@stigmer/server 3.14.0-dev.20260910084630

package/src/domain/agentexecution/__tests__/update-status.test.ts

@@ -0,0 +1,369 @@
+/**
+ * Pins the updateStatus merge engine against Go's
+ * update_status_guard_test.go and
+ * update_status_recalled_memories_report_test.go case-for-case: the
+ * transcript regression guard (shrink + front-truncation-with-append +
+ * the terminal exemption), the equal-length approval finalize, and the
+ * presence-guarded runner-owned field pattern (recalled_memories_report).
+ * These exercise applyUpdateStatusMerge directly on a clone — mirroring
+ * the freshly-loaded resource the merge mutates in place inside the
+ * updateResource write lock.
+ */
+import { clone, create } from "@bufbuild/protobuf";
+import type { MessageInitShape } from "@bufbuild/protobuf";
+import { describe, expect, it } from "vitest";
+
+import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import {
+  AgentExecutionSchema,
+  AgentExecutionStatusSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import type { AgentExecutionStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import {
+  ApprovalAction,
+  ExecutionPhase,
+  MessageType,
+  ToolCallStatus,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { AgentExecutionUpdateStatusInputSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
+import type { AgentMessage } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import { AgentMessageSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+
+import { createLogger } from "../../../boot/logger.js";
+import { findToolCallInExecution } from "../submit-approval.js";
+import { applyUpdateStatusMerge } from "../update-status.js";
+
+const silentLogger = createLogger({
+  level: "error",
+  pretty: false,
+  write: () => {},
+});
+
+/**
+ * Applies the merge to a clone of the existing execution and returns the
+ * merged result (Go runBuildStep).
+ */
+function runBuildStep(
+  existing: AgentExecution,
+  incoming: MessageInitShape<typeof AgentExecutionStatusSchema>,
+): AgentExecution {
+  const input = create(AgentExecutionUpdateStatusInputSchema, {
+    executionId: existing.metadata?.id ?? "",
+    status: incoming,
+  });
+  const merged = clone(AgentExecutionSchema, existing);
+  applyUpdateStatusMerge(merged, input, silentLogger);
+  return merged;
+}
+
+function messages(...contents: string[]): AgentMessage[] {
+  return contents.map((c) => create(AgentMessageSchema, { content: c }));
+}
+
+function existingWith(
+  phase: ExecutionPhase,
+  ...msgs: string[]
+): AgentExecution {
+  return create(AgentExecutionSchema, {
+    metadata: { id: "exec-guard", name: "exec-guard" },
+    spec: {},
+    status: { phase, messages: msgs.map((c) => ({ content: c })) },
+  });
+}
+
+describe("the transcript regression guard (update_status_guard_test.go)", () => {
+  it("rejects a shrinking transcript for a non-terminal execution", () => {
+    const merged = runBuildStep(
+      existingWith(ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL, "m1", "m2", "m3"),
+      {
+        phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+        messages: [{ content: "only-one" }],
+      },
+    );
+    expect(merged.status?.messages).toHaveLength(3);
+    expect(merged.status?.messages[0]?.content).toBe("m1");
+  });
+
+  it("accepts the equal-length approval finalize (narration blanked in place) and projects the gate", () => {
+    const existing = create(AgentExecutionSchema, {
+      metadata: { id: "exec-guard", name: "exec-guard" },
+      spec: {},
+      status: {
+        phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+        messages: [
+          { content: "let me create the file" },
+          {
+            toolCalls: [
+              {
+                id: "tc-write",
+                name: "Write",
+                status: ToolCallStatus.TOOL_CALL_FAILED,
+                requiresApproval: true,
+              },
+            ],
+          },
+          { content: "I could not write the file; approve it when prompted" },
+        ],
+      },
+    });
+    const merged = runBuildStep(existing, {
+      phase: ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL,
+      messages: [
+        { content: "let me create the file" },
+        {
+          toolCalls: [
+            {
+              id: "tc-write",
+              name: "Write",
+              status: ToolCallStatus.TOOL_CALL_WAITING_APPROVAL,
+              requiresApproval: true,
+            },
+          ],
+        },
+        { content: "" },
+      ],
+    });
+
+    expect(
+      merged.status?.messages,
+      "append-only finalize keeps all 3 messages (narration blanked, not removed)",
+    ).toHaveLength(3);
+    expect(merged.status?.messages[2]?.content).toBe("");
+    expect(
+      merged.status?.pendingApprovals,
+      "the gated WAITING_APPROVAL call projects exactly one pending approval",
+    ).toHaveLength(1);
+    expect(merged.status?.pendingApprovals[0]?.toolCallId).toBe("tc-write");
+  });
+
+  it("rejects a shrinking WAITING_FOR_APPROVAL finalize (no phase carve-out)", () => {
+    const merged = runBuildStep(
+      existingWith(ExecutionPhase.EXECUTION_IN_PROGRESS, "m1", "m2", "m3"),
+      {
+        phase: ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL,
+        messages: [{ content: "m1" }, { content: "m2" }],
+      },
+    );
+    expect(merged.status?.messages).toHaveLength(3);
+  });
+
+  it("accepts a growing transcript (the normal streaming case)", () => {
+    const merged = runBuildStep(
+      existingWith(ExecutionPhase.EXECUTION_IN_PROGRESS, "m1", "m2"),
+      {
+        phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+        messages: [{ content: "m1" }, { content: "m2" }, { content: "m3" }],
+      },
+    );
+    expect(merged.status?.messages).toHaveLength(3);
+  });
+
+  it("accepts an equal-length replacement (in-place mutation of the same turns)", () => {
+    const merged = runBuildStep(
+      existingWith(ExecutionPhase.EXECUTION_IN_PROGRESS, "m1", "m2"),
+      {
+        phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+        messages: [{ content: "m1-updated" }, { content: "m2-updated" }],
+      },
+    );
+    expect(merged.status?.messages).toHaveLength(2);
+    expect(merged.status?.messages[0]?.content).toBe("m1-updated");
+  });
+
+  it("rejects front-truncation-with-append (the gap a count-only guard cannot see)", () => {
+    const existing = create(AgentExecutionSchema, {
+      metadata: { id: "exec-guard", name: "exec-guard" },
+      spec: {},
+      status: {
+        phase: ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL,
+        messages: [
+          {
+            type: MessageType.MESSAGE_THINKING,
+            content: "planning the self-DM",
+          },
+          {
+            type: MessageType.MESSAGE_AI,
+            toolCalls: [
+              {
+                id: "tc-getappstate",
+                name: "getAppState",
+                status: ToolCallStatus.TOOL_CALL_WAITING_APPROVAL,
+                requiresApproval: true,
+                approvalAction: ApprovalAction.APPROVE_ALL,
+                mcpServerSlug: "open-computer-use",
+              },
+            ],
+          },
+        ],
+      },
+    });
+    // Regressed resume transcript: leading thinking + getAppState gone,
+    // later leased tools appended. len(incoming)=3 >= existing=2, so a
+    // count-only guard would not fire.
+    const merged = runBuildStep(existing, {
+      phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+      messages: [
+        {
+          type: MessageType.MESSAGE_AI,
+          toolCalls: [
+            { id: "tc-click", name: "click", status: ToolCallStatus.TOOL_CALL_COMPLETED },
+          ],
+        },
+        {
+          type: MessageType.MESSAGE_AI,
+          toolCalls: [
+            { id: "tc-scroll", name: "scroll", status: ToolCallStatus.TOOL_CALL_COMPLETED },
+          ],
+        },
+        { type: MessageType.MESSAGE_AI, content: "done" },
+      ],
+    });
+
+    const hasThinking = merged.status?.messages.some(
+      (m) =>
+        m.type === MessageType.MESSAGE_THINKING &&
+        m.content === "planning the self-DM",
+    );
+    expect(
+      hasThinking,
+      "the leading thinking block must survive a front-truncated-but-appended update",
+    ).toBe(true);
+    expect(
+      findToolCallInExecution(merged, "tc-getappstate"),
+      "the first tool call must survive a front-truncated-but-appended update",
+    ).toBeDefined();
+  });
+
+  it("allows a shrink for a terminal execution (administrative correction)", () => {
+    const merged = runBuildStep(
+      existingWith(ExecutionPhase.EXECUTION_COMPLETED, "m1", "m2", "m3"),
+      {
+        phase: ExecutionPhase.EXECUTION_COMPLETED,
+        messages: [{ content: "single" }],
+      },
+    );
+    expect(merged.status?.messages).toHaveLength(1);
+  });
+
+  it("keeps the TERMINATED transcript guarded (the narrow transcript-terminal set)", () => {
+    // TERMINATED is deliberately absent from the transcript guard's
+    // terminal set (phases.ts) — a terminated execution's committed
+    // transcript stays protected from free rewrites.
+    const merged = runBuildStep(
+      existingWith(ExecutionPhase.EXECUTION_TERMINATED, "m1", "m2", "m3"),
+      {
+        phase: ExecutionPhase.EXECUTION_TERMINATED,
+        messages: [{ content: "single" }],
+      },
+    );
+    expect(merged.status?.messages).toHaveLength(3);
+  });
+});
+
+describe("the phase latch and terminal settle", () => {
+  it("latches a terminal phase against a straggler IN_PROGRESS persist and re-settles its rows", () => {
+    const existing = create(AgentExecutionSchema, {
+      metadata: { id: "exec-latch", name: "exec-latch" },
+      spec: {},
+      status: {
+        phase: ExecutionPhase.EXECUTION_TERMINATED,
+        completedAt: "2026-08-24T10:00:00Z",
+        messages: [{ content: "m1" }],
+      },
+    });
+    // The straggler carries a live phase and a RUNNING tool call appended
+    // to an equal-or-longer transcript.
+    const merged = runBuildStep(existing, {
+      phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+      messages: [
+        { content: "m1" },
+        {
+          toolCalls: [
+            { id: "tc-live", name: "shell", status: ToolCallStatus.TOOL_CALL_RUNNING },
+          ],
+        },
+      ],
+    });
+
+    expect(
+      merged.status?.phase,
+      "the terminal phase is final (Recover is the sanctioned un-terminalizer)",
+    ).toBe(ExecutionPhase.EXECUTION_TERMINATED);
+    const straggler = findToolCallInExecution(merged, "tc-live");
+    expect(
+      straggler?.status,
+      "the straggler's RUNNING row re-settles in the same merge (#207)",
+    ).toBe(ToolCallStatus.TOOL_CALL_INTERRUPTED);
+    expect(straggler?.completedAt).toBe("2026-08-24T10:00:00Z");
+  });
+
+  it("clears completed_at when the merged phase is non-terminal (resume defense-in-depth)", () => {
+    const existing = create(AgentExecutionSchema, {
+      metadata: { id: "exec-resume", name: "exec-resume" },
+      spec: {},
+      status: {
+        phase: ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL,
+        completedAt: "2026-08-24T10:00:00Z",
+        messages: [{ content: "m1" }],
+      },
+    });
+    const merged = runBuildStep(existing, {
+      phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+      messages: [{ content: "m1" }],
+    });
+    expect(merged.status?.completedAt).toBe("");
+  });
+});
+
+describe("the presence-guarded runner-owned field pattern (recalled_memories_report)", () => {
+  function selectionReport(...ids: string[]) {
+    return {
+      selectionActive: true,
+      injectedMemoryIds: ids,
+      embeddingModel: "text-embedding-3-small",
+    };
+  }
+
+  it("stores a runner-sent report", () => {
+    const merged = runBuildStep(
+      existingWith(ExecutionPhase.EXECUTION_IN_PROGRESS, "m1"),
+      {
+        phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+        messages: [{ content: "m1" }],
+        recalledMemoriesReport: selectionReport("mem_a", "mem_b"),
+      },
+    );
+    const report = merged.status?.recalledMemoriesReport;
+    expect(report).toBeDefined();
+    expect(report?.selectionActive).toBe(true);
+    expect(report?.injectedMemoryIds).toEqual(["mem_a", "mem_b"]);
+    expect(report?.embeddingModel).toBe("text-embedding-3-small");
+  });
+
+  it("preserves the stored report across report-less writes (incl. the terminal persist)", () => {
+    const existing = existingWith(ExecutionPhase.EXECUTION_IN_PROGRESS, "m1");
+    (existing.status as AgentExecutionStatus).recalledMemoriesReport = create(
+      AgentExecutionStatusSchema,
+      { recalledMemoriesReport: selectionReport("mem_a") },
+    ).recalledMemoriesReport;
+
+    const merged = runBuildStep(existing, {
+      phase: ExecutionPhase.EXECUTION_COMPLETED,
+      messages: [{ content: "m1" }, { content: "m2" }],
+    });
+    expect(merged.status?.recalledMemoriesReport?.injectedMemoryIds).toEqual([
+      "mem_a",
+    ]);
+  });
+
+  it("never invents a report (runner-owned, single writer)", () => {
+    const merged = runBuildStep(
+      existingWith(ExecutionPhase.EXECUTION_IN_PROGRESS, "m1"),
+      {
+        phase: ExecutionPhase.EXECUTION_COMPLETED,
+        messages: [{ content: "m1" }, { content: "m2" }],
+      },
+    );
+    expect(merged.status?.recalledMemoriesReport).toBeUndefined();
+  });
+});

package/src/domain/agentexecution/__tests__/usage.test.ts

@@ -0,0 +1,186 @@
+/**
+ * Pins the usage aggregation helpers against Go's usage_aggregation_test.go
+ * case-for-case: the OSS zero-value posture (no llm_call_usage_record
+ * collection here — every aggregate is structurally valid and zero), the
+ * date/org/agent filters, grouping, distinct sets, daily entries, and the
+ * top-agents cap.
+ */
+import { create } from "@bufbuild/protobuf";
+import { describe, expect, it } from "vitest";
+
+import { AgentExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { AgentUsageSummarySchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
+
+import {
+  aggregateUsageReport,
+  buildDailyCostEntries,
+  buildExecutionSummary,
+  buildSessionSummary,
+  earliestStartedAt,
+  extractDate,
+  filterByDateRange,
+  filterByOrg,
+  groupByDate,
+  groupBySessionId,
+  latestStartedAt,
+  mergeModelBreakdowns,
+  topAgentsByCost,
+} from "../usage.js";
+
+function makeExecution(
+  id: string,
+  sessionId: string,
+  agentId: string,
+  org: string,
+  startedAt: string,
+  subAgentCount = 0,
+): AgentExecution {
+  return create(AgentExecutionSchema, {
+    metadata: { id, name: `exec-${id}`, org },
+    spec: { sessionId, agentId },
+    status: {
+      startedAt,
+      completedAt: startedAt,
+      phase: ExecutionPhase.EXECUTION_COMPLETED,
+      subAgentExecutions: Array.from({ length: subAgentCount }, () => ({})),
+    },
+  });
+}
+
+describe("usage aggregation (OSS zero-value posture)", () => {
+  it("aggregateUsageReport returns zero", () => {
+    const agg = aggregateUsageReport();
+    expect(agg.inputTokens).toBe(0n);
+    expect(agg.outputTokens).toBe(0n);
+    expect(agg.totalTokens).toBe(0n);
+    expect(agg.llmCallCount).toBe(0);
+    expect(agg.billableCostMicros).toBe(0n);
+  });
+
+  it("mergeModelBreakdowns returns empty", () => {
+    expect(mergeModelBreakdowns()).toHaveLength(0);
+  });
+
+  it("buildExecutionSummary projects identity fields with zero usage", () => {
+    const summary = buildExecutionSummary(
+      makeExecution("e1", "s1", "a1", "org", "2026-03-10T10:00:00Z", 1),
+    );
+    expect(summary.executionId).toBe("e1");
+    expect(summary.startedAt).toBe("2026-03-10T10:00:00Z");
+    expect(summary.subAgentCount).toBe(1);
+    expect(summary.phase).toBe(ExecutionPhase.EXECUTION_COMPLETED);
+    expect(summary.inputTokens, "OSS has no usage data").toBe(0n);
+    expect(summary.billableCostMicros, "OSS has no usage data").toBe(0n);
+  });
+
+  it("filterByDateRange applies inclusive string bounds", () => {
+    const executions = [
+      makeExecution("e1", "s1", "a1", "org", "2026-03-01T10:00:00Z"),
+      makeExecution("e2", "s1", "a1", "org", "2026-03-05T10:00:00Z"),
+      makeExecution("e3", "s1", "a1", "org", "2026-03-10T10:00:00Z"),
+      makeExecution("e4", "s1", "a1", "org", "2026-03-15T10:00:00Z"),
+    ];
+    expect(filterByDateRange(executions, "2026-03-03", "2026-03-12")).toHaveLength(2);
+    expect(filterByDateRange(executions, "2026-03-10", "")).toHaveLength(2);
+    expect(filterByDateRange(executions, "", "2026-03-05T10:00:00Z")).toHaveLength(2);
+    expect(filterByDateRange(executions, "", "")).toHaveLength(4);
+  });
+
+  it("groupBySessionId groups by spec.session_id", () => {
+    const groups = groupBySessionId([
+      makeExecution("e1", "s1", "a1", "org", ""),
+      makeExecution("e2", "s1", "a1", "org", ""),
+      makeExecution("e3", "s2", "a1", "org", ""),
+    ]);
+    expect(groups.size).toBe(2);
+    expect(groups.get("s1")).toHaveLength(2);
+    expect(groups.get("s2")).toHaveLength(1);
+  });
+
+  it("groupByDate groups by the YYYY-MM-DD prefix", () => {
+    const groups = groupByDate([
+      makeExecution("e1", "s1", "a1", "org", "2026-03-10T08:00:00Z"),
+      makeExecution("e2", "s1", "a1", "org", "2026-03-10T14:00:00Z"),
+      makeExecution("e3", "s1", "a1", "org", "2026-03-11T09:00:00Z"),
+    ]);
+    expect(groups.size).toBe(2);
+    expect(groups.get("2026-03-10")).toHaveLength(2);
+  });
+
+  it("buildSessionSummary carries the time span with zero usage", () => {
+    const summary = buildSessionSummary("s1", [
+      makeExecution("e1", "s1", "a1", "org", "2026-03-10T08:00:00Z"),
+      makeExecution("e2", "s1", "a1", "org", "2026-03-10T14:00:00Z"),
+    ]);
+    expect(summary.sessionId).toBe("s1");
+    expect(summary.executionCount).toBe(2);
+    expect(summary.totalTokens, "OSS has no usage data").toBe(0n);
+    expect(summary.billableCostMicros, "OSS has no usage data").toBe(0n);
+    expect(summary.firstExecutionAt).toBe("2026-03-10T08:00:00Z");
+  });
+
+  it("buildDailyCostEntries sorts chronologically with zero cost", () => {
+    const entries = buildDailyCostEntries([
+      makeExecution("e1", "s1", "a1", "org", "2026-03-10T08:00:00Z"),
+      makeExecution("e2", "s1", "a1", "org", "2026-03-10T14:00:00Z"),
+      makeExecution("e3", "s1", "a1", "org", "2026-03-11T09:00:00Z"),
+    ]);
+    expect(entries).toHaveLength(2);
+    expect(entries[0]?.date).toBe("2026-03-10");
+    expect(entries[0]?.executionCount).toBe(2);
+    expect(entries[0]?.totalTokens, "OSS has no usage data").toBe(0n);
+    expect(entries[1]?.date).toBe("2026-03-11");
+  });
+
+  it("topAgentsByCost ranks descending and caps", () => {
+    const top = topAgentsByCost(
+      [
+        create(AgentUsageSummarySchema, { agentId: "a1", billableCostMicros: 1_000_000n }),
+        create(AgentUsageSummarySchema, { agentId: "a2", billableCostMicros: 5_000_000n }),
+        create(AgentUsageSummarySchema, { agentId: "a3", billableCostMicros: 500_000n }),
+        create(AgentUsageSummarySchema, { agentId: "a4", billableCostMicros: 3_000_000n }),
+      ],
+      2,
+    );
+    expect(top).toHaveLength(2);
+    expect(top[0]?.agentId).toBe("a2");
+    expect(top[1]?.agentId).toBe("a4");
+  });
+
+  it("filterByOrg matches case-insensitively", () => {
+    const executions = [
+      makeExecution("e1", "s1", "a1", "org-a", ""),
+      makeExecution("e2", "s1", "a1", "org-b", ""),
+      makeExecution("e3", "s1", "a1", "org-a", ""),
+    ];
+    expect(filterByOrg(executions, "org-a")).toHaveLength(2);
+    // Go strings.EqualFold semantics.
+    expect(filterByOrg(executions, "ORG-A")).toHaveLength(2);
+  });
+
+  it("extractDate takes the 10-char prefix or nothing", () => {
+    expect(extractDate("2026-03-10T08:00:00Z")).toBe("2026-03-10");
+    expect(extractDate("2026-03-10")).toBe("2026-03-10");
+    expect(extractDate("short")).toBe("");
+    expect(extractDate("")).toBe("");
+  });
+
+  it("earliest/latestStartedAt skip empties and compare as strings", () => {
+    const executions = [
+      makeExecution("e1", "s1", "a1", "org", "2026-03-10T14:00:00Z"),
+      makeExecution("e2", "s1", "a1", "org", "2026-03-05T09:00:00Z"),
+      makeExecution("e3", "s1", "a1", "org", "2026-03-12T08:00:00Z"),
+    ];
+    expect(earliestStartedAt(executions)).toBe("2026-03-05T09:00:00Z");
+    expect(latestStartedAt(executions)).toBe("2026-03-12T08:00:00Z");
+  });
+
+  it("empty inputs answer zero shapes everywhere", () => {
+    expect(aggregateUsageReport().totalTokens).toBe(0n);
+    expect(mergeModelBreakdowns()).toHaveLength(0);
+    expect(buildDailyCostEntries([])).toHaveLength(0);
+    expect(earliestStartedAt([])).toBe("");
+  });
+});

package/src/domain/agentexecution/__tests__/validate-service-tier.test.ts

@@ -0,0 +1,117 @@
+/**
+ * Pins validate-service-tier.ts against Go's validate_service_tier_test.go
+ * case-for-case: fail-closed create-time validation of
+ * ExecutionConfig.service_tier (#357) against the BUNDLED registry
+ * (composer-2.5 prices a fast variant; claude-sonnet-4.6 is native with
+ * none). Both editions must refuse the same request with the same
+ * message — the conformance tier suite asserts the codes on every target;
+ * these tests additionally pin the message fragments.
+ */
+import { testCallerIdentity } from "../../../pipeline/__tests__/support.js";
+import { create } from "@bufbuild/protobuf";
+import type { MessageInitShape } from "@bufbuild/protobuf";
+import { Code, ConnectError } from "@connectrpc/connect";
+import { describe, expect, it } from "vitest";
+
+import { AgentExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { ServiceTier } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { ExecutionConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+
+import { createLogger } from "../../../boot/logger.js";
+import { RequestContext } from "../../../pipeline/request-context.js";
+import { bundledModelRegistryDocument } from "../../workflow/registry/bundled.js";
+import { ModelRegistryStore } from "../../workflow/registry/model-registry-store.js";
+import { newValidateServiceTierStep } from "../validate-service-tier.js";
+
+const silentLogger = createLogger({
+  level: "error",
+  pretty: false,
+  write: () => {},
+});
+
+const registry = new ModelRegistryStore({
+  bundledDocument: bundledModelRegistryDocument(),
+  upstreamOrigin: "http://unused.test",
+  refreshEnabled: false,
+  logger: silentLogger,
+});
+
+const step = newValidateServiceTierStep(registry);
+
+function contextFor(
+  config: MessageInitShape<typeof ExecutionConfigSchema> | undefined,
+): RequestContext<typeof AgentExecutionSchema> {
+  return new RequestContext(
+    AgentExecutionSchema,
+    create(AgentExecutionSchema, {
+      spec: {
+        message: "hello",
+        ...(config === undefined ? {} : { executionConfig: config }),
+      },
+    }),
+    testCallerIdentity(),
+    ApiResourceKind.agent_execution,
+  );
+}
+
+function refusal(
+  config: MessageInitShape<typeof ExecutionConfigSchema>,
+): ConnectError {
+  try {
+    step.execute(contextFor(config));
+  } catch (error) {
+    expect(error).toBeInstanceOf(ConnectError);
+    return error as ConnectError;
+  }
+  throw new Error("expected a fail-closed refusal, step passed");
+}
+
+describe("ValidateServiceTier (#357, bundled registry)", () => {
+  it("no execution_config passes", () => {
+    expect(() => step.execute(contextFor(undefined))).not.toThrow();
+  });
+
+  it("explicit STANDARD passes without a model", () => {
+    expect(() =>
+      step.execute(contextFor({ serviceTier: ServiceTier.STANDARD })),
+    ).not.toThrow();
+  });
+
+  it("FAST with a fast-priced model passes", () => {
+    expect(() =>
+      step.execute(
+        contextFor({
+          modelName: "composer-2.5",
+          serviceTier: ServiceTier.FAST,
+        }),
+      ),
+    ).not.toThrow();
+  });
+
+  it("FAST without model_name fails closed (no FAST-on-Auto)", () => {
+    const err = refusal({ serviceTier: ServiceTier.FAST });
+    expect(err.code).toBe(Code.InvalidArgument);
+    expect(err.rawMessage).toContain("requires execution_config.model_name");
+    // Fast-capable suggestions ride along.
+    expect(err.rawMessage).toContain("composer-2.5");
+  });
+
+  it("FAST on a native model with no fast variant fails closed", () => {
+    const err = refusal({
+      modelName: "claude-sonnet-4.6",
+      serviceTier: ServiceTier.FAST,
+    });
+    expect(err.code).toBe(Code.InvalidArgument);
+    expect(err.rawMessage).toContain("no fast variant");
+    expect(err.rawMessage).toContain("claude-sonnet-4.6");
+  });
+
+  it("FAST on an unknown model fails closed", () => {
+    const err = refusal({
+      modelName: "not-a-model",
+      serviceTier: ServiceTier.FAST,
+    });
+    expect(err.code).toBe(Code.InvalidArgument);
+  });
+});