@stigmer/runner 3.0.1

package/src/__tests__/golden-e2e.test.ts

@@ -0,0 +1,250 @@
+/**
+ * Golden YAML E2E tests using Temporal TestWorkflowEnvironment.
+ *
+ * These tests run the full Temporal workflow lifecycle:
+ * - Workflow bundling into the Temporal deterministic sandbox
+ * - Activity scheduling via proxyActivities/proxyLocalActivities
+ * - Expression evaluation via local activities (jq-wasm)
+ * - Timer handling (sleep/wait)
+ *
+ * Prerequisites:
+ * - @temporalio/testing ephemeral server binary (installed via npm)
+ * - Temporal CLI (`temporal`) on PATH
+ *
+ * The workflow-engine uses `deepClone` from `clone.ts` which falls
+ * back to JSON round-trip when `structuredClone` is unavailable in
+ * the Temporal deterministic V8 sandbox. Tests are skipped if the
+ * environment can't start a Temporal test server.
+ *
+ * Run with: npx vitest run src/__tests__/golden-e2e.test.ts
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadWorkflowFromYaml } from "../workflow-engine/loader.js";
+import { evaluateExpressionBatch } from "../workflow-engine/expression.js";
+import type { ExecuteServerlessWorkflowInput } from "../workflows/execute-serverless-workflow.js";
+import type { WorkflowModel } from "../workflow-engine/types.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const GOLDEN_DIR = join(__dirname, "../../test/golden");
+const WORKFLOWS_PATH = join(__dirname, "../workflows/index.ts");
+const TASK_QUEUE = "golden-e2e-test";
+
+function loadGolden(filename: string): string {
+  return readFileSync(join(GOLDEN_DIR, filename), "utf-8");
+}
+
+function fakeHttpResponse(body: unknown = {}): unknown {
+  return { id: 1, title: "response", body: "ok", userId: 7, ...body as object };
+}
+
+type TestWorkflowEnvironment = import("@temporalio/testing").TestWorkflowEnvironment;
+type Worker = import("@temporalio/worker").Worker;
+
+let env: TestWorkflowEnvironment | null = null;
+let worker: Worker | null = null;
+let workerRunPromise: Promise<void> | null = null;
+let envReady = false;
+
+function createMockActivities() {
+  return {
+    EvaluateExpressions: async (
+      expressions: Record<string, string>,
+      input: unknown,
+      stateVars: Record<string, unknown>,
+    ): Promise<Record<string, unknown>> => {
+      return evaluateExpressionBatch(expressions, input, stateVars);
+    },
+    CallHttp: async (): Promise<unknown> => fakeHttpResponse(),
+    CallGrpc: async (): Promise<unknown> => ({ result: "grpc-response" }),
+    CallFunction: async (
+      call: string,
+      config: Record<string, unknown>,
+    ): Promise<unknown> => {
+      if (call === "emit_event") {
+        const event = config.event as Record<string, unknown>;
+        return { specversion: "1.0", type: event?.type ?? "unknown", data: event?.data, id: `evt-${Date.now()}` };
+      }
+      if (call === "notification") return { delivered: true, channel: "webhook" };
+      return { result: `function-${call}` };
+    },
+    CallAgent: async (): Promise<unknown> => ({
+      structured: { severity: "low", category: "style", customer_impact: false },
+    }),
+    RunScript: async (): Promise<unknown> => ({ computed: 4 }),
+    RunShell: async (): Promise<unknown> => "hello from shell",
+    UpdateWorkflowTaskApprovalStatus: async (): Promise<void> => {},
+    ClearWorkflowApprovalStatus: async (): Promise<void> => {},
+  };
+}
+
+async function runGoldenWorkflow(model: WorkflowModel, workflowInput: unknown = null): Promise<unknown> {
+  if (!env) throw new Error("TestWorkflowEnvironment not initialized");
+  const input: ExecuteServerlessWorkflowInput = {
+    model,
+    workflow_input: workflowInput,
+    env: {},
+    metadata: { execution_id: "e2e-test" },
+  };
+  return env.client.workflow.execute("stigmer/workflow/execute", {
+    taskQueue: TASK_QUEUE,
+    workflowId: `golden-e2e-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    args: [input],
+    workflowExecutionTimeout: "30s",
+  });
+}
+
+describe("Golden E2E — Temporal TestWorkflowEnvironment", () => {
+  beforeAll(async () => {
+    try {
+      const { TestWorkflowEnvironment: TWE } = await import("@temporalio/testing");
+      const { Worker: W } = await import("@temporalio/worker");
+
+      env = await TWE.createLocal();
+      worker = await W.create({
+        connection: env.nativeConnection,
+        taskQueue: TASK_QUEUE,
+        workflowsPath: WORKFLOWS_PATH,
+        activities: createMockActivities(),
+      });
+      workerRunPromise = worker.run();
+
+      // Smoke test: execute simplest workflow to verify sandbox compatibility
+      const smokeModel = loadWorkflowFromYaml(loadGolden("01-operation-basic.yaml"));
+      await runGoldenWorkflow(smokeModel);
+      envReady = true;
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`Temporal E2E smoke test failed (tests will be skipped): ${msg}`);
+      envReady = false;
+    }
+  }, 60_000);
+
+  afterAll(async () => {
+    if (worker) {
+      worker.shutdown();
+      await workerRunPromise?.catch(() => {});
+    }
+    if (env) await env.teardown();
+  }, 30_000);
+
+  // ─────────────────────────────────────────────────────────────────
+  // Each test skips gracefully if the Temporal test server
+  // cannot start or the smoke test fails.
+  // ─────────────────────────────────────────────────────────────────
+
+  it("#01 operation-basic — sequential set tasks", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("01-operation-basic.yaml"));
+    const result = await runGoldenWorkflow(model);
+    expect(result).toEqual({ workflow_completed: true });
+  });
+
+  it("#14 try-catch-raise — error handling pipeline", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("14-try-catch-raise.yaml"));
+    const result = await runGoldenWorkflow(model);
+    expect(result).toEqual({ phase: "completed" });
+  });
+
+  it("#15 fork-parallel — non-compete branches", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("15-fork-parallel.yaml"));
+    const result = await runGoldenWorkflow(model);
+    expect(result).toBeDefined();
+  });
+
+  it("#02 switch-conditional — HTTP + conditional branching", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("02-switch-conditional.yaml"));
+    const result = await runGoldenWorkflow(model);
+    expect(result).toBeDefined();
+  });
+
+  it("#03 foreach-loop — iteration with HTTP calls", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("03-foreach-loop.yaml"));
+    const result = await runGoldenWorkflow(model, { items: ["a", "b", "c"] });
+    expect(result).toBeDefined();
+  });
+
+  it("#04 parallel-concurrent — fork with HTTP branches", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("04-parallel-concurrent.yaml"));
+    const result = await runGoldenWorkflow(model);
+    expect(result).toBeDefined();
+  });
+
+  it("#06 sleep-delay — wait + HTTP calls", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("06-sleep-delay.yaml"));
+    const result = await runGoldenWorkflow(model);
+    expect(result).toBeDefined();
+  });
+
+  it("#07 inject-transform — expressions + HTTP", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("07-inject-transform.yaml"));
+    const result = await runGoldenWorkflow(model, { a: 10, b: 20 });
+    expect(result).toBeDefined();
+  });
+
+  it("#08 error-retry — try/catch with HTTP", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("08-error-retry.yaml"));
+    const result = await runGoldenWorkflow(model);
+    expect(result).toBeDefined();
+  });
+
+  it("#11 claimcheck-large-payload — sequential HTTP calls", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("11-claimcheck-large-payload.yaml"));
+    const result = await runGoldenWorkflow(model);
+    expect(result).toBeDefined();
+  });
+
+  it("#12 claimcheck-between-steps — HTTP chain", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("12-claimcheck-between-steps.yaml"));
+    const result = await runGoldenWorkflow(model);
+    expect(result).toBeDefined();
+  });
+
+  it("#16 wait-delay — timer durations", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("16-wait-delay.yaml"));
+    const result = await runGoldenWorkflow(model);
+    expect(result).toEqual({ completed: true });
+  });
+
+  it("#18 run-task — script + shell + workflow", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("18-run-task.yaml"));
+    const result = await runGoldenWorkflow(model);
+    expect(result).toEqual({ all_runs_done: true });
+  });
+
+  it("#19 emit-event — CloudEvents envelope", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("19-emit-event.yaml"));
+    const result = await runGoldenWorkflow(model);
+    expect(result).toEqual({ events_emitted: true });
+  });
+
+  it("#21 retry-backoff — catch-level retry", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("21-retry-backoff.yaml"));
+    const result = await runGoldenWorkflow(model);
+    expect(result).toEqual({ phase: "completed" });
+  });
+
+  it("#23 notification — webhook notification", async () => {
+    if (!envReady) return;
+    const model = loadWorkflowFromYaml(loadGolden("23-notification.yaml"));
+    const result = await runGoldenWorkflow(model);
+    expect(result).toEqual({ notifications_sent: true });
+  });
+});

package/src/__tests__/ipc-protocol-fixtures.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+import committed from "../../fixtures/ipc-protocol.generated.json" with { type: "json" };
+import { IPC_PROTOCOL_VERSION, buildReadyMessage } from "../ipc-protocol.js";
+import { buildFixtures } from "../ipc-protocol-fixtures.js";
+
+/**
+ * The TS side of the golden-fixture conformance suite. Its job is narrow and honest: keep
+ * the committed artifact fresh and bind the runtime `ready` builder to it. The cross-
+ * language contract assurance comes from the Rust and Go mirrors asserting against the same
+ * committed file — see crates/stigmer-runner-host/src/protocol.rs and
+ * test/integration/harness/ipc_fixtures_test.go.
+ */
+describe("ipc-protocol golden fixtures", () => {
+  it("matches the committed artifact (regenerate with `make gen-ipc-fixtures` if this fails)", () => {
+    expect(committed).toEqual(buildFixtures());
+  });
+
+  it("sources the `ready` fixture from the real builder", () => {
+    expect(buildFixtures().responses.ready).toEqual(buildReadyMessage());
+  });
+
+  it("advertises the crate-shared integer protocol version", () => {
+    expect(buildFixtures().ipcProtocolVersion).toBe(IPC_PROTOCOL_VERSION);
+    expect(Number.isInteger(IPC_PROTOCOL_VERSION)).toBe(true);
+  });
+
+  it("covers every command and response in the contract", () => {
+    const { commands, responses } = buildFixtures();
+    // Locks the catalog so a new message cannot be added to ipc-protocol.ts without a
+    // fixture — the mirrors would otherwise have nothing to conform against.
+    expect(Object.keys(commands).sort()).toEqual([
+      "addSession",
+      "addWorkflowExecution",
+      "removeSession",
+      "removeWorkflowExecution",
+      "shutdown",
+      "updateTokenCleared",
+      "updateTokenSet",
+    ]);
+    expect(Object.keys(responses).sort()).toEqual([
+      "error",
+      "ready",
+      "readyLegacy",
+      "sessionAdded",
+      "sessionRemoved",
+      "shutdownComplete",
+      "tokenUpdated",
+      "workflowExecutionAdded",
+      "workflowExecutionRemoved",
+    ]);
+  });
+
+  it("encodes the token set/clear distinction the wire depends on", () => {
+    const { commands } = buildFixtures();
+    expect(commands.updateTokenSet.token).toBe("tok_example");
+    // `null` is the canonical "clear the token" shape; absence is a host quirk, not the
+    // contract. The Rust and Go mirrors are checked against this exact value.
+    expect(commands.updateTokenCleared.token).toBeNull();
+  });
+
+  it("keeps a legacy `ready` without a protocolVersion for backward-compat hosts", () => {
+    const { readyLegacy } = buildFixtures().responses;
+    expect(readyLegacy).toEqual({ type: "ready" });
+    expect("protocolVersion" in readyLegacy).toBe(false);
+  });
+});

