@stigmer/runner 3.6.0 → 3.8.0

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

@@ -0,0 +1,170 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ServiceTier } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+/**
+ * Verifies the service-tier → Cursor variant-parameter translation (#357):
+ * the runner must always send an explicit selection whose price-bearing
+ * parameters are a deterministic function of the requested tier — never
+ * the catalog's (account-influenced) default variant.
+ *
+ * Catalog fixtures mirror the real shapes observed 2026-08-06: composer
+ * has a `fast` bool (default fast=true), haiku has a `thinking` bool
+ * (default thinking=true), grok has `effort` x `fast`, and Auto
+ * ("default") has a single variant with no parameters.
+ */
+const listMock = vi.hoisted(() => vi.fn());
+
+vi.mock("@cursor/sdk", () => ({
+  Cursor: { models: { list: listMock } },
+}));
+
+import {
+  resolveEffectiveServiceTier,
+  resolveServiceTierParams,
+  resetCatalogCacheForTests,
+} from "../service-tier.js";
+
+const CATALOG = [
+  {
+    id: "composer-2.5",
+    displayName: "Composer 2.5",
+    aliases: ["composer-latest", "composer"],
+    parameters: [
+      { id: "fast", values: [{ value: "false" }, { value: "true" }] },
+    ],
+  },
+  {
+    id: "claude-haiku-4-5",
+    displayName: "Haiku 4.5",
+    aliases: ["haiku"],
+    parameters: [
+      { id: "thinking", values: [{ value: "false" }, { value: "true" }] },
+    ],
+  },
+  {
+    id: "grok-4.5",
+    displayName: "Cursor Grok 4.5",
+    parameters: [
+      { id: "effort", values: [{ value: "low" }, { value: "medium" }, { value: "high" }] },
+      { id: "fast", values: [{ value: "false" }, { value: "true" }] },
+    ],
+  },
+  {
+    id: "claude-opus-4-8",
+    displayName: "Opus 4.8",
+    parameters: [
+      { id: "thinking", values: [{ value: "false" }, { value: "true" }] },
+      { id: "effort", values: [{ value: "low" }, { value: "high" }] },
+      { id: "fast", values: [{ value: "false" }, { value: "true" }] },
+    ],
+  },
+  {
+    id: "default",
+    displayName: "Auto",
+    aliases: ["auto"],
+    variants: [{ params: [], displayName: "Auto", isDefault: true }],
+  },
+];
+
+function opts(modelId: string, tier: ServiceTier.STANDARD | ServiceTier.FAST) {
+  return { apiKey: "key-1", modelId, tier, executionId: "aex_test" };
+}
+
+beforeEach(() => {
+  resetCatalogCacheForTests();
+  listMock.mockReset();
+  listMock.mockResolvedValue(CATALOG);
+});
+
+describe("resolveEffectiveServiceTier", () => {
+  it("resolves UNSPECIFIED to STANDARD — never the account default", () => {
+    expect(resolveEffectiveServiceTier(ServiceTier.UNSPECIFIED)).toBe(ServiceTier.STANDARD);
+    expect(resolveEffectiveServiceTier(undefined)).toBe(ServiceTier.STANDARD);
+  });
+
+  it("preserves explicit STANDARD and FAST", () => {
+    expect(resolveEffectiveServiceTier(ServiceTier.STANDARD)).toBe(ServiceTier.STANDARD);
+    expect(resolveEffectiveServiceTier(ServiceTier.FAST)).toBe(ServiceTier.FAST);
+  });
+});
+
+describe("resolveServiceTierParams", () => {
+  it("STANDARD pins fast=false on a fast-capable model", async () => {
+    const params = await resolveServiceTierParams(opts("composer-2.5", ServiceTier.STANDARD));
+    expect(params).toEqual([{ id: "fast", value: "false" }]);
+  });
+
+  it("FAST pins fast=true on a fast-capable model", async () => {
+    const params = await resolveServiceTierParams(opts("composer-2.5", ServiceTier.FAST));
+    expect(params).toEqual([{ id: "fast", value: "true" }]);
+  });
+
+  it("STANDARD pins thinking=false on a thinking-capable model (the haiku drift)", async () => {
+    const params = await resolveServiceTierParams(opts("claude-haiku-4-5", ServiceTier.STANDARD));
+    expect(params).toEqual([{ id: "thinking", value: "false" }]);
+  });
+
+  it("FAST on a model with no fast parameter fails loudly, never downgrades", async () => {
+    await expect(
+      resolveServiceTierParams(opts("claude-haiku-4-5", ServiceTier.FAST)),
+    ).rejects.toThrow(/no "fast" parameter/);
+  });
+
+  it("leaves price-neutral parameters (effort) to the catalog default", async () => {
+    const params = await resolveServiceTierParams(opts("grok-4.5", ServiceTier.STANDARD));
+    expect(params).toEqual([{ id: "fast", value: "false" }]);
+  });
+
+  it("pins every price-bearing parameter, sorted, on multi-dimension models", async () => {
+    const params = await resolveServiceTierParams(opts("claude-opus-4-8", ServiceTier.FAST));
+    expect(params).toEqual([
+      { id: "fast", value: "true" },
+      { id: "thinking", value: "false" },
+    ]);
+  });
+
+  it("resolves models referenced by alias", async () => {
+    const params = await resolveServiceTierParams(opts("composer", ServiceTier.STANDARD));
+    expect(params).toEqual([{ id: "fast", value: "false" }]);
+  });
+
+  it("Auto has no tier dimension: STANDARD sends no params", async () => {
+    const params = await resolveServiceTierParams(opts("default", ServiceTier.STANDARD));
+    expect(params).toEqual([]);
+    // No catalog fetch needed for Auto — nothing to look up.
+    expect(listMock).not.toHaveBeenCalled();
+  });
+
+  it("Auto + FAST is a loud failure (registry/catalog drift, not a silent no-op)", async () => {
+    await expect(
+      resolveServiceTierParams(opts("default", ServiceTier.FAST)),
+    ).rejects.toThrow(/requires a pinned model/);
+  });
+
+  it("unknown model: STANDARD degrades to no params, FAST fails loudly", async () => {
+    await expect(
+      resolveServiceTierParams(opts("not-a-model", ServiceTier.STANDARD)),
+    ).resolves.toEqual([]);
+    await expect(
+      resolveServiceTierParams(opts("not-a-model", ServiceTier.FAST)),
+    ).rejects.toThrow(/does not list that model/);
+  });
+
+  it("catalog fetch failure: STANDARD degrades, FAST fails loudly", async () => {
+    listMock.mockRejectedValue(new Error("proxy down"));
+    await expect(
+      resolveServiceTierParams(opts("composer-2.5", ServiceTier.STANDARD)),
+    ).resolves.toEqual([]);
+    resetCatalogCacheForTests();
+    listMock.mockRejectedValue(new Error("proxy down"));
+    await expect(
+      resolveServiceTierParams(opts("composer-2.5", ServiceTier.FAST)),
+    ).rejects.toThrow(/catalog fetch failed/);
+  });
+
+  it("caches the catalog per worker — one fetch for repeated resolutions", async () => {
+    await resolveServiceTierParams(opts("composer-2.5", ServiceTier.STANDARD));
+    await resolveServiceTierParams(opts("claude-haiku-4-5", ServiceTier.STANDARD));
+    expect(listMock).toHaveBeenCalledTimes(1);
+  });
+});

