@stigmer/runner 3.6.0 → 3.7.0

package/src/activities/__tests__/call-agent.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+import { ServiceTier } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 
 let mockGetAgentByReference: ReturnType<typeof vi.fn>;
 let mockCreateSession: ReturnType<typeof vi.fn>;
@@ -93,11 +94,11 @@ describe("callAgentAction", () => {
       expect(ref.slug).toBe("my-agent");
     });
 
-    it("uses config.org over __stigmer_org_id when both are present", async () => {
+    it("org/slug agent reference overrides the workflow org for lookup only", async () => {
       await expect(
         callAgentAction(
-          { agent: "my-agent", message: "Hello", org: "explicit-org" },
-          { __stigmer_org_id: "fallback-org" },
+          { agent: "explicit-org/my-agent", message: "Hello" },
+          { __stigmer_org_id: "workflow-org" },
           "wfl_parent789",
         ),
       ).rejects.toThrow("CompleteAsyncError");
@@ -106,6 +107,11 @@ describe("callAgentAction", () => {
       expect(ref.org).toBe("explicit-org");
       expect(ref.slug).toBe("my-agent");
       expect(ref.kind).toBe(ApiResourceKind.agent);
+
+      // The execution itself is still created in the workflow's org — the
+      // cross-org reference changes agent lookup, never the billing org.
+      const execution = mockCreateAgentExecution.mock.calls[0][0];
+      expect(execution.metadata?.org).toBe("workflow-org");
     });
   });
 
@@ -120,7 +126,7 @@ describe("callAgentAction", () => {
       ).rejects.toThrow("call:agent requires an organization context");
     });
 
-    it("falls back to __stigmer_org_id from runtime env", async () => {
+    it("uses __stigmer_org_id from runtime env", async () => {
       await expect(
         callAgentAction(
           { agent: "my-agent", message: "Hello" },
@@ -260,4 +266,213 @@ describe("callAgentAction", () => {
       expect(execution.spec.activityTaskQueue).toBe("");
     });
   });
+
+  describe("run_config → ExecutionConfig mapping (#358)", () => {
+    it("maps model_name, max_cost_usd, and max_tool_rounds onto ExecutionConfig", async () => {
+      await expect(
+        callAgentAction(
+          {
+            agent: "my-agent",
+            message: "Hello",
+            run_config: {
+              model_name: "claude-sonnet-4-6",
+              max_cost_usd: 0.75,
+              max_tool_rounds: 15,
+            },
+          },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      const execution = mockCreateAgentExecution.mock.calls[0][0];
+      expect(execution.spec.executionConfig).toBeDefined();
+      expect(execution.spec.executionConfig.modelName).toBe("claude-sonnet-4-6");
+      expect(execution.spec.executionConfig.maxCostUsd).toBe(0.75);
+      expect(execution.spec.executionConfig.maxToolRounds).toBe(15);
+    });
+
+    it("maps a canonical service_tier onto ExecutionConfig.serviceTier (#357)", async () => {
+      await expect(
+        callAgentAction(
+          {
+            agent: "my-agent",
+            message: "Hello",
+            run_config: { service_tier: "SERVICE_TIER_FAST" },
+          },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      const execution = mockCreateAgentExecution.mock.calls[0][0];
+      expect(execution.spec.executionConfig).toBeDefined();
+      expect(execution.spec.executionConfig.serviceTier).toBe(ServiceTier.FAST);
+    });
+
+    it("fails loudly on a service_tier value with no proto mapping", async () => {
+      // The loader canonicalizes tiers; an unmapped value reaching the
+      // activity means loader/activity drift. A pricing directive must
+      // never be silently dropped.
+      await expect(
+        callAgentAction(
+          {
+            agent: "my-agent",
+            message: "Hello",
+            run_config: { service_tier: "SERVICE_TIER_TURBO" },
+          },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow(
+        "call:agent run_config.service_tier 'SERVICE_TIER_TURBO' has no proto mapping",
+      );
+    });
+
+    it("omits ExecutionConfig entirely when run_config and output are absent", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "my-agent", message: "Hello" },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      const execution = mockCreateAgentExecution.mock.calls[0][0];
+      expect(execution.spec.executionConfig).toBeUndefined();
+    });
+
+    it("treats zero bounds as no override", async () => {
+      await expect(
+        callAgentAction(
+          {
+            agent: "my-agent",
+            message: "Hello",
+            run_config: { model_name: "claude-sonnet-4-6", max_cost_usd: 0, max_tool_rounds: 0 },
+          },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      const execution = mockCreateAgentExecution.mock.calls[0][0];
+      expect(execution.spec.executionConfig.modelName).toBe("claude-sonnet-4-6");
+      // Proto zero values: unset numerics read back as 0, but nothing was
+      // deliberately written — the guards must not have set them from a
+      // zero "no override" input.
+      expect(execution.spec.executionConfig.maxCostUsd).toBe(0);
+      expect(execution.spec.executionConfig.maxToolRounds).toBe(0);
+    });
+  });
+
+  describe("workspace entries and workflow provenance (#358 Phase 2)", () => {
+    it("maps git workspace entries onto the created session's spec", async () => {
+      await expect(
+        callAgentAction(
+          {
+            agent: "my-agent",
+            message: "Hello",
+            workspace_entries: [
+              { name: "app", source: { git_repo: { url: "https://github.com/acme/app", branch: "main" } } },
+              { source: { git_repo: { url: "https://github.com/acme/lib" } } },
+            ],
+          },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      const session = mockCreateSession.mock.calls[0][0];
+      const entries = session.spec.workspaceEntries;
+      expect(entries).toHaveLength(2);
+      expect(entries[0].name).toBe("app");
+      expect(entries[0].source.source.case).toBe("gitRepo");
+      expect(entries[0].source.source.value.url).toBe("https://github.com/acme/app");
+      expect(entries[0].source.source.value.branch).toBe("main");
+      expect(entries[1].source.source.value.url).toBe("https://github.com/acme/lib");
+    });
+
+    it("creates sessions without workspace entries when none are configured", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "my-agent", message: "Hello" },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      const session = mockCreateSession.mock.calls[0][0];
+      expect(session.spec.workspaceEntries).toHaveLength(0);
+    });
+
+    it("stamps workflow provenance labels the server keys environment resolution on", async () => {
+      await expect(
+        callAgentAction(
+          {
+            agent: "my-agent",
+            message: "Hello",
+            __wfExecId: "wex_prov1",
+            __taskName: "triage",
+          } as any,
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      const execution = mockCreateAgentExecution.mock.calls[0][0];
+      expect(execution.metadata.labels["stigmer.ai/workflow-execution-id"]).toBe("wex_prov1");
+      expect(execution.metadata.labels["stigmer.ai/workflow-task"]).toBe("triage");
+    });
+
+    it("stamps no provenance labels without workflow context", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "my-agent", message: "Hello" },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      const execution = mockCreateAgentExecution.mock.calls[0][0];
+      expect(Object.keys(execution.metadata.labels ?? {})).toHaveLength(0);
+    });
+  });
+
+  describe("env secret marking", () => {
+    it("preserves the agent-declared secret flag when a task env override supplies the value", async () => {
+      // The agent declares API_TOKEN as secret. A task-level env override
+      // provides the value — the secret marking must survive (#358: the
+      // override used to hardcode isSecret:false, a redaction downgrade).
+      mockGetAgentByReference.mockResolvedValue({
+        metadata: { id: "agt_test123" },
+        status: { defaultInstanceId: "ain_default456" },
+        spec: {
+          env: {
+            API_TOKEN: { isSecret: true },
+            REGION: { isSecret: false },
+          },
+        },
+      });
+
+      await expect(
+        callAgentAction(
+          {
+            agent: "my-agent",
+            message: "Hello",
+            env: { API_TOKEN: "resolved-secret-value", REGION: "us-east-1", EXTRA: "plain" },
+          },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      const execution = mockCreateAgentExecution.mock.calls[0][0];
+      const runtimeEnv = execution.spec.runtimeEnv;
+      expect(runtimeEnv.API_TOKEN.value).toBe("resolved-secret-value");
+      expect(runtimeEnv.API_TOKEN.isSecret).toBe(true);
+      expect(runtimeEnv.REGION.isSecret).toBe(false);
+      // Keys the agent never declared stay non-secret.
+      expect(runtimeEnv.EXTRA.isSecret).toBe(false);
+    });
+  });
 });

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/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);
+  });
+});