package/src/__tests__/ipc-protocol.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest";
+import { IPC_PROTOCOL_VERSION, buildReadyMessage } from "../ipc-protocol.js";
+
+/**
+ * Locks the wire shape of the `ready` handshake. Hosts (runner.rs, unified_runner.go, and
+ * external embedders) read `protocolVersion` to decide compatibility, so a silent change to
+ * its value or type is a breaking protocol change — these assertions make that change loud.
+ */
+describe("ipc-protocol ready handshake", () => {
+  it("advertises an integer protocol version", () => {
+    expect(IPC_PROTOCOL_VERSION).toBe(1);
+    expect(Number.isInteger(IPC_PROTOCOL_VERSION)).toBe(true);
+  });
+
+  it("builds the exact ready message the host expects", () => {
+    expect(buildReadyMessage()).toEqual({
+      type: "ready",
+      protocolVersion: IPC_PROTOCOL_VERSION,
+    });
+  });
+
+  it("emits protocolVersion as a number, not a string", () => {
+    expect(typeof buildReadyMessage().protocolVersion).toBe("number");
+  });
+
+  it("carries exactly the type and protocolVersion fields", () => {
+    expect(Object.keys(buildReadyMessage()).sort()).toEqual([
+      "protocolVersion",
+      "type",
+    ]);
+  });
+});