package/src/activities/execute-cursor/__tests__/usage-accumulator.test.ts

@@ -1,7 +1,45 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi, beforeAll } from "vitest";
+import { ServiceTier } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 
 import { UsageAccumulator } from "../usage-accumulator.js";
 
+// The accumulator's per-turn estimate reads the worker's pricing table
+// (model-pricing.ts); load it from a stubbed registry so the fast-rate
+// assertions run against known prices (the model-pricing.test.ts pattern).
+beforeAll(async () => {
+  const registry = {
+    models: [
+      {
+        id: "composer-2.5",
+        displayName: "Composer 2.5",
+        provider: "cursor",
+        harness: "cursor",
+        costTier: "economy",
+        pricing: {
+          inputPricePerMillion: 0.5,
+          outputPricePerMillion: 2.5,
+          cacheWritePricePerMillion: 0,
+          cacheReadPricePerMillion: 0.2,
+        },
+        pricingVariants: {
+          fast: {
+            inputPricePerMillion: 3.0,
+            outputPricePerMillion: 15.0,
+            cacheWritePricePerMillion: 0,
+            cacheReadPricePerMillion: 0.2,
+          },
+        },
+      },
+    ],
+  };
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async () => ({ ok: true, status: 200, json: async () => registry })),
+  );
+  process.env.STIGMER_TOKEN = "test-token";
+  await (await import("../model-pricing.js")).ensureLoaded();
+});
+
 /**
  * Guards the token-accounting convention the Usage widget and the billing
  * parity test both depend on: the Cursor SDK's inputTokens already INCLUDES
@@ -43,4 +81,52 @@ describe("UsageAccumulator", () => {
     expect(snap.outputTokens).toBe(0n);
     expect(snap.totalTokens).toBe(42n);
   });
+
+  it("records the requested tier and params into the snapshot (#357 audit trail)", () => {
+    const acc = new UsageAccumulator(
+      "composer-2.5",
+      ServiceTier.FAST,
+      [{ id: "fast", value: "true" }],
+    );
+    acc.addTurn({ inputTokens: 10, outputTokens: 5 });
+    const snap = acc.snapshot();
+    expect(snap.requestedServiceTier).toBe(ServiceTier.FAST);
+    expect(snap.requestedModelParams).toBe('[{"id":"fast","value":"true"}]');
+  });
+
+  it("records an empty params string when the runner sent none", () => {
+    const acc = new UsageAccumulator("default", ServiceTier.STANDARD, []);
+    acc.addTurn({ inputTokens: 1 });
+    const snap = acc.snapshot();
+    expect(snap.requestedServiceTier).toBe(ServiceTier.STANDARD);
+    expect(snap.requestedModelParams).toBe("");
+  });
+
+  it("estimates FAST runs at fast-variant rates, not base rates (#357)", () => {
+    // Revert guard for the tier→pricing wiring in addTurn: a FAST run
+    // priced at base rates would understate the display estimate ~6x
+    // relative to the authoritative bill. Rates from the stubbed registry:
+    // base $0.5/$2.5 per M, fast $3/$15 per M.
+    const turn = { inputTokens: 1_000_000, outputTokens: 1_000_000 };
+
+    const standard = new UsageAccumulator("composer-2.5", ServiceTier.STANDARD);
+    standard.addTurn(turn);
+    const fast = new UsageAccumulator("composer-2.5", ServiceTier.FAST);
+    fast.addTurn(turn);
+
+    expect(standard.snapshot().estimatedCostUsd).toBeCloseTo(3.0, 6);
+    expect(fast.snapshot().estimatedCostUsd).toBeCloseTo(18.0, 6);
+  });
+
+  it("estimates UNSPECIFIED at base rates (resolves to standard)", () => {
+    const turn = { inputTokens: 1_000_000, outputTokens: 1_000_000 };
+
+    const unspecified = new UsageAccumulator("composer-2.5");
+    unspecified.addTurn(turn);
+    const standard = new UsageAccumulator("composer-2.5", ServiceTier.STANDARD);
+    standard.addTurn(turn);
+
+    expect(unspecified.snapshot().estimatedCostUsd)
+      .toBe(standard.snapshot().estimatedCostUsd);
+  });
 });

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

@@ -48,6 +48,7 @@ import { MessageAccumulator, cancelInProgressSubAgentProtos, collapseRedundantTo
 import { utcTimestamp, persistStatus, reportSetupProgress, slimStatus } from "../../shared/status.js";
 import { TimingRecorder, emitTimingLog } from "../../shared/cold-start-timing.js";
 import { readContextBridge } from "../../shared/context-bridge.js";
+import { readConversationCatchup } from "../../shared/conversation-catchup.js";
 import { readSenderIdentity } from "../../shared/sender-identity.js";
 import {
   injectCallerIdentityEnv,
@@ -69,6 +70,10 @@ import {
   discoverChannelMessaging,
   synthesizeChannelAttachment,
 } from "../../shared/channel-attachment.js";
+import {
+  readChannelConversationId,
+  synthesizeConversationAttachment,
+} from "../../shared/conversation-attachment.js";
 import { injectSynthesizedAttachment } from "../../shared/synthesized-attachment.js";
 import { mergeApprovalPolicies } from "./approval-policy.js";
 import { deriveActiveLeases, isUnattendedApprovalMode } from "../../shared/approval-policy.js";
@@ -79,7 +84,7 @@ import { buildCursorSubAgentDefinitions } from "./subagent-config.js";
 import { resolveSkills } from "./skill-resolver.js";
 import { removeStigmerSymlink } from "../../shared/workspace/stigmer-link.js";
 import { resolveAttachments } from "./attachment-resolver.js";
-import { buildEnhancedPrompt, buildReinvocationPrompt, formatInteractionModePrefix, formatImplementPlanSection } from "./prompt-builder.js";
+import { buildEnhancedPrompt, buildReinvocationPrompt, formatConversationCatchupSection, formatInteractionModePrefix, formatImplementPlanSection } from "./prompt-builder.js";
 import { installHitlGate, removeHitlGate } from "./workspace-setup.js";
 import { ensureHitlDir } from "../../shared/workspace/platform-dir.js";
 import {
@@ -121,6 +126,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";
@@ -684,6 +690,31 @@ async function executeCursorInner(
         };
       }
     }
+
+    // Phase 4a4: Synthesize the conversation participation attachment
+    // (channel-conversations DD-008 D-c) — the third sibling. The
+    // channel-id session label IS the attachment decision (stamped
+    // server-side on every channel session; a free local read, unlike
+    // the channels discovery RPC above). HTTP-only: synthesize answers
+    // undefined with no bridge endpoint by design (see
+    // shared/conversation-attachment.ts).
+    const conversationAttachment = synthesizeConversationAttachment(
+      readChannelConversationId(session.metadata?.labels),
+      {
+        bridgeEndpoint: config.mcpBridgeEndpoint,
+        credential: attachmentCredential,
+        backendEndpoint: config.stigmerBackendEndpoint,
+      },
+    );
+    if (conversationAttachment) {
+      const resolvedServers = injectSynthesizedAttachment(
+        mcpResolution.resolvedServers, conversationAttachment, "conversation participation",
+      );
+      mcpResolution = {
+        resolvedServers,
+        cursorConfig: toCursorMcpConfig(resolvedServers),
+      };
+    }
     const mcpConfig = mcpResolution.cursorConfig;
 
     // Phase 4b: Merge approval policies from all layers.
@@ -889,7 +920,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) {
@@ -897,6 +930,7 @@ async function executeCursorInner(
         `ExecuteCursor model resolved: execution=${executionId}, requested="${requestedModel}", using="${validatedModel}"`,
       );
     }
+    const requestedServiceTier = resolveEffectiveServiceTier(spec.executionConfig?.serviceTier);
 
     heartbeat();
 
@@ -931,10 +965,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,
@@ -943,6 +988,7 @@ async function executeCursorInner(
       : {
           apiKey: effectiveApiKey,
           model: validatedModel,
+          modelParams,
           workspaceDirs: blueprint.workspaceDirs,
           sessionId,
           workspaceRootDir: config.workspaceRootDir,
@@ -1055,6 +1101,7 @@ async function executeCursorInner(
       contextBridge: readContextBridge(blueprint.sessionSpec.metadata),
       senderIdentity: readSenderIdentity(blueprint.sessionSpec.metadata),
       sessionContext: readSessionContext(blueprint.sessionSpec.metadata),
+      conversationCatchup: readConversationCatchup(spec.conversationCatchup),
     });
 
     // Phase 10a: Inject structured output instruction for Cursor harness
@@ -1075,7 +1122,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
@@ -1577,14 +1628,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();
 
@@ -1664,9 +1737,15 @@ async function executeCursorInner(
             attachmentPaths,
             pendingApprovals: adjudicatedApprovals,
             interactionMode,
+            // buildFromPlan was silently dropped here until T03 Sitting 3 —
+            // a build turn that hit handle recovery lost its directive. The
+            // fresh prompt must carry every per-turn directive the original
+            // did.
+            buildFromPlan,
             contextBridge: readContextBridge(blueprint.sessionSpec.metadata),
             senderIdentity: readSenderIdentity(blueprint.sessionSpec.metadata),
             sessionContext: readSessionContext(blueprint.sessionSpec.metadata),
+            conversationCatchup: readConversationCatchup(spec.conversationCatchup),
           });
 
           console.log(
@@ -2263,6 +2342,18 @@ export interface BuildPromptInput {
    * turn.
    */
   sessionContext?: string;
