@stigmer/runner 3.5.3 → 3.7.0

package/src/activities/__tests__/discover-mcp-server.test.ts

@@ -411,6 +411,55 @@ describe("DiscoverMcpServer activity", () => {
       expect(mockClient.getExecutionContextByExecutionId).toHaveBeenCalledWith("ctx-abc");
     });
 
+    it("discovers a caller-identity-templating server via the anonymous sentinel", async () => {
+      // Discovery has no session, so declared STIGMER_CALLER_IDENTITY_*
+      // placeholders resolve to the anonymous sentinel instead of failing
+      // with PlaceholderResolutionError — the failure mode that would
+      // leave an identity-consuming server's tools permanently
+      // unclassified. The server sees an anonymous caller and must answer
+      // tools/list (its authz layer refuses tool CALLS, not discovery).
+      const { discoverMcpServer } = await import("../discover-mcp-server.js");
+      const { MultiServerMCPClient } = await import("@langchain/mcp-adapters");
+
+      const spec = makeHttpSpec("https://isc-mcp.example.com/mcp");
+      spec.serverType.value.headers = {
+        "X-Stigmer-Caller-Kind": "${STIGMER_CALLER_IDENTITY_KIND}",
+        "X-Stigmer-Caller-Value": "${STIGMER_CALLER_IDENTITY_VALUE}",
+        Authorization: "Bearer ${ISC_SHARED_SECRET}",
+      };
+      spec.env = {
+        STIGMER_CALLER_IDENTITY_KIND: { optional: true },
+        STIGMER_CALLER_IDENTITY_VALUE: { optional: true },
+        ISC_SHARED_SECRET: { isSecret: true },
+      };
+
+      const mockClient = makeMockStigmerClient({
+        mcpServer: makeMcpServer({ metadata: { slug: "isc-gym" }, spec }),
+        executionContext: {
+          spec: { data: { ISC_SHARED_SECRET: { value: "s3cret", isSecret: true } } },
+        },
+      });
+
+      const mockMcpClient = makeMockMcpClient({
+        tools: [{ name: "get_gym_info", description: "Public info", inputSchema: { type: "object" } }],
+      });
+      mockInitializeConnections.mockResolvedValue({});
+      mockGetClient.mockResolvedValue(mockMcpClient);
+
+      const result = await discoverMcpServer(
+        { mcpServerId: "mcp-isc", executionContextId: "ctx-isc" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden" },
+      );
+
+      expect(result.tools).toHaveLength(1);
+      const connectionConfig = vi.mocked(MultiServerMCPClient).mock.calls[0][0] as any;
+      expect(connectionConfig["isc-gym"].headers).toEqual({
+        "X-Stigmer-Caller-Kind": "anonymous",
+        "X-Stigmer-Caller-Value": "",
+        Authorization: "Bearer s3cret",
+      });
+    });
+
     it("returns empty env when no executionContextId provided", async () => {
       const { discoverMcpServer } = await import("../discover-mcp-server.js");
 

package/src/activities/call-agent.ts

@@ -31,6 +31,13 @@ import { AgentExecutionSpecSchema, ExecutionConfigSchema } from "@stigmer/protos
 import { SessionSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
 import { SessionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/spec_pb";
 import { Harness, ExecutionTarget } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
+import { ServiceTier } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import {
+  WorkspaceEntrySchema,
+  WorkspaceSourceSchema,
+  GitRepoSourceSchema,
+  type WorkspaceEntry,
+} from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
 import { AgentExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import { ExecutionValueSchema } from "@stigmer/protos/ai/stigmer/agentic/executioncontext/v1/spec_pb";
 import type { ExecutionValue } from "@stigmer/protos/ai/stigmer/agentic/executioncontext/v1/spec_pb";
@@ -62,14 +69,15 @@ export async function callAgentAction(
     );
   }
 
-  const orgId = resolved.org
-    ?? (runtimeEnv["__stigmer_org_id"] as string | undefined)
-    ?? "";
+  // The execution is always created in the workflow's org — the workflow
+  // owner pays for the run. A cross-org agent reference ("org/slug") only
+  // changes where the agent blueprint is looked up, never the billing org.
+  const orgId = (runtimeEnv["__stigmer_org_id"] as string | undefined) ?? "";
 
   if (!orgId) {
     throw new Error(
       "call:agent requires an organization context. " +
-      "Set 'org' in the task config or ensure '__stigmer_org_id' is in the workflow environment.",
+      "Ensure '__stigmer_org_id' is in the workflow environment.",
     );
   }
 
@@ -142,6 +150,7 @@ export async function callAgentAction(
         harness,
         executionTarget,
         subject: "Auto-created session",
+        workspaceEntries: buildWorkspaceEntries(resolved.workspace_entries),
       }),
     }),
   );
@@ -170,10 +179,17 @@ export async function callAgentAction(
     );
   }
 