package/src/__tests__/otel-metrics.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { getInstruments, resetInstruments } from "../otel-metrics.js";
+
+describe("OTel Metrics Registry", () => {
+  beforeEach(() => {
+    resetInstruments();
+  });
+
+  it("creates all required instruments", async () => {
+    const instruments = await getInstruments();
+    expect(instruments.executionCount).toBeDefined();
+    expect(instruments.executionActive).toBeDefined();
+    expect(instruments.activityDuration).toBeDefined();
+    expect(instruments.workflowTaskDuration).toBeDefined();
+    expect(instruments.workflowTaskCount).toBeDefined();
+  });
+
+  it("returns the same singleton on repeated calls", async () => {
+    const first = await getInstruments();
+    const second = await getInstruments();
+    expect(first).toBe(second);
+  });
+
+  it("instruments are callable without throwing (no-op meter)", async () => {
+    const instruments = await getInstruments();
+    expect(() => instruments.executionCount.add(1)).not.toThrow();
+    expect(() => instruments.executionActive.add(1)).not.toThrow();
+    expect(() => instruments.executionActive.add(-1)).not.toThrow();
+    expect(() => instruments.activityDuration.record(150)).not.toThrow();
+    expect(() => instruments.workflowTaskDuration.record(42)).not.toThrow();
+    expect(() => instruments.workflowTaskCount.add(1, { "task.kind": "set" })).not.toThrow();
+  });
+
+  it("reset allows re-creation", async () => {
+    const first = await getInstruments();
+    resetInstruments();
+    const second = await getInstruments();
+    expect(first).not.toBe(second);
+  });
+});