+  /**
+   * 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
+   * 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
+   * matters. Once delivered, the digest persists in the agent's own
+   * conversation store; the next turn's field is composed fresh and is
+   * usually blank.
+   */
+  conversationCatchup?: string;
 }
 
 /**
@@ -2294,6 +2385,7 @@ export function buildPrompt(input: BuildPromptInput): string {
     attachmentPaths,
     interactionMode,
     buildFromPlan,
+    conversationCatchup,
   } = input;
 
   const isHitlReinvocation = approvalDecisions !== undefined && approvalDecisions.size > 0;
@@ -2311,15 +2403,22 @@ export function buildPrompt(input: BuildPromptInput): string {
 
   // A successfully resumed agent carries its own conversation context via the
   // SDK's native store — send the raw user message with no preamble. The
-  // exceptions are the per-EXECUTION directives, which never inherit from the
+  // exceptions are the per-EXECUTION values, which never inherit from the
   // session's first turn: the interaction-mode prefix (a follow-up can switch
   // Agent→Plan mid-session, and for Cursor the prompt is the only plan-mode
-  // enforcement) and the implement-plan directive (the build turn is usually
-  // a follow-up on a resumed agent).
+  // enforcement), the implement-plan directive (the build turn is usually a
+  // follow-up on a resumed agent), and the conversation catchup (handback
+  // ALWAYS lands mid-session on a resumed agent — this prefix is the property
+  // the metadata lane structurally cannot deliver, cloud DD-006). Catchup
+  // last: it is context, and context sits closest to the task (the enhanced
+  // prompt's own ordering doctrine).
   if (resolution.reason === "resumed_successfully") {
     const prefixes = [
       formatInteractionModePrefix(interactionMode),
       formatImplementPlanSection(buildFromPlan, attachmentPaths),
+      conversationCatchup !== undefined
+        ? formatConversationCatchupSection(conversationCatchup)
+        : undefined,
     ].filter((p): p is string => p !== undefined);
     return prefixes.length > 0
       ? [...prefixes, userMessage].join("\n\n")
@@ -2344,6 +2443,7 @@ export function buildPrompt(input: BuildPromptInput): string {
     contextBridge: input.contextBridge,
     senderIdentity: input.senderIdentity,
     sessionContext: input.sessionContext,
+    conversationCatchup,
   });
 }
 

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

@@ -21,6 +21,7 @@ import type { DatastoreUsage, SubAgent } from "@stigmer/protos/ai/stigmer/agenti
 import type { PendingApproval } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/approval_pb";
 import { ApprovalAction, InteractionMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { formatContextBridgeText } from "../../shared/context-bridge.js";
+import { formatConversationCatchupText } from "../../shared/conversation-catchup.js";
 import { formatDatastoresSection } from "../../shared/datastore-attachment.js";
 import {
   formatChannelTemplatesSection,
@@ -107,6 +108,16 @@ export interface EnhancedPromptOptions {
    * store — the context is constant for the session's lifetime.
    */
   sessionContext?: string;
