@stigmer/runner 3.12.3 → 3.12.5

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

@@ -41,6 +41,7 @@ import type { Config } from "../../config.js";
 import { StigmerClient } from "../../client/stigmer-client.js";
 import { describeExecutionError } from "../../shared/model-error.js";
 import { resolveAgentWithTransportRecovery } from "./session-lifecycle.js";
+import { cacheSessionAgent, computeAgentFingerprint, takeCachedAgent } from "./agent-session-cache.js";
 import type { AgentResolution, AgentResolutionReason, CreateAgentOptions, CreateCloudAgentOptions } from "./session-lifecycle.js";
 import { CursorMode } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
 import { determineCursorMode, isCloudMode } from "./cursor-mode.js";
@@ -55,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";
@@ -70,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,
@@ -84,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";
@@ -134,7 +137,8 @@ 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 { resolveEffectiveServiceTier } from "../../shared/service-tier.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";
 import { activityStarted, activityFinished } from "../../idle-watchdog.js";
@@ -145,7 +149,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.
@@ -625,16 +629,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");
@@ -682,13 +689,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),
-        };
       }
     }
 
@@ -708,15 +711,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.
     //
@@ -732,16 +733,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(
@@ -908,7 +908,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,
@@ -1052,21 +1052,52 @@ async function executeCursorInner(
     // is the largest user-visible setup segment; this split keeps its
     // historical meaning — the SDK call was already 98%+ of it).
     setupTiming.mark("prepare_agent");
-    let resolution: AgentResolution = await resolveAgentWithTransportRecovery({
-      harnessStateId: threadId,
-      createOptions,
-      mode: agentMode,
-      timeoutMs: config.agentResolveTimeoutMs,
-      buildTimeoutMessage: (finalAttempt) =>
-        `Cursor agent ${threadId ? "resume" : "create"} timed out after ${resolveTimeoutSeconds}s ` +
-        `(${config.proxyEndpoint ? `via proxy ${config.proxyEndpoint}` : "direct Cursor API connection"}). ` +
-        `The transport connection is likely dead. ` +
-        (finalAttempt
-          ? `An automatic retry on a fresh transport connection also timed out. ` +
-            `Retry the message later; if this persists, check proxy and network health.`
-          : `Resetting the transport and retrying automatically.`),
-      resetTransport: closeProxySessions,
-    });
+
+    // Phase 8a: Reuse the previous turn's agent when this session parked one
+    // (#215). A checkout hit skips Agent.resume() AND — the real win — keeps
+    // the SDK executor lease alive, so agent.send() below re-acquires the
+    // warm executor instead of re-spawning every stdio MCP server (the
+    // measured 2.2–3.2s `send_returned` tax). The fingerprint covers the
+    // full acquisition config, so any drift (rotated credential, edited MCP
+    // servers, model change) falls through to a fresh resolve.
+    const agentFingerprint = computeAgentFingerprint(
+      createOptions as unknown as Record<string, unknown>,
+    );
+    const parkedAgent = takeCachedAgent(sessionId, agentFingerprint, threadId ?? "");
+    let resolution: AgentResolution;
+    if (parkedAgent) {
+      console.log(
+        `ExecuteCursor reusing parked session agent: execution=${executionId}, ` +
+        `session=${sessionId}, agentId=${parkedAgent.agentId}`,
+      );
+      resolution = {
+        agent: parkedAgent as AgentResolution["agent"],
+        agentId: parkedAgent.agentId,
+        isNew: false,
+        resumed: true,
+        mode: agentMode,
+        // The parked handle IS the live conversation — every consumer of
+        // "resumed_successfully" (prompt selection, poisoned-handle
+        // recovery eligibility) wants exactly those semantics.
+        reason: "resumed_successfully",
+      };
+    } else {
+      resolution = await resolveAgentWithTransportRecovery({
+        harnessStateId: threadId,
+        createOptions,
+        mode: agentMode,
+        timeoutMs: config.agentResolveTimeoutMs,
+        buildTimeoutMessage: (finalAttempt) =>
+          `Cursor agent ${threadId ? "resume" : "create"} timed out after ${resolveTimeoutSeconds}s ` +
+          `(${config.proxyEndpoint ? `via proxy ${config.proxyEndpoint}` : "direct Cursor API connection"}). ` +
+          `The transport connection is likely dead. ` +
+          (finalAttempt
+            ? `An automatic retry on a fresh transport connection also timed out. ` +
+              `Retry the message later; if this persists, check proxy and network health.`
+            : `Resetting the transport and retrying automatically.`),
+        resetTransport: closeProxySessions,
+      });
+    }
 
     console.log(
       `ExecuteCursor agent resolved: execution=${executionId}, ` +
@@ -1142,6 +1173,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
@@ -1368,13 +1400,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
@@ -1462,7 +1502,9 @@ async function executeCursorInner(
           timestamp: utcTimestamp(),
         }));
         await persist(status);
-        try { resolution.agent.close(); } catch { /* best effort */ }
+        // Clean terminal: the conversation continues on the next message,
+        // so park the healthy agent for that turn (#215).
+        cacheSessionAgent(sessionId ?? "", resolution.agent, agentFingerprint);
         console.warn(
           `ExecuteCursor terminated (cost cap): execution=${executionId}, ` +
           `estimatedCostUsd=${estimated.toFixed(4)}, maxCostUsd=${maxCostUsd.toFixed(2)}`,
@@ -1470,10 +1512,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();
@@ -1527,7 +1575,8 @@ async function executeCursorInner(
           timestamp: utcTimestamp(),
         }));
         await persist(status);