package/src/__tests__/runner-manager.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from "vitest";
+import { mapManagerOptionsToConfig } from "../runner-manager.js";
+import type { RunnerManagerOptions } from "../runner-manager.js";
+
+/**
+ * The manager maps its options into a runner {@link Config}. The critical
+ * invariant these tests lock is that execution location (`mode`) is decoupled
+ * from credential transport (`proxyEndpoint`): the desktop runner executes
+ * LOCALLY while still routing Cursor traffic through the proxy. Re-coupling the
+ * two previously broke local-path workspace sessions.
+ */
+describe("mapManagerOptionsToConfig", () => {
+  const base: RunnerManagerOptions = {
+    temporalAddress: "localhost:7233",
+    stigmerEndpoint: "http://localhost:7234",
+  };
+
+  it("defaults mode to local when executionMode is unset", () => {
+    const config = mapManagerOptionsToConfig(base);
+    expect(config.mode).toBe("local");
+  });
+
+  it("stays local with a proxy endpoint set (the desktop case)", () => {
+    const config = mapManagerOptionsToConfig({
+      ...base,
+      proxyEndpoint: "https://localhost:9090",
+      stigmerToken: "tok",
+    });
+    expect(config.mode).toBe("local");
+    expect(config.proxyEndpoint).toBe("https://localhost:9090");
+    // Proxy transport still engages independently of execution location.
+    expect(config.cursorApiKey).toBe("proxy-managed");
+    expect(config.checkpointerType).toBe("http");
+  });
+
+  it("uses cloud only when executionMode is explicitly cloud", () => {
+    const config = mapManagerOptionsToConfig({
+      ...base,
+      executionMode: "cloud",
+      proxyEndpoint: "https://proxy.example.com",
+      stigmerToken: "tok",
+    });
+    expect(config.mode).toBe("cloud");
+  });
+
+  it("honors explicit local executionMode even with a proxy", () => {
+    const config = mapManagerOptionsToConfig({
+      ...base,
+      executionMode: "local",
+      proxyEndpoint: "https://proxy.example.com",
+      stigmerToken: "tok",
+    });
+    expect(config.mode).toBe("local");
+  });
+});

