@stigmer/runner 3.11.0 → 3.12.0

package/src/activities/emit-event.ts

@@ -9,12 +9,24 @@
  *
  * Supported delivery targets:
  * - webhook: HTTP POST with Content-Type: application/cloudevents+json
- * - signal:  Temporal signal to another running workflow's listen task
+ * - signal:  signal to another workflow execution's listen task, routed
+ *            through the server's SendSignal lane
+ *
+ * Signal delivery is deliberately server-mediated (oss#517): a direct
+ * Temporal client here would bypass the authorization boundary (any
+ * workflow could signal any workflow id in the namespace) and is
+ * structurally incompatible with payload encryption — emit→listen is
+ * the platform's only runner-to-runner channel, and under per-identity
+ * runner keys a sender-encrypted signal fails closed at a receiver
+ * holding a different key. The server re-produces the payload, so each
+ * side's codec passes it through.
  *
  * CloudEvents spec: https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md
  */
 
 import { randomUUID } from "node:crypto";
+import type { JsonObject } from "@bufbuild/protobuf";
+import { StigmerClient } from "../client/stigmer-client.js";
 import { loadConfig } from "../config.js";
 import { resolveRuntimePlaceholders } from "../workflow-engine/resolve.js";
 
@@ -24,7 +36,9 @@ export interface WebhookDeliveryTarget {
 }
 
 export interface SignalDeliveryTarget {
-  readonly workflow_id: string;
+  /** Target workflow execution id ("wfx_..."), as returned by run/create. */
+  readonly execution_id: string;
+  /** Signal name matching the target's listen task event id (verbatim). */
   readonly signal_name: string;
 }
 
@@ -54,6 +68,11 @@ export interface EmitEventResult {
 
 const WEBHOOK_TIMEOUT_MS = 30_000;
 
+// Delivery is best-effort by contract, so no single target may consume the
+// CallFunction activity's whole 5m startToClose budget. Same bound as the
+// webhook arm.
+const SIGNAL_TIMEOUT_MS = 30_000;
+
 function buildEnvelope(
   config: EmitEventConfig,
   executionId: string,
@@ -120,33 +139,53 @@ async function deliverWebhook(
   }
 }
 
+function buildClient(): StigmerClient {
+  const config = loadConfig();
+  return new StigmerClient({
+    endpoint: config.stigmerBackendEndpoint,
+    token: config.stigmerToken,
+  });
+}
+
 async function deliverSignal(
   envelope: Record<string, unknown>,
   target: SignalDeliveryTarget,
+  client: StigmerClient,
 ): Promise<DeliveryError | null> {
-  try {
-    const { Connection, Client } = await import("@temporalio/client");
-
-    // Resolve Temporal coordinates through the central config layer rather than
-    // reading env directly: signal delivery must dial the SAME cluster/namespace
-    // the worker connected with. config.ts is the single source of truth for the
-    // canonical TEMPORAL_SERVICE_ADDRESS / TEMPORAL_NAMESPACE resolution — reading
-    // env here would diverge (and previously dialed localhost via a stale name).
-    const config = loadConfig();
-    const temporalAddress = config.temporalAddress;
-    const temporalNamespace = config.temporalNamespace;
-
-    const connection = await Connection.connect({ address: temporalAddress });
-    const client = new Client({ connection, namespace: temporalNamespace });
-
-    const handle = client.workflow.getHandle(target.workflow_id);
-    await handle.signal(target.signal_name, envelope);
+  // Refuse the pre-oss#517 field by name: direct-addressing raw Temporal
+  // workflow ids is exactly the capability server mediation removes.
+  const legacyWorkflowId = (target as { workflow_id?: unknown }).workflow_id;
+  if (!target.execution_id) {
+    const reason = legacyWorkflowId
+      ? "signal delivery addresses workflow executions by 'execution_id' (\"wfx_...\"); 'workflow_id' is not supported"
+      : "signal delivery requires 'execution_id'";
+    return {
+      target: `signal:${String(legacyWorkflowId ?? "")}/${target.signal_name ?? ""}`,
+      error: reason,
+    };
+  }
+  if (!target.signal_name) {
+    return {
+      target: `signal:${target.execution_id}/`,
+      error: "signal delivery requires 'signal_name'",
+    };
+  }
 
+  try {
+    await client.sendWorkflowSignal(
+      target.execution_id,
+      target.signal_name,
+      envelope as JsonObject,
+      { timeoutMs: SIGNAL_TIMEOUT_MS },
+    );
     return null;
   } catch (err) {
+    // Server refusals arrive as ConnectErrors whose messages carry the code
+    // (e.g. [not_found], [failed_precondition] for terminal executions) —
+    // surfaced verbatim in delivery_errors, same contract as the webhook arm.
     const message = err instanceof Error ? err.message : String(err);
     return {
-      target: `signal:${target.workflow_id}/${target.signal_name}`,
+      target: `signal:${target.execution_id}/${target.signal_name}`,
       error: message,
     };
   }
@@ -173,13 +212,18 @@ export async function emitEventAction(
   const errors: DeliveryError[] = [];
   const env = runtimeEnv ?? {};
 
+  // One client serves all signal targets of this emit; constructed lazily so
+  // webhook-only emits never pay for a gRPC transport.
+  let client: StigmerClient | undefined;
+
   for (const target of config.delivery) {
     let err: DeliveryError | null = null;
 
     if ("webhook" in target) {
       err = await deliverWebhook(envelope, target.webhook, env);
     } else if ("signal" in target) {
-      err = await deliverSignal(envelope, target.signal);
+      client ??= buildClient();
+      err = await deliverSignal(envelope, target.signal, client);
     }
 
     if (err) {

package/src/activities/execute-cursor/__tests__/attachment-resolver.test.ts

@@ -78,7 +78,11 @@ describe("resolveAttachments", () => {
     const result = await resolveAttachments([makeAttachment()], options({ storage }));
 
     expect(result).toEqual([
-      { filename: "plan.md", relativePath: ".stigmer/inputs/plan.md" },
+      {
+        filename: "plan.md",
+        relativePath: ".stigmer/inputs/plan.md",
+        downloadUrl: "mem://attachments/01ABC/plan.md",
+      },
     ]);
     expect(readFileSync(join(platformDir, "inputs", "plan.md"), "utf-8")).toBe("# The Plan");
   });
@@ -130,11 +134,16 @@ describe("resolveAttachments", () => {
     );
 
     expect(result).toEqual([
-      { filename: "report.pdf", relativePath: ".stigmer/inputs/report.pdf" },
+      {
+        filename: "report.pdf",
+        relativePath: ".stigmer/inputs/report.pdf",
+        downloadUrl: "mem://attachments/01AAA/report.pdf",
+      },
       {
         filename: "report-2.pdf",
         relativePath: ".stigmer/inputs/report-2.pdf",
         renamedFrom: "report.pdf",
+        downloadUrl: "mem://attachments/01BBB/report.pdf",
       },
     ]);
     expect(readFileSync(join(platformDir, "inputs", "report.pdf"), "utf-8")).toBe("first bytes");
@@ -155,12 +164,15 @@ describe("resolveAttachments", () => {
       options({ storage }),
     );
 
+    // The key-less local file lists no URL; the storage twin does — the
+    // per-file split the prompt renders.
     expect(result).toEqual([
       { filename: "notes.md", relativePath: ".stigmer/inputs/notes.md" },
       {
         filename: "notes-2.md",
         relativePath: ".stigmer/inputs/notes-2.md",
         renamedFrom: "notes.md",
+        downloadUrl: "mem://attachments/01ABC/notes.md",
       },
     ]);
     expect(readFileSync(join(platformDir, "inputs", "notes.md"), "utf-8")).toBe("local copy");
@@ -225,7 +237,11 @@ describe("resolveAttachments", () => {
     );
 
     expect(result).toEqual([
-      { filename: "evil.md", relativePath: ".stigmer/inputs/evil.md" },
+      {
+        filename: "evil.md",
+        relativePath: ".stigmer/inputs/evil.md",
+        downloadUrl: "mem://attachments/01ABC/x",
+      },
     ]);
     expect(readFileSync(join(platformDir, "inputs", "evil.md"), "utf-8")).toBe("contained");
     // Nothing escaped two levels up (where `../../evil.md` would have landed).
@@ -247,6 +263,50 @@ describe("resolveAttachments", () => {
     expect(readFileSync(join(platformDir, "inputs", "evil.txt"), "utf-8")).toBe("local-contained");
   });
 
+  // ── Download-URL hand-off (issue #532) ───────────────────────────────────
+  // The URL is strictly additive (shared/attachment-download-urls.ts): every
+  // case below also asserts the file materialized exactly as it would
+  // without one.
+
+  describe("download-URL minting during resolution", () => {
+    it("degrades to no URL when the mint fails — file still materialized, turn proceeds", async () => {
+      const { storage } = makeInMemoryArtifactStorage();
+      await storage.upload("attachments/01ABC/plan.md", Buffer.from("# The Plan"), "text/markdown");
+      storage.getDownloadUrl.mockRejectedValueOnce(new Error("presign endpoint unreachable"));
+
+      const result = await resolveAttachments([makeAttachment()], options({ storage }));
+
+      expect(result).toEqual([
+        { filename: "plan.md", relativePath: ".stigmer/inputs/plan.md" },
+      ]);
+      expect(readFileSync(join(platformDir, "inputs", "plan.md"), "utf-8")).toBe("# The Plan");
+    });
+
+    it("mints a URL on the localPath fast path when an uploaded copy also exists", async () => {
+      // The fast path skips storage for the BYTES; the mint rule is
+      // branch-independent, so the uploaded copy still backs the URL.
+      const srcPath = join(workspaceDir, "src.csv");
+      writeFileSync(srcPath, "a,b,c");
+      const { storage } = makeInMemoryArtifactStorage();
+
+      const result = await resolveAttachments(
+        [makeAttachment({ filename: "data.csv", storageKey: "attachments/01ABC/data.csv", localPath: srcPath })],
+        options({ storage }),
+      );
+
+      expect(result).toEqual([
+        {
+          filename: "data.csv",
+          relativePath: ".stigmer/inputs/data.csv",
+          downloadUrl: "mem://attachments/01ABC/data.csv",
+        },
+      ]);
+      // Bytes came off local disk, not storage — the fast path is intact.
+      expect(storage.download).not.toHaveBeenCalled();
+      expect(readFileSync(join(platformDir, "inputs", "data.csv"), "utf-8")).toBe("a,b,c");
+    });
+  });
+
   // ── Vision selection (T04) ────────────────────────────────────────────────
   // Vision is strictly additive: every case below also asserts the file
   // materialized exactly as it would without a budget.

package/src/activities/execute-cursor/__tests__/build-prompt.test.ts

@@ -9,12 +9,10 @@
 
 import { describe, it, expect } from "vitest";
 import { create } from "@bufbuild/protobuf";
-import { DatastoreUsageSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb";
 import { ApprovalAction, InteractionMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { PendingApprovalSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/approval_pb";
-import { ApiResourceReferenceSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
 
-import { buildPrompt, isHitlReinvocation } from "../index.js";
+import { appendStructuredOutputDirective, buildPrompt, isHitlReinvocation, primarySendCarriesImages } from "../index.js";
 import type { BuildPromptInput } from "../index.js";
 import { buildReinvocationPrompt, formatInteractionModePrefix, formatImplementPlanSection, formatToolApprovalProtocol, buildToolApprovalRuleFile } from "../prompt-builder.js";
 import { PLAN_MODE_DIRECTIVE } from "../../../shared/plan-mode-prompt.js";
@@ -89,33 +87,6 @@ describe("buildPrompt", () => {
     expect(prompt).toContain(USER_MESSAGE);
   });
 
-  it("renders the <available_datastores> section on the first execution (T05)", () => {
-    const prompt = buildPrompt(
-      input({
-        resolution: resolution("local", "created_first_execution"),
-        datastoreUsages: [
-          create(DatastoreUsageSchema, {
-            datastoreRef: create(ApiResourceReferenceSchema, { slug: "clinic" }),
-          }),
-        ],
-      }),
-    );
-    expect(prompt).toContain("<available_datastores>");
-    expect(prompt).toContain("- clinic");
-    expect(prompt).toContain("describe_datastore");
-    // The standing failure-disclosure instruction (issue #325) is this
-    // harness's ONLY outage coverage: the Cursor SDK connects MCP itself,
-    // so the runner can never reconcile the live roster here.
-    expect(prompt).toContain("do not answer from memory");
-  });
-
-  it("omits the datastores section when the agent uses no datastores", () => {
-    const prompt = buildPrompt(
-      input({ resolution: resolution("local", "created_first_execution") }),
-    );
-    expect(prompt).not.toContain("<available_datastores>");
-  });
-
   it("carries the rollover context bridge on the first execution (DD-013)", () => {
     const prompt = buildPrompt(
       input({
@@ -255,7 +226,7 @@ describe("buildPrompt", () => {
   });
 });
 
-describe("isHitlReinvocation (the single discriminator for message-accompanied payloads)", () => {
+describe("isHitlReinvocation (paired with resolution.reason at every consumer — issue #366)", () => {
   it("is false with no decisions and false with an empty map", () => {
     expect(isHitlReinvocation(undefined)).toBe(false);
     expect(isHitlReinvocation(new Map())).toBe(false);
@@ -268,6 +239,115 @@ describe("isHitlReinvocation (the single discriminator for message-accompanied p
   });
 });
 
+describe("HITL recovery — fresh agent mid-HITL (issue #366)", () => {
+  const decisions = () =>
+    new Map<string, ApprovalAction>([["tool-call-1", ApprovalAction.APPROVE]]);
+  const approvals = () => [
+    create(PendingApprovalSchema, {
+      toolCallId: "tool-call-1",
+      toolName: "Write",
+      message: "Write file: gated.txt",
+    }),
+  ];
+  const recoveryInput = (overrides: Partial<BuildPromptInput> = {}) =>
+    input({
+      resolution: resolution("local", "created_after_resume_failure"),
+      approvalDecisions: decisions(),
+      pendingApprovals: approvals(),
+      ...overrides,
+    });
+
+  it("keeps the resumed-HITL prompt byte-identical to the bare reinvocation prompt (regression guard)", () => {
+    const prompt = buildPrompt(
+      input({
+        resolution: resolution("local", "resumed_successfully"),
+        approvalDecisions: decisions(),
+        pendingApprovals: approvals(),
+      }),
+    );
+    expect(prompt).toBe(buildReinvocationPrompt(approvals(), decisions()));
+  });
+
+  it("rebuilds full context for a fresh agent mid-HITL: instructions, the ORIGINAL user message, the state-loss disclosure, and the decisions", () => {
+    const prompt = buildPrompt(recoveryInput());
+    // The pre-fix failure mode: bare decisions with no story.
+    expect(prompt).not.toBe(buildReinvocationPrompt(approvals(), decisions()));
+    expect(prompt).toContain("<agent_instructions>");
+    expect(prompt).toContain("<tool_approval_protocol>");
+    expect(prompt).toContain(`<user_request>\n${USER_MESSAGE}\n</user_request>`);
+    expect(prompt).toContain("<turn_recovery>");
+    expect(prompt).toContain("Write file: gated.txt");
+    expect(prompt).toContain("APPROVED");
+    // The opaque tool-call id must not leak into the prompt (reinvocation rule).
+    expect(prompt).not.toContain("tool-call-1");
+  });
+
+  it("orders the recovery chronologically: request, then the recovered work, then the decisions, ending on the continue directive", () => {
+    const prompt = buildPrompt(
+      recoveryInput({ turnRecoveryDigest: "Tool: Write file: draft.txt — completed" }),
+    );
+    const requestIdx = prompt.indexOf("<user_request>");
+    const recoveryIdx = prompt.indexOf("<turn_recovery>");
+    const decisionsIdx = prompt.indexOf("APPROVED");
+    expect(requestIdx).toBeGreaterThan(-1);
+    expect(recoveryIdx).toBeGreaterThan(requestIdx);
+    expect(decisionsIdx).toBeGreaterThan(recoveryIdx);
+    expect(prompt).toContain("Tool: Write file: draft.txt — completed");
+    expect(prompt.trimEnd().endsWith("do not ask the user for permission in prose.")).toBe(true);
+  });
+
+  it("discloses the state loss even with NO transcript — otherwise the decisions read as reactions to proposals this agent never made", () => {
+    const prompt = buildPrompt(recoveryInput({ turnRecoveryDigest: undefined }));
+    expect(prompt).toContain("<turn_recovery>");
+    expect(prompt).toContain("no transcript of your progress is available");
+  });
+
+  it("preserves already-applied semantics: exact-applied writes are described as done, not as work to redo", () => {
+    const prompt = buildPrompt(
+      recoveryInput({ appliedToolCallIds: new Set(["tool-call-1"]) }),
+    );
+    expect(prompt).toContain("ALREADY applied");
+    expect(prompt).not.toContain("Carry them out now");
+  });
+
+  it("carries the session-standing context a first turn would get — the replacement agent inherits the whole story, not just the blueprint", () => {
+    const prompt = buildPrompt(
+      recoveryInput({ contextBridge: "User: earlier thread\nAssistant: earlier reply" }),
+    );
+    expect(prompt).toContain("<previous_conversation_context>");
+    expect(prompt).toContain("User: earlier thread");
+  });
+
+  it("selects the recovery shape for ANY non-resumed reason — decisions-only is safe only when native context is guaranteed", () => {
+    // created_first_execution + decisions cannot happen in practice
+    // (decisions are reconstructed from a persisted transcript, which
+    // implies a prior invocation) — but if it ever did, the bare decisions
+    // prompt would reproduce the #366 amnesia. Fail safe.
+    const prompt = buildPrompt(
+      recoveryInput({ resolution: resolution("local", "created_first_execution") }),
+    );
+    expect(prompt).toContain("<turn_recovery>");
+    expect(prompt).toContain("<agent_instructions>");
+  });
+
+  it("primary send skips images ONLY for a resumed HITL agent (which holds them natively); every fresh agent gets the re-delivery", () => {
+    expect(primarySendCarriesImages(decisions(), "resumed_successfully")).toBe(false);
+    // The #366 vision corollary: fresh agent mid-HITL after a
+    // resolution-time resume failure.
+    expect(primarySendCarriesImages(decisions(), "created_after_resume_failure")).toBe(true);
+    // Non-HITL turns always carry the message's images, resumed or not.
+    expect(primarySendCarriesImages(undefined, "resumed_successfully")).toBe(true);
+    expect(primarySendCarriesImages(undefined, "created_first_execution")).toBe(true);
+  });
+
+  it("the structured-output directive is a pure append shared by the primary and recovery sends — absent schema, absent suffix", () => {
+    expect(appendStructuredOutputDirective("base", undefined)).toBe("base");
+    const withSchema = appendStructuredOutputDirective("base", { type: "object" });
+    expect(withSchema.startsWith("base\n\n---\nCRITICAL OUTPUT REQUIREMENT:")).toBe(true);
+    expect(withSchema).toContain('"type": "object"');
+  });
+});
+
 describe("attachments on a resumed turn (T04 — the mid-session WhatsApp case)", () => {
   const RESUMED = { resolution: resolution("local", "resumed_successfully") };
 
@@ -345,6 +425,68 @@ describe("attachments on a resumed turn (T04 — the mid-session WhatsApp case)"
     expect(prompt).toContain("Attached inline and visible to you, in order: 1. a.jpg");
   });
 
+  it("lists a minted download URL beside its file with the presigned hand-off line (issue #532)", () => {
+    const prompt = buildPrompt(
+      input({
+        ...RESUMED,
+        attachments: [
+          { path: ".stigmer/inputs/lease.pdf", downloadUrl: "https://r2.example/lease?sig=abc" },
+          { path: ".stigmer/inputs/notes.md" },
+        ],
+        downloadUrlKind: "presigned",
+      }),
+    );
+    expect(prompt).toContain(
+      "- `.stigmer/inputs/lease.pdf` — download URL: https://r2.example/lease?sig=abc",
+    );
+    // The URL-less file keeps a clean entry.
+    expect(prompt).toContain("- `.stigmer/inputs/notes.md`\n");
+    expect(prompt).toContain("These URLs are time-limited");
+  });
+
+  it("words a local-serve URL honestly — reachable only from this machine", () => {
+    const prompt = buildPrompt(
+      input({
+        ...RESUMED,
+        attachments: [
+          { path: ".stigmer/inputs/lease.pdf", downloadUrl: "http://localhost:7235/attachments/01A/lease.pdf" },
+        ],
+        downloadUrlKind: "local-serve",
+      }),
+    );
+    expect(prompt).toContain("download URL: http://localhost:7235/attachments/01A/lease.pdf");
+    expect(prompt).toContain("reachable only from this machine");
+    expect(prompt).not.toContain("time-limited");
+  });
+
+  it("renders no hand-off line when no listed file carries a URL (kind alone is not enough)", () => {
+    const prompt = buildPrompt(
+      input({
+        ...RESUMED,
+        attachments: [{ path: ".stigmer/inputs/local-only.csv" }],
+        downloadUrlKind: "presigned",
+      }),
+    );
+    expect(prompt).toContain("<input_files>");
+    expect(prompt).not.toContain("download URL");
+    expect(prompt).not.toContain("time-limited");
+  });
+
+  it("renders the download URL inside the enhanced first-turn prompt too", () => {
+    const prompt = buildPrompt(
+      input({
+        resolution: resolution("local", "created_first_execution"),
+        attachments: [
+          { path: ".stigmer/inputs/lease.pdf", downloadUrl: "https://r2.example/lease?sig=abc" },
+        ],
+        downloadUrlKind: "presigned",
+      }),
+    );
+    expect(prompt).toContain("<input_files>");
+    expect(prompt).toContain("download URL: https://r2.example/lease?sig=abc");
+    expect(prompt).toContain("These URLs are time-limited");
+  });
+
   it("a HITL re-invocation carries no input-files section — its prompt has no user message at all", () => {
     const prompt = buildPrompt(
       input({

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

@@ -1,4 +1,9 @@
-import { describe, it, expect, vi, beforeAll } from "vitest";
+import { describe, it, expect, vi, beforeAll, beforeEach, afterEach } from "vitest";
+import {
+  getPricingTable,
+  _resetPricingCache,
+  DEFAULT_PRICING,
+} from "../model-pricing-data.js";
 
 /**
  * Verifies the cursor-runner display estimate resolves Cursor speed variants
@@ -110,3 +115,59 @@ describe("getCursorModelPricing — speed variant resolution", () => {
     expect(p.inputPricePerMillion).toBe(5.0);
   });
 });
+
+describe("getPricingTable failure caching (#468)", () => {
+  beforeEach(() => {
+    _resetPricingCache();
+  });
+
+  afterEach(() => {
+    _resetPricingCache();
+    vi.useRealTimers();
+  });
+
+  it("retries after the short failure TTL instead of pinning DEFAULT_PRICING for an hour", async () => {
+    // The model-registry.ts failure-cache policy, applied here: wrong default
+    // rates for cost tracking must not persist a full success TTL.
+    vi.useFakeTimers();
+    const registryResponse = () =>
+      new Response(
+        JSON.stringify({
+          models: [
+            {
+              id: "composer-2.5",
+              displayName: "Composer 2.5",
+              provider: "cursor",
+              harness: "cursor",
+              costTier: "economy",
+              pricing: {
+                inputPricePerMillion: 0.5,
+                outputPricePerMillion: 2.5,
+                cacheWritePricePerMillion: 0,
+                cacheReadPricePerMillion: 0.2,
+              },
+            },
+          ],
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    const fetchSpy = vi
+      .fn<typeof fetch>()
+      .mockRejectedValueOnce(new Error("network error"))
+      .mockResolvedValueOnce(registryResponse());
+    vi.stubGlobal("fetch", fetchSpy);
+
+    // First call fails and degrades to the default table.
+    expect((await getPricingTable())[0]).toBe(DEFAULT_PRICING);
+
+    // Within the failure TTL the fallback stays cached (no refetch).
+    vi.advanceTimersByTime(30_000);
+    expect((await getPricingTable())[0]).toBe(DEFAULT_PRICING);
+    expect(fetchSpy).toHaveBeenCalledTimes(1);
+
+    // Past the failure TTL the registry is refetched and real rates recover.
+    vi.advanceTimersByTime(31_000);
+    expect((await getPricingTable())[0]?.model).toBe("composer-2.5");
+    expect(fetchSpy).toHaveBeenCalledTimes(2);
+  });
+});