@stigmer/runner 3.12.4 → 3.12.6

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

@@ -56,6 +56,7 @@ import {
   resolveCallerIdentity,
 } from "../../shared/caller-identity.js";
 import { readSessionContext } from "../../shared/session-context.js";
+import { readDeclaredPreferences } from "../../shared/declared-preferences.js";
 import { withholdSecretContentFromMessages } from "../../shared/tool-row.js";
 import { StallTimeoutError, formatStallFailure } from "../../shared/stall-watchdog.js";
 import { resolveUsableArtifactStorage, loadArtifactStorageConfig, type ArtifactStorage } from "../../shared/artifact-storage.js";
@@ -71,7 +72,8 @@ import { DeltaEnricher } from "./delta-enricher.js";
 import { TodoTracker } from "./todo-tracker.js";
 import { StreamingUpdateScheduler, loadStreamingConfig } from "../../shared/streaming-scheduler.js";
 import { createCursorEventRecorder } from "./cursor-event-recorder.js";
-import { resolveMcpServers, toCursorMcpConfig, validateMcpServerEnv } from "./mcp-resolver.js";
+import { resolveMcpServers } from "../../shared/mcp-resolver.js";
+import { toCursorMcpConfig, validateMcpServerEnv } from "./cursor-mcp-config.js";
 import { resolveMcpTransportPosture } from "../../shared/mcp-transport-guard.js";
 import {
   discoverChannelMessaging,
@@ -85,7 +87,7 @@ import { injectSynthesizedAttachment } from "../../shared/synthesized-attachment
 import { mergeApprovalPolicies } from "./approval-policy.js";
 import { deriveActiveLeases, isUnattendedApprovalMode } from "../../shared/approval-policy.js";
 import { enabledToolsBySlug } from "../../shared/mcp-enabled-tools.js";
-import { backfillMcpServersIfNeeded } from "./connect-backfill.js";
+import { backfillMcpServersIfNeeded } from "../../shared/connect-backfill.js";
 import { resolveExecutionEnv } from "./env-resolver.js";
 import { resolveBlueprint } from "./blueprint-resolver.js";
 import { buildCursorSubAgentDefinitions } from "./subagent-config.js";
@@ -136,6 +138,7 @@ import { setInterceptorExecutionId, runWithExecutionContext } from "./fetch-inte
 import { closeProxySessions } from "./http2-interceptor.js";
 import { resolveModelId, ensureLoaded as ensurePricingLoaded } from "./model-pricing.js";
 import { resolveEffectiveServiceTier } from "../../shared/service-tier.js";
+import { resolveEffectiveThinkingMode } from "../../shared/thinking-mode.js";
 import { resolveServiceTierParams } from "./service-tier.js";
 import { UsageAccumulator } from "./usage-accumulator.js";
 import { StreamingUsageSummarySchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/usage_pb";
@@ -147,7 +150,7 @@ import type { ClassifiedError } from "./error-classifier.js";
 import { createAgent, createCloudAgent } from "./session-lifecycle.js";
 import { setMaxListeners } from "node:events";
 import { startHeartbeat } from "../../shared/heartbeat.js";
-import { getShutdownSignalForQueue } from "../../runner-manager.js";
+import { classifyTurnInterruption, getShutdownSignalForQueue } from "../../shared/worker-shutdown.js";
 
 /**
  * Creates the activity functions bound to the runner config.
@@ -627,16 +630,19 @@ async function executeCursorInner(
       ),
       sessionId,
     );
-    let mcpResolution = await resolveMcpServers(
+    // The resolved-server list mutates through backfill and attachment
+    // injection below; the Cursor SDK config is projected from it exactly
+    // once, after the last mutation (see toCursorMcpConfig).
+    let resolvedMcpServers = (await resolveMcpServers(
       client, blueprint.mergedMcpServerUsages, mcpEnvVars, transportPosture,
-    );
+    )).resolvedServers;
     setupTiming.mark("resolve_mcp_servers");
 
     // Phase 4a: Connect backfill for undiscovered MCP servers
     heartbeatPhase = "resolving_mcp_servers";
     const sessionOrg = session.metadata?.org ?? "";
-    mcpResolution = await backfillMcpServersIfNeeded(
-      client, mcpResolution, blueprint.mergedMcpServerUsages, mcpEnvVars, sessionOrg,
+    resolvedMcpServers = await backfillMcpServersIfNeeded(
+      client, resolvedMcpServers, blueprint.mergedMcpServerUsages, mcpEnvVars, sessionOrg,
       transportPosture, heartbeat, secretKeys,
     );
     setupTiming.mark("backfill_mcp");
@@ -684,13 +690,9 @@ async function executeCursorInner(
         backendEndpoint: config.stigmerBackendEndpoint,
       });
       if (attachment) {
-        const resolvedServers = injectSynthesizedAttachment(
-          mcpResolution.resolvedServers, attachment, "channel messaging",
+        resolvedMcpServers = injectSynthesizedAttachment(
+          resolvedMcpServers, attachment, "channel messaging",
         );
-        mcpResolution = {
-          resolvedServers,
-          cursorConfig: toCursorMcpConfig(resolvedServers),
-        };
       }
     }
 
@@ -710,15 +712,13 @@ async function executeCursorInner(
       },
     );
     if (conversationAttachment) {
-      const resolvedServers = injectSynthesizedAttachment(
-        mcpResolution.resolvedServers, conversationAttachment, "conversation participation",
+      resolvedMcpServers = injectSynthesizedAttachment(
+        resolvedMcpServers, conversationAttachment, "conversation participation",
       );
-      mcpResolution = {
-        resolvedServers,
-        cursorConfig: toCursorMcpConfig(resolvedServers),
-      };
     }
-    const mcpConfig = mcpResolution.cursorConfig;
+    // The one projection point: every mutation above is now visible in the
+    // Cursor SDK config by construction (no per-mutation rebuild to forget).
+    const mcpConfig = toCursorMcpConfig(resolvedMcpServers);
 
     // Phase 4b: Merge approval policies from all layers.
     //
@@ -734,16 +734,15 @@ async function executeCursorInner(
     // see ResolvedMcpServer.toolApprovalOverrides (issue #349) — so there
     // is no separate override input to pass here.
     const mergedPolicies = mergeApprovalPolicies(
-      mcpResolution.resolvedServers,
+      resolvedMcpServers,
       leases,
     );
     heartbeat();
 
     // Phase 4c: Validate MCP server env health (diagnostic, non-blocking)
     const mcpWarnings = validateMcpServerEnv(
-      mcpResolution.resolvedServers,
+      resolvedMcpServers,
       blueprint.mergedMcpServerUsages,
-      envVars,
     );
     if (mcpWarnings.length > 0) {
       console.warn(
@@ -910,7 +909,7 @@ async function executeCursorInner(
       // servers' allow-lists, enforced by the hook's "disabled" arm ahead of
       // every approval bypass. The Cursor SDK config cannot hide a server's
       // tools, so this deny-at-call is the harness's enforcement.
-      enabledToolsBySlug(mcpResolution.resolvedServers),
+      enabledToolsBySlug(resolvedMcpServers),
     );
     const hitlGate = await installHitlGate({
       workspaceRoot: primaryWorkspaceDir,
@@ -962,9 +961,10 @@ async function executeCursorInner(
     await ensurePricingLoaded();
     setupTiming.mark("load_pricing");
 
-    // 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.
+    // Phase 6: Validate model selection and resolve the variant attributes.
+    // UNSPECIFIED → STANDARD (#357) and UNSPECIFIED → DISABLED (#772)
+    // resolve here and nowhere else: every upstream layer preserves the
+    // caller's raw enum values.
     const requestedModel = spec.executionConfig?.modelName || "default";
     const validatedModel = resolveModelId(requestedModel);
     if (validatedModel !== requestedModel) {
@@ -973,6 +973,7 @@ async function executeCursorInner(
       );
     }
     const requestedServiceTier = resolveEffectiveServiceTier(spec.executionConfig?.serviceTier);
+    const requestedThinkingMode = resolveEffectiveThinkingMode(spec.executionConfig?.thinkingMode);
 
     heartbeat();
 
@@ -1007,13 +1008,15 @@ 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).
+    // Translate the tier + thinking mode 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 served variant
+    // (#357 fast pricing, #772 thinking).
     const modelParams = await resolveServiceTierParams({
       apiKey: effectiveApiKey,
       modelId: validatedModel,
       tier: requestedServiceTier,
+      thinking: requestedThinkingMode,
       executionId,
     });
 
@@ -1175,6 +1178,7 @@ async function executeCursorInner(
       contextBridge: readContextBridge(blueprint.sessionSpec.metadata),
       senderIdentity: readSenderIdentity(blueprint.sessionSpec.metadata),
       sessionContext: readSessionContext(blueprint.sessionSpec.metadata),
+      declaredPreferences: readDeclaredPreferences(spec.declaredPreferences),
       conversationCatchup: readConversationCatchup(spec.conversationCatchup),
       // The turn's recorded transcript, seeded from the persisted execution
       // on a reinvocation (Phase 3). Consumed only by the HITL-recovery
@@ -1229,6 +1233,7 @@ async function executeCursorInner(
       validatedModel,
       requestedServiceTier,
       modelParams,
+      requestedThinkingMode,
     );
 
     // Phase 10c: Start OTel turn span. Coarse-grained — spans the whole turn
@@ -1401,13 +1406,21 @@ async function executeCursorInner(
     // classifies a shutdown from the shutdown signal directly (in
     // resolvePreBoundaryTerminal). The heartbeat timer may set `cancelled` before
     // the AbortSignal microtask propagates; the direct signal check catches that.
-    const isShutdown = periodicHeartbeat.workerShutdown || (shutdownSignal?.aborted ?? false);
-    if (isShutdown) {
+    // The decision table (including #776's grace-window guard: an aborted
+    // shutdown signal with NO interruption evidence stays "none") lives in
+    // classifyTurnInterruption — shared/worker-shutdown.ts.
+    const interruption = classifyTurnInterruption({
+      heartbeatCancelled: periodicHeartbeat.cancelled,
+      heartbeatWorkerShutdown: periodicHeartbeat.workerShutdown,
+      cancellationSignalAborted: Context.current().cancellationSignal.aborted,
+      shutdownSignalAborted: shutdownSignal?.aborted ?? false,
+    });
+    if (interruption === "worker-shutdown") {
       turnState.pauseDetected = false;
-    } else if (periodicHeartbeat.cancelled) {
+    } else if (interruption === "pause") {
       turnState.pauseDetected = true;
     }
-    workerShutdownDetected = isShutdown;
+    workerShutdownDetected = interruption === "worker-shutdown";
 
     // Post-stream finalize, shared by the primary turn and both recovery retries:
     // finalize the transcript + streaming flags, mark any in-flight sub-agent
@@ -1505,10 +1518,16 @@ async function executeCursorInner(
         return { kind: "return" };
       }
 
-      // Worker shutdown: the runner-manager aborted the shutdown signal. NOT a
+      // Worker shutdown: the runner/manager aborted the shutdown signal. NOT a
       // user pause. Checked via the shutdown signal directly so a retry (whose
-      // periodic heartbeat is already stopped) still classifies it correctly.
-      if (workerShutdownDetected || (shutdownSignal?.aborted ?? false)) {
+      // periodic heartbeat is already stopped) still classifies it correctly —
+      // but only alongside a delivered cancellation: a retry that completed
+      // normally inside the drain grace window must stay a completion (#776's
+      // grace-window guard, mirroring the primary's `interrupted` gate).
+      if (
+        workerShutdownDetected ||
+        ((shutdownSignal?.aborted ?? false) && Context.current().cancellationSignal.aborted)
+      ) {
         status.phase = ExecutionPhase.EXECUTION_FAILED;
         status.error = "Execution interrupted: runner worker was shut down. Retry or resume.";
         status.completedAt = utcTimestamp();
@@ -1806,6 +1825,7 @@ async function executeCursorInner(
           fallbackContext: { model: validatedModel, mode: agentMode, agentId: resolution.agentId },
           durationMs: (result as unknown as Record<string, unknown>).durationMs as number | undefined,
           messageCount: status.messages.length,
+          proxyMode: !!config.proxyEndpoint,
         });
 
         console.error(
@@ -1865,6 +1885,7 @@ async function executeCursorInner(
             contextBridge: readContextBridge(blueprint.sessionSpec.metadata),
             senderIdentity: readSenderIdentity(blueprint.sessionSpec.metadata),
             sessionContext: readSessionContext(blueprint.sessionSpec.metadata),
+            declaredPreferences: readDeclaredPreferences(spec.declaredPreferences),
             conversationCatchup: readConversationCatchup(spec.conversationCatchup),
             // Composed fresh (not reused from Phase 10): the failed primary
             // stream may have appended partial work onto status.messages,
@@ -1944,6 +1965,7 @@ async function executeCursorInner(
             conversationErrorText: retryConversationErrorText,
             isResumedHandle: false,
             fallbackContext: { model: validatedModel, mode: agentMode, agentId: freshAgent.agentId },
+            proxyMode: !!config.proxyEndpoint,
           });
 
           status.phase = ExecutionPhase.EXECUTION_FAILED;
@@ -2150,9 +2172,12 @@ async function executeCursorInner(
     periodicHeartbeat?.stop();
 
     if (err instanceof CancelledFailure) {
-      // workerShutdownDetected means the runner-manager signaled shutdown
-      // before the worker drained. This is infrastructure failure, not pause.
-      if (workerShutdownDetected) {
+      // Worker shutdown is infrastructure failure, not pause. The direct
+      // signal check covers a CancelledFailure thrown BEFORE the post-stream
+      // classification ran (workerShutdownDetected still false); no extra
+      // interruption-evidence gate is needed here — the caught
+      // CancelledFailure IS the evidence (#776).
+      if (workerShutdownDetected || (shutdownSignal?.aborted ?? false)) {
         console.log(`ExecuteCursor cancelled (worker shutdown) for execution ${executionId}`);
         status.phase = ExecutionPhase.EXECUTION_FAILED;
         status.error = "Execution interrupted: runner worker was shut down. Retry or resume.";
@@ -2242,6 +2267,7 @@ async function executeCursorInner(
         capturedRejection: getCapturedRejection(executionId),
         isResumedHandle: false,
         fallbackContext: errorContext,
+        proxyMode: !!config.proxyEndpoint,
       });
       clearCapturedRejection(executionId);
       status.phase = ExecutionPhase.EXECUTION_FAILED;
@@ -2451,10 +2477,19 @@ export interface BuildPromptInput {
    * turn.
    */
   sessionContext?: string;
+  /**
+   * Platform-declared standing preferences from the execution spec's
+   * `declared_preferences` (stigmer/stigmer#293). Like the bridge, only
+   * the enhanced-prompt path consumes it — deliberately frozen per Cursor
+   * session (DD-002 D3): the first turn delivers it into the agent's own
+   * conversation store, and repeating it on resumed turns would bloat the
+   * store with identical content.
+   */
+  declaredPreferences?: import("../../shared/declared-preferences.js").DeclaredPreferencesContent;
   /**
    * Conversation catchup from the execution spec's `conversation_catchup`
    * (cloud DD-006): what happened on the channel conversation that the
-   * agent has not seen. PER-TURN, so unlike the three standing values
+   * agent has not seen. PER-TURN, so unlike the standing values
    * above it rides BOTH prompt paths — the enhanced prompt and a resumed
    * turn's prefix (the `interaction_mode` shape). Handback lands
    * mid-session on a resumed agent: the resumed path is the one that
@@ -2589,6 +2624,7 @@ export function buildPrompt(input: BuildPromptInput): string {
           contextBridge: input.contextBridge,
           senderIdentity: input.senderIdentity,
           sessionContext: input.sessionContext,
+          declaredPreferences: input.declaredPreferences,
           conversationCatchup,
         },
         {
@@ -2655,6 +2691,7 @@ export function buildPrompt(input: BuildPromptInput): string {
     contextBridge: input.contextBridge,
     senderIdentity: input.senderIdentity,
     sessionContext: input.sessionContext,
+    declaredPreferences: input.declaredPreferences,
     conversationCatchup,
   });
 }

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

@@ -31,6 +31,10 @@ import {
   type SenderIdentity,
 } from "../../shared/sender-identity.js";
 import { formatSessionContextText } from "../../shared/session-context.js";
+import {
+  formatDeclaredPreferencesText,
+  type DeclaredPreferencesContent,
+} from "../../shared/declared-preferences.js";
 import {
   visionDisclosureLines,
   type NotViewableEntry,
@@ -147,11 +151,20 @@ export interface EnhancedPromptOptions {
    * store — the context is constant for the session's lifetime.
    */
   sessionContext?: string;
+  /**
+   * Platform-declared standing preferences (stigmer/stigmer#293): the org's
+   * and user's standing context, server-snapshotted onto the execution
+   * spec's `declared_preferences` at create. Like the bridge, it lands in
+   * the first message and persists in the cursor agent's own conversation
+   * store — deliberately frozen per Cursor session (DD-002 D3): repeating
+   * it every resumed turn would bloat the store with identical content.
+   */
+  declaredPreferences?: DeclaredPreferencesContent;
   /**
    * Conversation catchup (cloud DD-006): what happened on the channel
    * conversation that the agent has not seen, read from the execution
-   * spec's `conversation_catchup`. PER-TURN, unlike the three standing
-   * siblings above: it rides BOTH prompt paths — this enhanced prompt and
+   * spec's `conversation_catchup`. PER-TURN, unlike the standing siblings
+   * above: it rides BOTH prompt paths — this enhanced prompt and
    * a resumed turn's prefix (the `interaction_mode` shape) — because
    * handback lands mid-session on a resumed agent, the exact case the
    * metadata lane cannot reach.
@@ -232,6 +245,14 @@ export function buildEnhancedPrompt(options: EnhancedPromptOptions): string {
     sections.push(formatSenderIdentitySection(options.senderIdentity));
   }
 
+  // Platform-declared standing facts precede embedder-supplied context
+  // (DD-002 D3): both are standing background, but the declared preferences
+  // are platform-authored while session context is the embedder's overlay —
+  // the more specific overlay reads later and naturally refines.
+  if (options.declaredPreferences) {
+    sections.push(formatDeclaredPreferencesSection(options.declaredPreferences));
+  }
+
   // Standing facts about the user (session context) come before the
   // carried conversation (bridge): the bridge may refer back to them.
   if (options.sessionContext) {
@@ -445,6 +466,12 @@ export function formatSenderIdentitySection(identity: SenderIdentity): string {
   return `<conversation_sender>\n${formatSenderIdentityText(identity)}\n</conversation_sender>`;
 }
 
+export function formatDeclaredPreferencesSection(
+  preferences: DeclaredPreferencesContent,
+): string {
+  return `<declared_preferences>\n${formatDeclaredPreferencesText(preferences)}\n</declared_preferences>`;
+}
+
 export function formatSessionContextSection(context: string): string {
   return `<session_context>\n${formatSessionContextText(context)}\n</session_context>`;
 }

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

@@ -1,18 +1,23 @@
 /**
- * Service-tier → Cursor variant-parameter translation (stigmer/stigmer#357).
+ * Variant-attribute → Cursor variant-parameter translation
+ * (stigmer/stigmer#357 service tier, #772 thinking mode).
  *
  * 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:
+ * A bare `{ id }` lets the Cursor catalog's default variant decide the
+ * variant (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 user-selectable
+ * variant parameter the model declares, so the served variant is a
+ * deterministic function of the execution config:
  *
- * - 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 —
+ * - fast: pinned from ExecutionConfig.service_tier (FAST → true).
+ *   Price-bearing — the fast variant bills at pricingVariants.fast rates.
+ * - thinking: pinned from ExecutionConfig.thinking_mode (ENABLED → true).
+ *   Per-token price-neutral (ledger-verified 2026-08-15: thinking wire ids
+ *   bill exactly base rates; thinking+fast bills exactly the fast rate) —
+ *   pinned anyway because the served variant must never follow the account
+ *   default, and ENABLED turns consume more output (reasoning) tokens.
+ * - Parameters that are neither (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
@@ -20,17 +25,19 @@
  * rides the same proxy fetch-interceptor as every other SDK call, so it
  * works identically in proxy and direct modes.
  *
- * The harness-neutral halves — the tier enum semantics, and the single
- * UNSPECIFIED→STANDARD resolution point — live in
- * `shared/service-tier.ts` since #361 extended tiers to the native
- * harness; this module keeps only the Cursor-catalog translation.
+ * The harness-neutral halves — the enum semantics and the single
+ * UNSPECIFIED→default resolution points — live in `shared/service-tier.ts`
+ * (since #361 extended tiers to the native harness) and
+ * `shared/thinking-mode.ts`; this module keeps only the Cursor-catalog
+ * translation.
  */
 
 import { Cursor } from "@cursor/sdk";
 import type { ModelListItem, ModelParameterValue } from "@cursor/sdk";
-import { ServiceTier } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { ServiceTier, ThinkingMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 
 import { serviceTierLabel, type EffectiveServiceTier } from "../../shared/service-tier.js";
+import { thinkingModeLabel, type EffectiveThinkingMode } from "../../shared/thinking-mode.js";
 
 /**
  * Catalog ids that mean "Cursor picks the model" (Auto). Auto's single
@@ -42,9 +49,11 @@ import { serviceTierLabel, type EffectiveServiceTier } from "../../shared/servic
 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
+ * The user-selectable variant parameter ids. Pinning exactly these keeps
+ * the served variant deterministic while leaving effort knobs on their
+ * catalog defaults. `fast` changes the per-token price; `thinking` is
+ * price-neutral but changes token consumption and must never follow the
+ * account default. Sourced from the Cursor catalog survey
  * (stigmer-cloud _projects/2026-08/20260806.04.model-service-tier).
  */
 const FAST_PARAM_ID = "fast";
@@ -108,46 +117,55 @@ export interface ResolveServiceTierParamsOptions {
   /** Validated model id the execution runs on (may be "default" for Auto). */
   readonly modelId: string;
   readonly tier: EffectiveServiceTier;
+  readonly thinking: EffectiveThinkingMode;
   /** 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.
+ * Translate the effective tier + thinking mode 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.
+ * Fail-closed posture: an ACTIVE selection (FAST tier, ENABLED thinking)
+ * with no pinnable 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.
+ * The base selection (STANDARD + DISABLED) 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 (the
+ * incident this module exists to prevent). Failing every base execution
+ * whenever the catalog endpoint blips would be the worse trade; the WARN
+ * below plus billing's requested-vs-billed mismatch alarms (which catch
+ * exactly this window) are the compensating controls.
  */
 export async function resolveServiceTierParams(
   options: ResolveServiceTierParamsOptions,
 ): Promise<ModelParameterValue[]> {
-  const { apiKey, modelId, tier, executionId } = options;
+  const { apiKey, modelId, tier, thinking, executionId } = options;
   const tierName = serviceTierLabel(tier);
+  const thinkingName = thinkingModeLabel(thinking);
+  // Selections that actively deviate from the base variant must fail loudly
+  // when they cannot be pinned; the base selection may degrade with a WARN.
+  const active: string[] = [];
+  if (tier === ServiceTier.FAST) active.push("service_tier=fast");
+  if (thinking === ThinkingMode.ENABLED) active.push("thinking=enabled");
 
   if (AUTO_MODEL_IDS.has(modelId)) {
-    if (tier === ServiceTier.FAST) {
+    if (active.length > 0) {
       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.`,
+        `${active.join(" + ")} requires a pinned model — Auto ("${modelId}") has ` +
+        `no variant dimensions. 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).`,
+      `VariantParams: execution=${executionId} model=${modelId} tier=${tierName} ` +
+      `thinking=${thinkingName} — Auto has no variant parameters; Cursor picks ` +
+      `the model and variant (documented v1 limitation).`,
     );
     return [];
   }
@@ -156,37 +174,38 @@ export async function resolveServiceTierParams(
   try {
     models = await listCatalogModels(apiKey);
   } catch (err) {
-    if (tier === ServiceTier.FAST) {
+    if (active.length > 0) {
       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)}`,
+        `${active.join(" + ")} 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.`,
+      `VariantParams UNPINNED: execution=${executionId} model=${modelId} tier=${tierName} ` +
+      `thinking=${thinkingName} — catalog fetch failed ` +
+      `(${err instanceof Error ? err.message : err}); sending no variant params, ` +
+      `so the catalog DEFAULT variant decides the served variant for this ` +
+      `execution (fast/thinking on several models — the expensive direction). ` +
+      `Billing's requested-vs-billed mismatch alarms cover this window.`,
     );
     return [];
   }
 
   const model = findCatalogModel(models, modelId);
   if (!model) {
-    if (tier === ServiceTier.FAST) {
+    if (active.length > 0) {
       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.`,
+        `${active.join(" + ")} requested for "${modelId}" (execution ${executionId}) ` +
+        `but the Cursor catalog does not list that model — cannot pin its ` +
+        `variant parameters. 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.`,
+      `VariantParams UNPINNED: execution=${executionId} model=${modelId} tier=${tierName} ` +
+      `thinking=${thinkingName} — model not in the Cursor catalog; sending no ` +
+      `variant params, so the catalog DEFAULT variant decides the served ` +
+      `variant for this execution.`,
     );
     return [];
   }
@@ -196,10 +215,13 @@ export async function resolveServiceTierParams(
     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" });
+      params.push({
+        id: THINKING_PARAM_ID,
+        value: thinking === ThinkingMode.ENABLED ? "true" : "false",
+      });
     }
-    // Any other parameter (e.g. effort) is price-neutral: left to the
-    // catalog default variant on purpose.
+    // Any other parameter (e.g. effort) is price-neutral and not
+    // user-selectable: left to the catalog default variant on purpose.
   }
 
   if (tier === ServiceTier.FAST && !params.some((p) => p.id === FAST_PARAM_ID)) {
@@ -211,10 +233,19 @@ export async function resolveServiceTierParams(
     );
   }
 
+  if (thinking === ThinkingMode.ENABLED && !params.some((p) => p.id === THINKING_PARAM_ID)) {
+    throw new Error(
+      `thinking=enabled requested for "${modelId}" (execution ${executionId}) ` +
+      `but the Cursor catalog declares no "thinking" parameter for it. The ` +
+      `model registry claims a thinking capability the provider no longer ` +
+      `offers — refusing rather than silently serving the base variant.`,
+    );
+  }
+
   params.sort((a, b) => a.id.localeCompare(b.id));
   console.log(
-    `ServiceTier: execution=${executionId} model=${modelId} tier=${tierName} ` +
-    `params=${JSON.stringify(params)}`,
+    `VariantParams: execution=${executionId} model=${modelId} tier=${tierName} ` +
+    `thinking=${thinkingName} params=${JSON.stringify(params)}`,
   );
   return params;
 }

package/src/activities/execute-cursor/session-lifecycle.ts

@@ -47,7 +47,7 @@ import type {
   ModelParameterValue,
 } from "@cursor/sdk";
 import { withTimeout, TimeoutError } from "../../shared/with-timeout.js";
-import type { CursorMcpServerConfig } from "./mcp-resolver.js";
+import type { CursorMcpServerConfig } from "./cursor-mcp-config.js";
 
 // ---------------------------------------------------------------------------
 // Constants