package/src/__tests__/runner-token-coordinator.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { createRunnerTokenCoordinator } from "../runner-token-coordinator.js";
+import type { RefreshedRunnerToken } from "../bootstrap.js";
+
+/**
+ * Unit tests for the runner's two-writer token model.
+ *
+ * The load-bearing guarantee here is the anti-staleness regression: once the
+ * runner mints its own proxy token, a control-plane token push must NOT clobber
+ * it (the bug fixed in stigmer-cloud _changelog 2026-05-26 / 2026-06-01 was the
+ * inverse — the proxy token froze and never refreshed). These tests pin both
+ * directions of that invariant.
+ */
+
+const silentLog = { log: vi.fn(), warn: vi.fn() };
+
+describe("createRunnerTokenCoordinator", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    silentLog.log.mockClear();
+    silentLog.warn.mockClear();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe("pre-mint (lockstep preserved)", () => {
+    it("applies a control-plane token to the proxy sink when nothing is minted", () => {
+      const applyProxyToken = vi.fn();
+      const coordinator = createRunnerTokenCoordinator({
+        applyProxyToken,
+        reMint: vi.fn(),
+        log: silentLog,
+      });
+
+      coordinator.onControlPlaneTokenChanged("cp_token");
+
+      expect(coordinator.isProxyTokenMinted()).toBe(false);
+      expect(applyProxyToken).toHaveBeenCalledWith("cp_token");
+    });
+
+    it("ignores a null control-plane token (logout) without touching the proxy sink", () => {
+      const applyProxyToken = vi.fn();
+      const coordinator = createRunnerTokenCoordinator({
+        applyProxyToken,
+        reMint: vi.fn(),
+        log: silentLog,
+      });
+
+      coordinator.onControlPlaneTokenChanged(null);
+
+      expect(applyProxyToken).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("after minting", () => {
+    it("applies the minted token and marks the proxy token as minted", () => {
+      const applyProxyToken = vi.fn();
+      const coordinator = createRunnerTokenCoordinator({
+        applyProxyToken,
+        reMint: vi.fn(),
+        log: silentLog,
+      });
+
+      coordinator.adoptMintedToken("rt_minted", 14400);
+
+      expect(coordinator.isProxyTokenMinted()).toBe(true);
+      expect(applyProxyToken).toHaveBeenCalledWith("rt_minted");
+    });
+
+    it("ANTI-STALENESS: a control-plane push must NOT clobber the minted proxy token", () => {
+      const applyProxyToken = vi.fn();
+      const coordinator = createRunnerTokenCoordinator({
+        applyProxyToken,
+        reMint: vi.fn(),
+        log: silentLog,
+      });
+
+      coordinator.adoptMintedToken("rt_minted", 14400);
+      applyProxyToken.mockClear();
+
+      // The desktop rotates its Auth0 token and pushes it as the control-plane
+      // credential. The proxy interceptors must keep the minted token.
+      coordinator.onControlPlaneTokenChanged("auth0_rotated");
+
+      expect(applyProxyToken).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("refresh timer", () => {
+    it("re-mints from the control-plane token before expiry and reschedules", async () => {
+      const applyProxyToken = vi.fn();
+      const reMint = vi
+        .fn<[], Promise<RefreshedRunnerToken | undefined>>()
+        .mockResolvedValueOnce({ token: "rt_v2", expiresInSeconds: 100 })
+        .mockResolvedValueOnce({ token: "rt_v3", expiresInSeconds: 100 });
+
+      const coordinator = createRunnerTokenCoordinator({
+        applyProxyToken,
+        reMint,
+        log: silentLog,
+      });
+
+      // ttl=100s → refresh at 0.8 * 100s = 80s.
+      coordinator.adoptMintedToken("rt_v1", 100);
+      applyProxyToken.mockClear();
+
+      await vi.advanceTimersByTimeAsync(80_000);
+      expect(reMint).toHaveBeenCalledTimes(1);
+      expect(applyProxyToken).toHaveBeenCalledWith("rt_v2");
+
+      // It rescheduled; the next refresh re-mints again.
+      await vi.advanceTimersByTimeAsync(80_000);
+      expect(reMint).toHaveBeenCalledTimes(2);
+      expect(applyProxyToken).toHaveBeenCalledWith("rt_v3");
+
+      coordinator.stop();
+    });
+
+    it("retries (without clobbering) when a re-mint fails, then recovers", async () => {
+      const applyProxyToken = vi.fn();
+      const reMint = vi
+        .fn<[], Promise<RefreshedRunnerToken | undefined>>()
+        .mockResolvedValueOnce(undefined) // first refresh fails to mint
+        .mockResolvedValueOnce({ token: "rt_recovered", expiresInSeconds: 100 });
+
+      const coordinator = createRunnerTokenCoordinator({
+        applyProxyToken,
+        reMint,
+        log: silentLog,
+      });
+
+      coordinator.adoptMintedToken("rt_v1", 100);
+      applyProxyToken.mockClear();
+
+      // First scheduled refresh (at 80s) returns undefined → no new proxy token,
+      // schedules a retry at 0.8 * 60s = 48s.
+      await vi.advanceTimersByTimeAsync(80_000);
+      expect(reMint).toHaveBeenCalledTimes(1);
+      expect(applyProxyToken).not.toHaveBeenCalled();
+
+      // Retry succeeds and recovers the proxy token.
+      await vi.advanceTimersByTimeAsync(48_000);
+      expect(reMint).toHaveBeenCalledTimes(2);
+      expect(applyProxyToken).toHaveBeenCalledWith("rt_recovered");
+
+      coordinator.stop();
+    });
+
+    it("stop() cancels the refresh timer", async () => {
+      const reMint = vi.fn<[], Promise<RefreshedRunnerToken | undefined>>();
+      const coordinator = createRunnerTokenCoordinator({
+        applyProxyToken: vi.fn(),
+        reMint,
+        log: silentLog,
+      });
+
+      coordinator.adoptMintedToken("rt_v1", 100);
+      coordinator.stop();
+
+      await vi.advanceTimersByTimeAsync(200_000);
+      expect(reMint).not.toHaveBeenCalled();
+    });
+  });
+});