@vellumai/assistant 0.6.4 → 0.6.6

package/src/__tests__/conversation-pairing.test.ts

@@ -358,8 +358,11 @@ describe("pairDeliveryWithConversation", () => {
     expect(upsertOutboundBindingMock).toHaveBeenCalledTimes(1);
   });
 
-  test("reuses pre-namespace binding when namespaced binding is absent", async () => {
-    // Simulate a binding created before the notification: prefix was introduced
+  test("reuses pre-namespace binding via inbound path when namespaced binding is absent", async () => {
+    // Simulate a binding created before the notification: prefix was introduced.
+    // Un-prefixed bindings are resolved by step 1 (inbound path) which skips
+    // the source check and does not upsert a notification-prefixed binding —
+    // the conversation is still reused.
     mockExistingConversations["conv-legacy"] = {
       id: "conv-legacy",
       source: "notification",
@@ -390,16 +393,11 @@ describe("pairDeliveryWithConversation", () => {
     expect(result.conversationId).toBe("conv-legacy");
     expect(result.createdNewConversation).toBe(false);
     expect(createConversationMock).not.toHaveBeenCalled();
-    // The upsert should write with the new namespaced sourceChannel
-    expect(upsertOutboundBindingMock).toHaveBeenCalledTimes(1);
-    const upsertArgs = upsertOutboundBindingMock.mock.calls[0]![0] as Record<
-      string,
-      unknown
-    >;
-    expect(upsertArgs.sourceChannel).toBe("notification:telegram");
+    // Inbound path does not touch outbound bindings — it only reads.
+    expect(upsertOutboundBindingMock).not.toHaveBeenCalled();
   });
 
-  test("falls back to new conversation when bound conversation is stale (wrong source)", async () => {
+  test("falls back to new conversation when notification-bound conversation is stale (wrong source) and no inbound binding exists", async () => {
     mockExistingConversations["conv-user-owned"] = {
       id: "conv-user-owned",
       source: "user",
@@ -410,6 +408,8 @@ describe("pairDeliveryWithConversation", () => {
       sourceChannel: "notification:slack",
       externalChatId: "C0123ABCDEF",
     };
+    // No inbound (un-prefixed) binding — step 1 finds nothing, step 2
+    // finds the notification binding but the source check rejects it.
 
     const signal = makeSignal();
     const copy = makeCopy();
@@ -468,6 +468,170 @@ describe("pairDeliveryWithConversation", () => {
     expect(upsertOutboundBindingMock).toHaveBeenCalledTimes(1);
   });
 
+  // ── Inbound conversation continuity ──────────────────────────────
+
+  test("prefers inbound conversation over notification-scoped conversation for reply continuity", async () => {
+    // An inbound conversation exists (un-prefixed binding, source: null)
+    // AND a notification conversation exists (prefixed binding, source: "notification").
+    // The inbound conversation should win so that the user's replies
+    // include the notification in their conversation history.
+    mockExistingConversations["conv-inbound"] = {
+      id: "conv-inbound",
+      source: null as unknown as string,
+      title: "Slack DM",
+    };
+    mockBindings["slack:D0ASABGUTQR"] = {
+      conversationId: "conv-inbound",
+      sourceChannel: "slack",
+      externalChatId: "D0ASABGUTQR",
+    };
+    mockExistingConversations["conv-notification"] = {
+      id: "conv-notification",
+      source: "notification",
+      title: "Notification Thread",
+    };
+    mockBindings["notification:slack:D0ASABGUTQR"] = {
+      conversationId: "conv-notification",
+      sourceChannel: "notification:slack",
+      externalChatId: "D0ASABGUTQR",
+    };
+
+    const signal = makeSignal();
+    const copy = makeCopy({
+      conversationSeedMessage: "New tweet from @alice - draft reply attached",
+    });
+    const bindingContext: DestinationBindingContext = {
+      sourceChannel: "slack" as NotificationChannel,
+      externalChatId: "D0ASABGUTQR",
+    };
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "slack" as NotificationChannel,
+      copy,
+      { bindingContext },
+    );
+
+    // Should use the inbound conversation, not the notification one
+    expect(result.conversationId).toBe("conv-inbound");
+    expect(result.messageId).toBe("msg-001");
+    expect(result.createdNewConversation).toBe(false);
+    expect(result.conversationFallbackUsed).toBe(false);
+    expect(createConversationMock).not.toHaveBeenCalled();
+    expect(addMessageMock).toHaveBeenCalledTimes(1);
+    expect(addMessageMock.mock.calls[0]![0]).toBe("conv-inbound");
+    // Should NOT touch the notification binding — we only read the inbound one
+    expect(upsertOutboundBindingMock).not.toHaveBeenCalled();
+  });
+
+  test("uses inbound conversation regardless of source field for reply continuity", async () => {
+    // The inbound conversation has source: null (typical for conversations
+    // created by the inbound handler). The notification would normally
+    // skip this because effectiveSource is "notification". But the inbound
+    // path intentionally skips the source check.
+    mockExistingConversations["conv-inbound-null-source"] = {
+      id: "conv-inbound-null-source",
+      source: null as unknown as string,
+      title: "Slack DM",
+    };
+    mockBindings["slack:D0CHATID123"] = {
+      conversationId: "conv-inbound-null-source",
+      sourceChannel: "slack",
+      externalChatId: "D0CHATID123",
+    };
+
+    const signal = makeSignal();
+    const copy = makeCopy({
+      conversationSeedMessage: "Your daily briefing is ready",
+    });
+    const bindingContext: DestinationBindingContext = {
+      sourceChannel: "slack" as NotificationChannel,
+      externalChatId: "D0CHATID123",
+    };
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "slack" as NotificationChannel,
+      copy,
+      { bindingContext },
+    );
+
+    expect(result.conversationId).toBe("conv-inbound-null-source");
+    expect(result.createdNewConversation).toBe(false);
+    expect(createConversationMock).not.toHaveBeenCalled();
+    expect(addMessageMock.mock.calls[0]![0]).toBe("conv-inbound-null-source");
+  });
+
+  test("falls back to notification binding when inbound binding points to deleted conversation", async () => {
+    // Inbound binding exists but conversation was deleted.
+    // Should fall through to notification binding.
+    mockBindings["slack:D0STALE"] = {
+      conversationId: "conv-deleted-inbound",
+      sourceChannel: "slack",
+      externalChatId: "D0STALE",
+    };
+    // conv-deleted-inbound is NOT in mockExistingConversations — getConversation returns null
+
+    mockExistingConversations["conv-notification-fallback"] = {
+      id: "conv-notification-fallback",
+      source: "notification",
+      title: "Notification Thread",
+    };
+    mockBindings["notification:slack:D0STALE"] = {
+      conversationId: "conv-notification-fallback",
+      sourceChannel: "notification:slack",
+      externalChatId: "D0STALE",
+    };
+
+    const signal = makeSignal();
+    const copy = makeCopy();
+    const bindingContext: DestinationBindingContext = {
+      sourceChannel: "slack" as NotificationChannel,
+      externalChatId: "D0STALE",
+    };
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "slack" as NotificationChannel,
+      copy,
+      { bindingContext },
+    );
+
+    // Inbound conversation is gone — should fall back to notification conversation
+    expect(result.conversationId).toBe("conv-notification-fallback");
+    expect(result.createdNewConversation).toBe(false);
+    expect(createConversationMock).not.toHaveBeenCalled();
+  });
+
+  test("falls through to create new conversation when no inbound and no notification binding exists", async () => {
+    // First notification to a channel where user has never messaged.
+    // No bindings at all — should create a new conversation.
+    const signal = makeSignal();
+    const copy = makeCopy();
+    const bindingContext: DestinationBindingContext = {
+      sourceChannel: "slack" as NotificationChannel,
+      externalChatId: "D0BRANDNEW",
+    };
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "slack" as NotificationChannel,
+      copy,
+      { bindingContext },
+    );
+
+    expect(result.conversationId).toBe("conv-001");
+    expect(result.createdNewConversation).toBe(true);
+    expect(createConversationMock).toHaveBeenCalledTimes(1);
+    expect(upsertOutboundBindingMock).toHaveBeenCalledTimes(1);
+    const upsertArgs = upsertOutboundBindingMock.mock.calls[0]![0] as Record<
+      string,
+      unknown
+    >;
+    expect(upsertArgs.sourceChannel).toBe("notification:slack");
+    expect(upsertArgs.externalChatId).toBe("D0BRANDNEW");
+  });
+
   test("creates new conversation and upserts binding when no prior binding exists", async () => {
     const signal = makeSignal();
     const copy = makeCopy();

package/src/__tests__/conversation-pre-run-repair.test.ts

@@ -24,22 +24,33 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
 
-    provider: "mock-provider",
-    maxTokens: 4096,
-    thinking: false,
-    contextWindow: {
-      maxInputTokens: 100000,
-      thresholdTokens: 80000,
-      preserveRecentMessages: 6,
-      summaryModel: "mock-model",
-      maxSummaryTokens: 512,
-      overflowRecovery: {
-        enabled: true,
-        safetyMarginRatio: 0.05,
-        maxAttempts: 3,
-        interactiveLatestTurnCompression: "summarize",
-        nonInteractiveLatestTurnCompression: "truncate",
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
       },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
     daemon: {
@@ -130,6 +141,12 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getResolvedTools() {
+      return [];
+    }
+    getActiveModel() {
+      return undefined;
+    }
     async run(
       messages: Message[],
       onEvent: (event: Record<string, unknown>) => void,

package/src/__tests__/conversation-process-callsite.test.ts

@@ -0,0 +1,309 @@
+/**
+ * Verifies that `callSite` threads from `Conversation.processMessage`
+ * options all the way down to the per-call provider config, and that
+ * user-initiated turns default to `'mainAgent'` when no caller-supplied
+ * `callSite` is set.
+ *
+ * The test mocks `AgentLoop.run()` so it can capture the `callSite` parameter
+ * the conversation passes after `processMessage` runs the slash-resolver and
+ * runtime-injection pipeline. Adapter callers (heartbeat, filing, scheduler)
+ * pass an explicit `callSite` so `RetryProvider` resolves their per-call
+ * config from `llm.callSites.<id>`.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+import type { Message, ProviderResponse } from "../providers/types.js";
+
+// Use an object wrapper so TypeScript doesn't narrow the captured type to
+// `undefined` based on the initial assignment in the test setup.
+const captured: { callSite?: string } = {};
+
+function clearCaptured(): void {
+  captured.callSite = undefined;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+mock.module("../memory/guardian-action-store.js", () => ({
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => ({ name: "mock-provider" }),
+  initializeProviders: () => {},
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    llm: {
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+        maxTokens: 4096,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
+    },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    daemon: {
+      startupSocketWaitMs: 5000,
+      stopTimeoutMs: 5000,
+      sigkillGracePeriodMs: 2000,
+      titleGenerationMaxTokens: 30,
+      standaloneRecording: true,
+    },
+    services: {
+      inference: {
+        mode: "your-own",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
+    },
+  }),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../prompts/system-prompt.js", () => ({
+  buildSystemPrompt: () => "system prompt",
+}));
+
+mock.module("../permissions/trust-store.js", () => ({
+  clearCache: () => {},
+}));
+
+mock.module("../security/secret-allowlist.js", () => ({
+  resetAllowlist: () => {},
+}));
+
+// Stub workspace-git so the test doesn't run real `git init` / `git add -A`
+// against the workingDir. On GitHub-hosted runners /tmp contains
+// root-owned systemd-private-* directories that return EACCES, and the
+// resulting retry/backoff path takes several seconds — enough to time
+// out this test even though the callSite-threading assertion is unrelated.
+mock.module("../workspace/turn-commit.js", () => ({
+  commitTurnChanges: async () => {},
+}));
+
+mock.module("../workspace/git-service.js", () => ({
+  getWorkspaceGitService: () => ({
+    ensureInitialized: async () => {},
+    commitIfDirty: async () => ({ committed: false }),
+  }),
+}));
+
+let mockDbMessages: Array<{ id: string; role: string; content: string }> = [];
+let mockConversation: Record<string, unknown> | null = null;
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversationType: () => "default",
+  setConversationOriginChannelIfUnset: () => {},
+  setConversationOriginInterfaceIfUnset: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
+  getMessages: () => mockDbMessages,
+  getConversation: () => mockConversation,
+  createConversation: () => ({ id: "conv-1" }),
+  addMessage: () => ({ id: "new-msg" }),
+  updateConversationUsage: () => {},
+  updateConversationTitle: () => {},
+  getMessageById: () => null,
+  getLastUserTimestampBefore: () => 0,
+}));
+
+mock.module("../memory/conversation-queries.js", () => ({
+  listConversations: () => [],
+}));
+
+mock.module("../memory/retriever.js", () => ({
+  buildMemoryRecall: async () => ({
+    enabled: false,
+    degraded: false,
+    injectedText: "",
+    semanticHits: 0,
+    injectedTokens: 0,
+    latencyMs: 0,
+  }),
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
+}));
+
+// Mock AgentLoop to capture the callSite argument that runAgentLoopImpl passes.
+// The 6th positional parameter is `callSite` (see assistant/src/agent/loop.ts).
+mock.module("../agent/loop.js", () => ({
+  AgentLoop: class {
+    constructor() {}
+    getToolTokenBudget() {
+      return 0;
+    }
+    getResolvedTools() {
+      return [];
+    }
+    async run(
+      messages: Message[],
+      onEvent: (event: Record<string, unknown>) => void,
+      _signal?: AbortSignal,
+      _requestId?: string,
+      _onCheckpoint?: unknown,
+      callSite?: string,
+    ): Promise<Message[]> {
+      captured.callSite = callSite;
+      onEvent({
+        type: "usage",
+        inputTokens: 0,
+        outputTokens: 0,
+        model: "mock",
+        providerDurationMs: 0,
+      });
+      return [
+        ...messages,
+        { role: "assistant", content: [{ type: "text", text: "ok" }] },
+      ];
+    }
+  },
+}));
+
+mock.module("../context/window-manager.js", () => ({
+  ContextWindowManager: class {
+    constructor() {}
+    shouldCompact() {
+      return { needed: false, estimatedTokens: 0 };
+    }
+    async maybeCompact() {
+      return { compacted: false };
+    }
+  },
+  createContextSummaryMessage: () => ({
+    role: "user",
+    content: [{ type: "text", text: "summary" }],
+  }),
+  getSummaryFromContextMessage: () => null,
+}));
+
+mock.module("../memory/canonical-guardian-store.js", () => ({
+  listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
+  listCanonicalGuardianRequests: () => [],
+  listPendingRequestsByConversationScope: () => [],
+  createCanonicalGuardianRequest: () => ({
+    id: "mock-cg-id",
+    code: "MOCK",
+    status: "pending",
+  }),
+  getCanonicalGuardianRequest: () => null,
+  getCanonicalGuardianRequestByCode: () => null,
+  updateCanonicalGuardianRequest: () => {},
+  resolveCanonicalGuardianRequest: () => {},
+  createCanonicalGuardianDelivery: () => ({ id: "mock-cgd-id" }),
+  listCanonicalGuardianDeliveries: () => [],
+  listPendingCanonicalGuardianRequestsByDestinationChat: () => [],
+  updateCanonicalGuardianDelivery: () => {},
+  generateCanonicalRequestCode: () => "MOCK-CODE",
+}));
+
+import { Conversation } from "../daemon/conversation.js";
+
+function makeConversation(): Conversation {
+  const provider = {
+    name: "mock",
+    async sendMessage(): Promise<ProviderResponse> {
+      return {
+        content: [{ type: "text", text: "hi" }],
+        model: "mock",
+        usage: { inputTokens: 0, outputTokens: 0 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+  return new Conversation(
+    "conv-1",
+    provider,
+    "system prompt",
+    4096,
+    () => {},
+    "/tmp",
+  );
+}
+
+describe("processMessage callSite threading", () => {
+  test("threads options.callSite='heartbeatAgent' down to agentLoop.run()", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [];
+    clearCaptured();
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    await conversation.processMessage(
+      "Heartbeat tick",
+      [],
+      () => {},
+      undefined, // requestId
+      undefined, // activeSurfaceId
+      undefined, // currentPage
+      { callSite: "heartbeatAgent" },
+    );
+
+    expect(captured.callSite).toBe("heartbeatAgent");
+  });
+
+  test("defaults to 'mainAgent' when not supplied", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [];
+    clearCaptured();
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    await conversation.processMessage("Plain user message", [], () => {});
+
+    expect(captured.callSite).toBe("mainAgent");
+  });
+});

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { AgentEvent } from "../agent/loop.js";
 import type { UserMessageAttachment } from "../daemon/message-protocol.js";
+import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 import { ProviderError } from "../util/errors.js";
 
@@ -27,22 +28,33 @@ mock.module("../config/loader.js", () => ({
       titleGenerationMaxTokens: 30,
     },
 
-    provider: "mock-provider",
-    maxTokens: 4096,
-    thinking: false,
-    contextWindow: {
-      enabled: true,
-      maxInputTokens: 100000,
-      targetBudgetRatio: 0.3,
-      compactThreshold: 0.8,
-      summaryBudgetRatio: 0.05,
-      overflowRecovery: {
-        enabled: true,
-        safetyMarginRatio: 0.05,
-        maxAttempts: 3,
-        interactiveLatestTurnCompression: "summarize",
-        nonInteractiveLatestTurnCompression: "truncate",
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
       },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
     services: {
@@ -65,9 +77,13 @@ mock.module("../config/loader.js", () => ({
 }));
 
 // Token estimator: return a small value (well within budget) so preflight
-// does not trigger in existing tests.
+// does not trigger in existing tests. Stub both the calibrated and raw
+// entry points — the latter backs the default `tokenEstimate` plugin
+// pipeline now used by the orchestrator's preflight / mid-loop checkpoints.
 mock.module("../context/token-estimator.js", () => ({
   estimatePromptTokens: () => 1000,
+  estimatePromptTokensRaw: () => 1000,
+  estimateToolsTokens: () => 0,
 }));
 
 // Overflow recovery module mocks — the convergence loop delegates to these
@@ -129,11 +145,6 @@ mock.module("../daemon/context-overflow-policy.js", () => ({
   resolveOverflowAction: () => "fail_gracefully",
 }));
 
-mock.module("../daemon/context-overflow-approval.js", () => ({
-  requestCompressionApproval: async () => ({ approved: false }),
-  CONTEXT_OVERFLOW_TOOL_NAME: "context_overflow_compression",
-}));
-
 mock.module("../prompts/system-prompt.js", () => ({
   buildSystemPrompt: () => "system prompt",
 }));
@@ -250,6 +261,12 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getResolvedTools() {
+      return [];
+    }
+    getActiveModel() {
+      return undefined;
+    }
     async run(
       messages: Message[],
       onEvent: (event: AgentEvent) => void,
@@ -431,6 +448,12 @@ describe("provider ordering error retry", () => {
     firstRunErrorMode = "ordering";
     maybeCompactCalls = [];
     forceCompactionEnabled = false;
+    // Orchestrator pipelines (`overflowReduce`, `persistence`, …) run through
+    // the plugin registry; re-register every default so each pipeline has a
+    // middleware to dispatch to. The `context-overflow-reducer` module itself
+    // (and other collaborators) are mocked above, so the default plugins'
+    // delegates go through the mocked implementations.
+    resetPluginRegistryAndRegisterDefaults();
   });
 
   test("simulated strict provider error triggers exactly one retry", async () => {