-        try { resolution.agent.close(); } catch { /* best effort */ }
+        // Clean terminal — park for the session's next turn (#215).
+        cacheSessionAgent(sessionId ?? "", resolution.agent, agentFingerprint);
         console.log(`ExecuteCursor completed (platform stop): execution=${executionId}`);
         return { kind: "return" };
       }
@@ -1573,6 +1622,12 @@ async function executeCursorInner(
     const enterApprovalPause = async (boundary: TurnBoundaryResult) => {
       status.phase = ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL;
       await persist(status);
+      // The approval-resume reinvocation is the cache's best case: park the
+      // agent so the resumed turn skips the full executor rebuild (#215).
+      // (This path previously dropped the handle without close() — the
+      // lease leaked; parking makes the lifetime explicit.) An absent
+      // sessionId falls back to "" — the cache closes the lease immediately.
+      cacheSessionAgent(sessionId ?? "", resolution.agent, agentFingerprint);
       console.log(
         `ExecuteCursor returning WAITING_FOR_APPROVAL: ${boundary.deniedToolCallCount} gated tool(s), ` +
         `${boundary.capturedChangeCount} file card(s) pending`,
@@ -1823,6 +1878,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,
@@ -2088,8 +2144,12 @@ async function executeCursorInner(
         (status.error ? `, error=${status.error}` : ""),
     );
 
-    // Release SDK executor lease to prevent cache buildup across workflow tasks
-    try { resolution.agent.close(); } catch { /* best effort */ }
+    // Park the agent (with its executor lease) for the session's next turn
+    // instead of closing it — the idle TTL / shutdown hooks in
+    // agent-session-cache own the eventual release, so cache buildup across
+    // sessions stays bounded while turns of ONE session stop paying the
+    // executor + MCP re-spawn tax (#215).
+    cacheSessionAgent(sessionId ?? "", resolution.agent, agentFingerprint);
 
     const slim = slimStatus(status) as Record<string, unknown>;
     if (finalText !== undefined) {
@@ -2104,9 +2164,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.";
@@ -2405,10 +2468,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
@@ -2543,6 +2615,7 @@ export function buildPrompt(input: BuildPromptInput): string {
           contextBridge: input.contextBridge,
           senderIdentity: input.senderIdentity,
           sessionContext: input.sessionContext,
+          declaredPreferences: input.declaredPreferences,
           conversationCatchup,
         },
         {
@@ -2609,6 +2682,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

@@ -20,19 +20,17 @@
  * 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.
+ * 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.
  */
 
 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;
+import { serviceTierLabel, type EffectiveServiceTier } from "../../shared/service-tier.js";
 
 /**
  * Catalog ids that mean "Cursor picks the model" (Auto). Auto's single
@@ -72,28 +70,6 @@ export function resetCatalogCacheForTests(): void {
   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) {

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