-  // Task-config-level env takes precedence over auto-forwarded values
+  // Task-config-level env takes precedence over auto-forwarded values.
+  // The agent's declared secret marking survives the override: a key the
+  // agent declares secret stays secret no matter which channel supplied
+  // the value, so an explicit task-level `env:` entry cannot downgrade
+  // redaction (issue #358 — the override used to hardcode isSecret:false).
   if (resolved.env) {
     for (const [key, value] of Object.entries(resolved.env)) {
-      executionRuntimeEnv[key] = { value: String(value), isSecret: false };
+      executionRuntimeEnv[key] = {
+        value: String(value),
+        isSecret: agentEnvDecls[key]?.isSecret ?? false,
+      };
     }
   }
 
@@ -196,13 +212,41 @@ export async function callAgentAction(
   const parentQueue = runtimeEnv["__stigmer_activity_task_queue"] as string | undefined;
   const activityTaskQueue = parentQueue?.startsWith("wfexec:") ? parentQueue : "";
 
-  const hasModel = !!resolved.config?.model;
+  // Honest RunConfig → ExecutionConfig mapping (issue #358): every field
+  // the author may set is forwarded to a field the runner enforces.
+  // model_name replaces the agent's default outright; max_cost_usd feeds
+  // the harness-generic cost guards (cost-cap middleware / cursor
+  // cost-guard); max_tool_rounds feeds resolveRecursionLimit (native
+  // harness only); service_tier feeds the cursor harness's explicit
+  // variant selection (issue #357). Zero/unset means "no override" and is
+  // omitted.
+  const runConfig = resolved.run_config;
+  const hasModel = !!runConfig?.model_name;
+  const hasCostCap = (runConfig?.max_cost_usd ?? 0) > 0;
+  const hasToolRounds = (runConfig?.max_tool_rounds ?? 0) > 0;
+  // Loader guarantees a canonical enum name; an unknown one here means the
+  // loader and this mapping drifted — fail the task, never silently drop a
+  // pricing directive.
+  const SERVICE_TIER_BY_NAME: Record<string, ServiceTier> = {
+    SERVICE_TIER_STANDARD: ServiceTier.STANDARD,
+    SERVICE_TIER_FAST: ServiceTier.FAST,
+  };
+  const serviceTier = runConfig?.service_tier
+    ? SERVICE_TIER_BY_NAME[runConfig.service_tier]
+    : undefined;
+  if (runConfig?.service_tier && serviceTier === undefined) {
+    throw new Error(
+      `call:agent run_config.service_tier '${runConfig.service_tier}' has no proto mapping`,
+    );
+  }
+  const hasServiceTier = serviceTier !== undefined;
   const hasOutputSchema = !!resolved.output?.schema;
 
   console.log(
     `[CallAgent] schema propagation diagnostic: ` +
     `hasOutputSchema=${hasOutputSchema}, ` +
-    `hasModel=${hasModel}, ` +
+    `hasModel=${hasModel}, hasCostCap=${hasCostCap}, hasToolRounds=${hasToolRounds}, ` +
+    `hasServiceTier=${hasServiceTier}, ` +
     `configKeys=[${Object.keys(resolved).join(",")}], ` +
     `hasOutput=${resolved.output !== undefined}, ` +
     `outputKeys=${resolved.output ? JSON.stringify(Object.keys(resolved.output)) : "N/A"}, ` +
@@ -220,15 +264,29 @@ export async function callAgentAction(
     runtimeEnv: runtimeEnvProto,
   });
 
-  if (hasModel || hasOutputSchema) {
+  if (hasModel || hasCostCap || hasToolRounds || hasServiceTier || hasOutputSchema) {
     const execConfig = create(ExecutionConfigSchema, {});
-    if (hasModel) execConfig.modelName = resolved.config!.model!;
+    if (hasModel) execConfig.modelName = runConfig!.model_name!;
+    if (hasCostCap) execConfig.maxCostUsd = runConfig!.max_cost_usd!;
+    if (hasToolRounds) execConfig.maxToolRounds = runConfig!.max_tool_rounds!;
+    if (hasServiceTier) execConfig.serviceTier = serviceTier!;
     if (hasOutputSchema) {
       execConfig.structuredOutputSchema = resolved.output!.schema as JsonObject;
     }
     executionSpec.executionConfig = execConfig;
   }
 
+  // Workflow provenance labels: the server's CreateExecutionContextStep
+  // keys the agent_call environment_refs resolution on these (the
+  // schedule-label lineage). The cloud edition additionally gates the
+  // branch on the trusted runner caller identity, so the labels are only
+  // load-bearing inside that trust boundary.
+  const labels: Record<string, string> = {};
+  if (wfExecId && taskName) {
+    labels["stigmer.ai/workflow-execution-id"] = wfExecId;
+    labels["stigmer.ai/workflow-task"] = taskName;
+  }
+
   await client.createAgentExecution(
     create(AgentExecutionSchema, {
       apiVersion: "agentic.stigmer.ai/v1",
@@ -236,6 +294,7 @@ export async function callAgentAction(
       metadata: create(ApiResourceMetadataSchema, {
         name: executionName,
         org: orgId,
+        labels,
       }),
       spec: executionSpec,
     }),
@@ -244,6 +303,31 @@ export async function callAgentAction(
   throw new CompleteAsyncError();
 }
 
+// buildWorkspaceEntries maps the task's git-only workspace entries onto the
+// shared session WorkspaceEntry proto. Provisioning credentials are NOT the
+// runner's concern here: the provisioner resolves GITHUB_TOKEN from the
+// merged environment (DD-018 D-4), which the task's environment_refs feed
+// via server-side resolution.
+function buildWorkspaceEntries(
+  entries: AgentCallConfig["workspace_entries"],
+): WorkspaceEntry[] {
+  if (!entries || entries.length === 0) return [];
+  return entries.map((entry) =>
+    create(WorkspaceEntrySchema, {
+      name: entry.name ?? "",
+      source: create(WorkspaceSourceSchema, {
+        source: {
+          case: "gitRepo",
+          value: create(GitRepoSourceSchema, {
+            url: entry.source.git_repo.url,
+            branch: entry.source.git_repo.branch ?? "",
+          }),
+        },
+      }),
+    }),
+  );
+}
+
 function parseAgentReference(
   agentStr: string,
   defaultOrg: string,

package/src/activities/discover-mcp-server.ts

@@ -30,6 +30,7 @@ import {
   type McpTransportPosture,
 } from "../shared/mcp-transport-guard.js";
 import { detectOAuthChallenge } from "../shared/mcp-oauth-detect.js";
+import { injectAnonymousCallerIdentityForDiscovery } from "../shared/caller-identity.js";
 import { withTimeout } from "../shared/with-timeout.js";
 import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
 import type { Config } from "../config.js";
@@ -249,7 +250,18 @@ export async function discoverMcpServer(
   const declaredEnvKeys = mcpServer.spec.env
     ? new Set(Object.keys(mcpServer.spec.env))
     : new Set<string>();
-  const finalEnv = injectPlatformEnv(declaredEnvKeys, envVars);
+  const platformEnv = injectPlatformEnv(declaredEnvKeys, envVars);
+
+  // Discovery runs with no session, so every declared caller-identity key
+  // resolves to the anonymous sentinel — without it, a server templating
+  // ${STIGMER_CALLER_IDENTITY_VALUE} in its headers would fail discovery
+  // with PlaceholderResolutionError and its tools would never be
+  // classified. Servers consuming these keys answer tools/list to
+  // anonymous callers by contract.
+  const finalEnv = injectAnonymousCallerIdentityForDiscovery(
+    declaredEnvKeys,
+    platformEnv,
+  );
 
   const resolved = mcpServerToResolved(mcpServer, slug, finalEnv);
   if (!resolved) {

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

@@ -7,6 +7,7 @@ import { describe, it, expect, vi, beforeAll } from "vitest";
  */
 describe("getCursorModelPricing — speed variant resolution", () => {
   let getCursorModelPricing: typeof import("../model-pricing.js").getCursorModelPricing;
+  let getCursorModelPricingForVariant: typeof import("../model-pricing.js").getCursorModelPricingForVariant;
   let computeTurnCost: typeof import("../model-pricing.js").computeTurnCost;
 
   beforeAll(async () => {
@@ -58,6 +59,7 @@ describe("getCursorModelPricing — speed variant resolution", () => {
     const mod = await import("../model-pricing.js");
     await mod.ensureLoaded();
     getCursorModelPricing = mod.getCursorModelPricing;
+    getCursorModelPricingForVariant = mod.getCursorModelPricingForVariant;
     computeTurnCost = mod.computeTurnCost;
   });
 
@@ -89,4 +91,22 @@ describe("getCursorModelPricing — speed variant resolution", () => {
     const cost = computeTurnCost(p, 266_945, 7_069, 0, 222_432);
     expect(cost).toBeCloseTo(0.28406, 5);
   });
+
+  it("getCursorModelPricingForVariant('fast') prices a base id at fast rates (#357)", () => {
+    // The explicit-tier path: the caller KNOWS the variant (it requested
+    // it) — no wire-id suffix inference involved.
+    const p = getCursorModelPricingForVariant("composer-2.5", "fast");
+    expect(p.inputPricePerMillion).toBe(3.0);
+    expect(p.outputPricePerMillion).toBe(15.0);
+  });
+
+  it("getCursorModelPricingForVariant(null) keeps base rates", () => {
+    const p = getCursorModelPricingForVariant("composer-2.5", null);
+    expect(p.inputPricePerMillion).toBe(0.5);
+  });
+
+  it("getCursorModelPricingForVariant('fast') falls back to base rates when unpriced", () => {
+    const p = getCursorModelPricingForVariant("claude-opus-4-6", "fast");
+    expect(p.inputPricePerMillion).toBe(5.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);
+  });
 });