+  /**
+   * 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
+   * 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.
+   */
+  conversationCatchup?: string;
 }
 
 /**
@@ -200,6 +211,14 @@ export function buildEnhancedPrompt(options: EnhancedPromptOptions): string {
     sections.push(formatContextBridgeSection(options.contextBridge));
   }
 
+  // Catchup after the bridge (DD-007 D-d: bridge first, catchup second) —
+  // the bridge carries the pre-takeover conversation, the catchup the human
+  // episode, strictly newer by construction; recency puts it closer to the
+  // task.
+  if (options.conversationCatchup) {
+    sections.push(formatConversationCatchupSection(options.conversationCatchup));
+  }
+
   // Always last before the task: the platform's tool-approval protocol. Placed
   // here for recency so it outweighs any "ask the user first" guidance Cursor
   // surfaces from a connected MCP server (see formatToolApprovalProtocol).
@@ -345,6 +364,10 @@ export function formatSessionContextSection(context: string): string {
   return `<session_context>\n${formatSessionContextText(context)}\n</session_context>`;
 }
 
+export function formatConversationCatchupSection(digest: string): string {
+  return `<conversation_catchup>\n${formatConversationCatchupText(digest)}\n</conversation_catchup>`;
+}
+
 export function formatSkillsSection(skills: SkillMetadata[]): string {
   const entries = skills.map(
     (s) => `- **${s.name}**: ${s.description}\n  Path: \`${s.path}\``,