@stigmer/runner 3.0.1

package/src/shared/__tests__/connect-backfill.test.ts

@@ -0,0 +1,346 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  needsBackfill,
+  backfillMcpServersIfNeeded,
+  extractRuntimeEnvForServer,
+} from "../connect-backfill.js";
+import type { ResolvedMcpServer } from "../mcp-resolver.js";
+
+function makeServer(overrides: Partial<ResolvedMcpServer> = {}): ResolvedMcpServer {
+  return {
+    slug: "test-server",
+    connectionType: "stdio",
+    command: "npx",
+    args: ["-y", "@mcp/test-server"],
+    toolApprovals: [],
+    pinnedToolApprovals: [],
+    discoveredCapabilitiesEmpty: false,
+    ...overrides,
+  };
+}
+
+function makeUsage(slug: string, org = "test-org") {
+  return {
+    mcpServerRef: { slug, org, kind: 0 },
+    toolApprovalOverrides: [],
+  } as any;
+}
+
+function makeMockClient(overrides: Record<string, unknown> = {}) {
+  return {
+    getMcpServerByReference: vi.fn().mockResolvedValue({
+      metadata: { id: "server-id-123" },
+      spec: { env: {} },
+    }),
+    connectMcpServer: vi.fn().mockResolvedValue({
+      status: {
+        discoveredCapabilities: { tools: [{ name: "tool1" }], resourceTemplates: [] },
+        toolApprovals: [{ toolName: "tool1", message: "Classified" }],
+      },
+    }),
+    ...overrides,
+  } as any;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// needsBackfill
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("needsBackfill", () => {
+  it("returns true when discoveredCapabilitiesEmpty is true", () => {
+    expect(needsBackfill(makeServer({ discoveredCapabilitiesEmpty: true }))).toBe(true);
+  });
+
+  it("returns false when discoveredCapabilitiesEmpty is false", () => {
+    expect(needsBackfill(makeServer({ discoveredCapabilitiesEmpty: false }))).toBe(false);
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// extractRuntimeEnvForServer
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("extractRuntimeEnvForServer", () => {
+  it("returns undefined when server has no env declarations", () => {
+    expect(extractRuntimeEnvForServer({ spec: {} }, { FOO: "bar" })).toBeUndefined();
+    expect(extractRuntimeEnvForServer({}, { FOO: "bar" })).toBeUndefined();
+  });
+
+  it("returns undefined when env declarations are empty", () => {
+    expect(extractRuntimeEnvForServer({ spec: { env: {} } }, { FOO: "bar" })).toBeUndefined();
+  });
+
+  it("returns only declared keys present in merged env with isSecret from declarations", () => {
+    const server = {
+      spec: {
+        env: {
+          API_KEY: { isSecret: true },
+          DB_URL: { isSecret: false },
+          UNUSED: { isSecret: false },
+        },
+      },
+    };
+    const mergedEnv = { API_KEY: "secret123", DB_URL: "postgres://localhost" };
+    const result = extractRuntimeEnvForServer(server, mergedEnv);
+    expect(result).toEqual({
+      API_KEY: { value: "secret123", isSecret: true },
+      DB_URL: { value: "postgres://localhost", isSecret: false },
+    });
+  });
+
+  it("falls back to secretKeys when declaration has no isSecret", () => {
+    const server = { spec: { env: { TOKEN: {}, OTHER: {} } } };
+    const mergedEnv = { TOKEN: "abc", OTHER: "def" };
+    const secretKeys = new Set(["TOKEN"]);
+    const result = extractRuntimeEnvForServer(server, mergedEnv, secretKeys);
+    expect(result).toEqual({
+      TOKEN: { value: "abc", isSecret: true },
+      OTHER: { value: "def", isSecret: false },
+    });
+  });
+
+  it("returns undefined when no declared keys are in merged env", () => {
+    const server = { spec: { env: { MISSING_KEY: {} } } };
+    expect(extractRuntimeEnvForServer(server, { OTHER: "val" })).toBeUndefined();
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// backfillMcpServersIfNeeded
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("backfillMcpServersIfNeeded", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  it("returns original servers unchanged when none need backfill", async () => {
+    const servers = [
+      makeServer({ slug: "a", discoveredCapabilitiesEmpty: false }),
+      makeServer({ slug: "b", discoveredCapabilitiesEmpty: false }),
+    ];
+    const client = makeMockClient();
+
+    const result = await backfillMcpServersIfNeeded(
+      client, servers, [], {}, "org",
+    );
+
+    expect(result).toBe(servers);
+    expect(client.getMcpServerByReference).not.toHaveBeenCalled();
+    expect(client.connectMcpServer).not.toHaveBeenCalled();
+  });
+
+  it("returns the same array reference for early-return (no backfill needed)", async () => {
+    const servers = [makeServer({ discoveredCapabilitiesEmpty: false })];
+    const client = makeMockClient();
+
+    const result = await backfillMcpServersIfNeeded(
+      client, servers, [], {}, "org",
+    );
+
+    expect(result).toBe(servers);
+  });
+
+  it("triggers connect RPC for servers with empty capabilities", async () => {
+    const servers = [
+      makeServer({ slug: "needs-backfill", discoveredCapabilitiesEmpty: true }),
+    ];
+    const usages = [makeUsage("needs-backfill")];
+    const client = makeMockClient();
+
+    vi.spyOn(await import("../mcp-resolver.js"), "resolveMcpServers").mockResolvedValue({
+      resolvedServers: [makeServer({ slug: "needs-backfill", discoveredCapabilitiesEmpty: false })],
+    });
+
+    const result = await backfillMcpServersIfNeeded(
+      client, servers, usages, {}, "org",
+    );
+
+    expect(client.getMcpServerByReference).toHaveBeenCalledOnce();
+    expect(client.connectMcpServer).toHaveBeenCalledWith("server-id-123", "org", undefined);
+    expect(result).not.toBe(servers);
+    expect(result[0].discoveredCapabilitiesEmpty).toBe(false);
+  });
+
+  it("only backfills servers that need it, leaves others alone", async () => {
+    const servers = [
+      makeServer({ slug: "ok", discoveredCapabilitiesEmpty: false }),
+      makeServer({ slug: "empty", discoveredCapabilitiesEmpty: true }),
+    ];
+    const usages = [makeUsage("ok"), makeUsage("empty")];
+    const client = makeMockClient();
+
+    const refreshedServers = [
+      makeServer({ slug: "ok", discoveredCapabilitiesEmpty: false }),
+      makeServer({ slug: "empty", discoveredCapabilitiesEmpty: false }),
+    ];
+    vi.spyOn(await import("../mcp-resolver.js"), "resolveMcpServers").mockResolvedValue({
+      resolvedServers: refreshedServers,
+    });
+
+    const result = await backfillMcpServersIfNeeded(
+      client, servers, usages, {}, "org",
+    );
+
+    expect(client.connectMcpServer).toHaveBeenCalledOnce();
+    expect(result).toEqual(refreshedServers);
+  });
+
+  it("passes runtime env to connect RPC when server declares env vars", async () => {
+    const servers = [
+      makeServer({ slug: "with-env", discoveredCapabilitiesEmpty: true }),
+    ];
+    const usages = [makeUsage("with-env")];
+    const mergedEnv = { API_KEY: "secret", OTHER: "ignored" };
+    const client = makeMockClient({
+      getMcpServerByReference: vi.fn().mockResolvedValue({
+        metadata: { id: "env-server-id" },
+        spec: { env: { API_KEY: { is_secret: true } } },
+      }),
+    });
+
+    vi.spyOn(await import("../mcp-resolver.js"), "resolveMcpServers").mockResolvedValue({
+      resolvedServers: [makeServer({ slug: "with-env", discoveredCapabilitiesEmpty: false })],
+    });
+
+    await backfillMcpServersIfNeeded(
+      client, servers, usages, mergedEnv, "org",
+    );
+
+    expect(client.connectMcpServer).toHaveBeenCalledWith(
+      "env-server-id", "org", { API_KEY: { value: "secret", isSecret: false } },
+    );
+  });
+
+  it("preserves original servers when connect RPC fails", async () => {
+    const servers = [
+      makeServer({ slug: "failing", discoveredCapabilitiesEmpty: true }),
+    ];
+    const usages = [makeUsage("failing")];
+    const client = makeMockClient({
+      connectMcpServer: vi.fn().mockRejectedValue(new Error("Connection refused")),
+    });
+
+    const result = await backfillMcpServersIfNeeded(
+      client, servers, usages, {}, "org",
+    );
+
+    expect(result).toBe(servers);
+  });
+
+  it("preserves original servers when connect RPC times out", async () => {
+    const servers = [
+      makeServer({ slug: "slow", discoveredCapabilitiesEmpty: true }),
+    ];
+    const usages = [makeUsage("slow")];
+    const client = makeMockClient({
+      connectMcpServer: vi.fn().mockImplementation(
+        () => new Promise((resolve) => setTimeout(resolve, 120_000)),
+      ),
+    });
+
+    const result = await backfillMcpServersIfNeeded(
+      client, servers, usages, {}, "org",
+    );
+
+    expect(result).toBe(servers);
+  }, 70_000);
+
+  it("invokes onHeartbeat callback at correct points", async () => {
+    const servers = [
+      makeServer({ slug: "hb-test", discoveredCapabilitiesEmpty: true }),
+    ];
+    const usages = [makeUsage("hb-test")];
+    const client = makeMockClient();
+    const onHeartbeat = vi.fn();
+
+    vi.spyOn(await import("../mcp-resolver.js"), "resolveMcpServers").mockResolvedValue({
+      resolvedServers: [makeServer({ slug: "hb-test", discoveredCapabilitiesEmpty: false })],
+    });
+
+    await backfillMcpServersIfNeeded(
+      client, servers, usages, {}, "org", onHeartbeat,
+    );
+
+    expect(onHeartbeat).toHaveBeenCalledTimes(2);
+  });
+
+  it("skips servers that have no matching usage ref", async () => {
+    const servers = [
+      makeServer({ slug: "orphan", discoveredCapabilitiesEmpty: true }),
+    ];
+    const client = makeMockClient();
+
+    const result = await backfillMcpServersIfNeeded(
+      client, servers, [], {}, "org",
+    );
+
+    expect(client.getMcpServerByReference).not.toHaveBeenCalled();
+    expect(result).toBe(servers);
+  });
+
+  it("skips servers where getMcpServerByReference returns no id", async () => {
+    const servers = [
+      makeServer({ slug: "no-id", discoveredCapabilitiesEmpty: true }),
+    ];
+    const usages = [makeUsage("no-id")];
+    const client = makeMockClient({
+      getMcpServerByReference: vi.fn().mockResolvedValue({
+        metadata: {},
+        spec: {},
+      }),
+    });
+
+    const result = await backfillMcpServersIfNeeded(
+      client, servers, usages, {}, "org",
+    );
+
+    expect(client.connectMcpServer).not.toHaveBeenCalled();
+    expect(result).toBe(servers);
+  });
+
+  it("re-resolves after partial success (one fails, one succeeds)", async () => {
+    const servers = [
+      makeServer({ slug: "fail-me", discoveredCapabilitiesEmpty: true }),
+      makeServer({ slug: "succeed", discoveredCapabilitiesEmpty: true }),
+    ];
+    const usages = [makeUsage("fail-me"), makeUsage("succeed")];
+
+    let callCount = 0;
+    const client = makeMockClient({
+      getMcpServerByReference: vi.fn().mockImplementation((ref: any) => ({
+        metadata: { id: `id-${ref.slug}` },
+        spec: { env: {} },
+      })),
+      connectMcpServer: vi.fn().mockImplementation((serverId: string) => {
+        callCount++;
+        if (serverId === "id-fail-me") {
+          return Promise.reject(new Error("Unreachable"));
+        }
+        return Promise.resolve({
+          status: {
+            discoveredCapabilities: { tools: [], resourceTemplates: [] },
+            toolApprovals: [],
+          },
+        });
+      }),
+    });
+
+    const refreshed = [
+      makeServer({ slug: "fail-me", discoveredCapabilitiesEmpty: true }),
+      makeServer({ slug: "succeed", discoveredCapabilitiesEmpty: false }),
+    ];
+    vi.spyOn(await import("../mcp-resolver.js"), "resolveMcpServers").mockResolvedValue({
+      resolvedServers: refreshed,
+    });
+
+    const result = await backfillMcpServersIfNeeded(
+      client, servers, usages, {}, "org",
+    );
+
+    expect(callCount).toBe(2);
+    expect(result).toEqual(refreshed);
+  });
+});

package/src/shared/__tests__/extract-json.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, expect } from "vitest";
+import { extractJsonFromText } from "../extract-json.js";
+
+/**
+ * Exact agent response from the production failure (truncated for test).
+ * The agent returned prose + markdown-fenced JSON.
+ */
+const PRODUCTION_RESPONSE = `Now I have sufficient data to generate the cohort analysis report. Based on my analysis:
+
+\`\`\`json
+{
+  "executive_summary": "DAU remains stable at 7,175 (+1.4% vs 7-day average). Critical attention needed for D3 drop-offs.",
+  "dau": 7175,
+  "dau_trend_pct": 1.38,
+  "cohorts": [
+    {
+      "name": "D1 New Players",
+      "size": 10,
+      "retention_trend": "Low acquisition volume, needs investigation",
+      "action_needed": true
+    },
+    {
+      "name": "D3 Drop-offs",
+      "size": 3589,
+      "retention_trend": "High drop-off concentration in Cuba, Indonesia, India",
+      "action_needed": true
+    }
+  ],
+  "anomalies": [
+    {
+      "metric": "D1 New Acquisition",
+      "severity": "warning",
+      "description": "Only 10 new D1 players vs expected ~200-300"
+    }
+  ],
+  "data_quality_notes": "Latest event_date: 2026-05-21 (3 days lag)."
+}
+\`\`\``;
+
+describe("extractJsonFromText", () => {
+  describe("Tier 1: direct JSON.parse", () => {
+    it("parses pure JSON string", () => {
+      const json = '{"name": "test", "value": 42}';
+      const result = extractJsonFromText(json);
+      expect(result).toEqual({ name: "test", value: 42 });
+    });
+
+    it("parses pure JSON array", () => {
+      const json = '[1, 2, 3]';
+      const result = extractJsonFromText(json);
+      expect(result).toEqual([1, 2, 3]);
+    });
+  });
+
+  describe("Tier 1.5: code-fence extraction", () => {
+    it("extracts JSON from ```json code fence", () => {
+      const text = 'Here is the result:\n\n```json\n{"key": "value"}\n```\n\nDone.';
+      const result = extractJsonFromText(text);
+      expect(result).toEqual({ key: "value" });
+    });
+
+    it("extracts JSON from bare ``` code fence (no language tag)", () => {
+      const text = 'Result:\n\n```\n{"answer": 42}\n```';
+      const result = extractJsonFromText(text);
+      expect(result).toEqual({ answer: 42 });
+    });
+
+    it("extracts the production failure response", () => {
+      const result = extractJsonFromText(PRODUCTION_RESPONSE);
+      expect(result).toBeDefined();
+      expect(result).toHaveProperty("executive_summary");
+      expect(result).toHaveProperty("dau", 7175);
+      expect(result).toHaveProperty("cohorts");
+      expect((result as Record<string, unknown>).cohorts).toHaveLength(2);
+    });
+
+    it("picks the valid JSON fence when multiple fences exist", () => {
+      const text = `Here's the SQL query:
+
+\`\`\`sql
+SELECT * FROM users;
+\`\`\`
+
+And the result:
+
+\`\`\`json
+{"users": 42}
+\`\`\``;
+      const result = extractJsonFromText(text);
+      expect(result).toEqual({ users: 42 });
+    });
+
+    it("handles code fence with trailing whitespace", () => {
+      const text = '```json\n{"ok": true}\n```  \n';
+      const result = extractJsonFromText(text);
+      expect(result).toEqual({ ok: true });
+    });
+  });
+
+  describe("Tier 1.75: heuristic brace extraction", () => {
+    it("extracts JSON from prose without code fences", () => {
+      const text = 'The analysis is complete. {"status": "done", "count": 5} That is the result.';
+      const result = extractJsonFromText(text);
+      expect(result).toEqual({ status: "done", count: 5 });
+    });
+
+    it("extracts the last JSON object when multiple exist in prose", () => {
+      const text = `Here is some debug output: {"debug": true, "step": 1}
+More analysis text here.
+Final result: {"answer": 42, "final": true}`;
+      const result = extractJsonFromText(text);
+      expect(result).toEqual({ answer: 42, final: true });
+    });
+
+    it("extracts JSON when prose follows the JSON object", () => {
+      const text = `Analysis complete. Here is the result:
+{"status": "done", "metrics": {"dau": 7175}}
+Done! The workflow has finished.`;
+      const result = extractJsonFromText(text);
+      expect(result).toEqual({ status: "done", metrics: { dau: 7175 } });
+    });
+
+    it("extracts JSON from prose ending with a JSON object (production failure pattern)", () => {
+      const text = `Now let me compile the notification plan based on the data I've analyzed.
+
+I've reviewed the player cohorts and identified the key metrics. The DAU is stable at 7,175 with a slight upward trend.
+
+{"executive_summary": "DAU stable at 7,175 (+1.4%). D3 drop-offs need attention.", "dau": 7175, "dau_trend_pct": 1.38, "cohorts": [{"name": "D1 New Players", "size": 10, "retention_trend": "Low acquisition", "action_needed": true}], "anomalies": [{"metric": "D1 New Acquisition", "severity": "warning", "description": "Only 10 new D1 players"}], "data_quality_notes": "3 days lag"}`;
+      const result = extractJsonFromText(text);
+      expect(result).toBeDefined();
+      expect(result).toHaveProperty("executive_summary");
+      expect(result).toHaveProperty("dau", 7175);
+      expect((result as Record<string, unknown>).cohorts).toHaveLength(1);
+    });
+  });
+
+  describe("failure cases", () => {
+    it("returns undefined for plain text with no JSON", () => {
+      const result = extractJsonFromText("This is just regular text with no JSON content.");
+      expect(result).toBeUndefined();
+    });
+
+    it("returns undefined for empty string", () => {
+      expect(extractJsonFromText("")).toBeUndefined();
+    });
+
+    it("returns undefined for malformed JSON in code fence", () => {
+      const text = '```json\n{broken json\n```';
+      const result = extractJsonFromText(text);
+      expect(result).toBeUndefined();
+    });
+  });
+});

package/src/shared/__tests__/grpc-retry-extended.test.ts

@@ -0,0 +1,176 @@
+/**
+ * Extended gRPC retry tests — ported from Python test_grpc_retry.py.
+ *
+ * Covers config validation, backoff timing, INTERNAL error handling,
+ * mixed error sequences, and max-retries edge cases beyond the core
+ * 15 tests in grpc-retry.test.ts.
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import { ConnectError, Code } from "@connectrpc/connect";
+import { create } from "@bufbuild/protobuf";
+import { AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { ExecutionControlSignal } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { persistWithRetry, isRetryableError, isTerminalError } from "../grpc-retry.js";
+import type { StigmerClient } from "../../client/stigmer-client.js";
+
+function makeStatus() {
+  return create(AgentExecutionStatusSchema, {});
+}
+
+function mockClient(
+  impl: (...args: unknown[]) => Promise<{ signal: ExecutionControlSignal }>,
+): StigmerClient {
+  return { updateStatus: impl } as unknown as StigmerClient;
+}
+
+const noDelay = async () => {};
+
+describe("isRetryableError — extended codes", () => {
+  it("returns false for INTERNAL", () => {
+    expect(isRetryableError(new ConnectError("err", Code.Internal))).toBe(false);
+  });
+
+  it("returns false for ALREADY_EXISTS", () => {
+    expect(isRetryableError(new ConnectError("dup", Code.AlreadyExists))).toBe(false);
+  });
+
+  it("returns false for CANCELLED", () => {
+    expect(isRetryableError(new ConnectError("cancelled", Code.Canceled))).toBe(false);
+  });
+});
+
+describe("isTerminalError — extended codes", () => {
+  it("returns false for INTERNAL", () => {
+    expect(isTerminalError(new ConnectError("err", Code.Internal))).toBe(false);
+  });
+
+  it("returns false for DEADLINE_EXCEEDED", () => {
+    expect(isTerminalError(new ConnectError("slow", Code.DeadlineExceeded))).toBe(false);
+  });
+
+  it("returns false for non-ConnectError", () => {
+    expect(isTerminalError(new Error("random"))).toBe(false);
+  });
+});
+
+describe("persistWithRetry — extended scenarios", () => {
+  it("does not retry INTERNAL errors (neither retryable nor terminal)", async () => {
+    let attempt = 0;
+    const client = mockClient(async () => {
+      attempt++;
+      throw new ConnectError("internal", Code.Internal);
+    });
+
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    await persistWithRetry(client, "exec-int", makeStatus(), {
+      maxRetries: 3,
+      delayFn: noDelay,
+    });
+    errorSpy.mockRestore();
+
+    expect(attempt).toBe(1);
+  });
+
+  it("does not retry ALREADY_EXISTS", async () => {
+    let attempt = 0;
+    const client = mockClient(async () => {
+      attempt++;
+      throw new ConnectError("exists", Code.AlreadyExists);
+    });
+
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    await persistWithRetry(client, "exec-ae", makeStatus(), {
+      maxRetries: 3,
+      delayFn: noDelay,
+    });
+    errorSpy.mockRestore();
+
+    expect(attempt).toBe(1);
+  });
+
+  it("handles mixed error sequence: retryable then terminal", async () => {
+    let attempt = 0;
+    const client = mockClient(async () => {
+      attempt++;
+      if (attempt === 1) throw new ConnectError("down", Code.Unavailable);
+      throw new ConnectError("gone", Code.NotFound);
+    });
+
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const signal = await persistWithRetry(client, "exec-mix", makeStatus(), {
+      delayFn: noDelay,
+    });
+    warnSpy.mockRestore();
+    errorSpy.mockRestore();
+
+    expect(attempt).toBe(2);
+    expect(signal).toBe(ExecutionControlSignal.UNSPECIFIED);
+  });
+
+  it("handles retryable then success", async () => {
+    let attempt = 0;
+    const client = mockClient(async () => {
+      attempt++;
+      if (attempt <= 2) throw new ConnectError("timeout", Code.DeadlineExceeded);
+      return { signal: ExecutionControlSignal.STOP };
+    });
+
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const signal = await persistWithRetry(client, "exec-ret", makeStatus(), {
+      maxRetries: 5,
+      delayFn: noDelay,
+    });
+    warnSpy.mockRestore();
+
+    expect(signal).toBe(ExecutionControlSignal.STOP);
+    expect(attempt).toBe(3);
+  });
+
+  it("maxRetries = 0 means one attempt only", async () => {
+    let attempt = 0;
+    const client = mockClient(async () => {
+      attempt++;
+      throw new ConnectError("down", Code.Unavailable);
+    });
+
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    await persistWithRetry(client, "exec-0", makeStatus(), {
+      maxRetries: 0,
+      delayFn: noDelay,
+    });
+    errorSpy.mockRestore();
+
+    expect(attempt).toBe(1);
+  });
+
+  it("respects custom backoff factor", async () => {
+    const delays: number[] = [];
+    const client = mockClient(async () => {
+      throw new ConnectError("down", Code.Unavailable);
+    });
+
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    await persistWithRetry(client, "exec-bf", makeStatus(), {
+      baseDelayMs: 50,
+      backoffFactor: 3,
+      maxRetries: 3,
+      delayFn: async (ms) => { delays.push(ms); },
+    });
+    warnSpy.mockRestore();
+    errorSpy.mockRestore();
+
+    expect(delays).toEqual([50, 150, 450]);
+  });
+
+  it("uses default options when none provided", async () => {
+    const client = mockClient(async () => ({
+      signal: ExecutionControlSignal.UNSPECIFIED,
+    }));
+
+    const signal = await persistWithRetry(client, "exec-default", makeStatus());
+    expect(signal).toBe(ExecutionControlSignal.UNSPECIFIED);
+  });
+});