@stigmer/runner 3.14.0 → 3.15.0

package/src/harness/__tests__/persist-chokepoint.test.ts

@@ -0,0 +1,146 @@
+/**
+ * The persist chokepoint's two contracts: what one write does (the secret
+ * backstop, the usage summary, the heartbeat, the STOP), and how requests
+ * coalesce (one write in flight, one follow-up at most, every request's
+ * promise resolving only once its state is on the wire).
+ */
+
+import { describe, expect, it, vi } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import { AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { UpdateStatusResponseSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
+import { AgentMessageSchema, ToolCallSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import { ExecutionControlSignal, MessageType, ServiceTier, ThinkingMode, ToolCallStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+import type { StigmerClient } from "../../client/stigmer-client.js";
+import { PersistChokepoint } from "../persist-chokepoint.js";
+import { UsageAccumulator } from "../usage-accumulator.js";
+
+interface Gate {
+  readonly open: () => void;
+  readonly opened: Promise<void>;
+}
+
+function gate(): Gate {
+  let open!: () => void;
+  const opened = new Promise<void>((resolve) => (open = resolve));
+  return { open, opened };
+}
+
+/** A client whose `updateStatus` answers through a gate the test opens, so writes can be held in flight. */
+function heldClient(answers: ExecutionControlSignal[] = []) {
+  const gates: Gate[] = [];
+  const writes: number[] = [];
+  const client = {
+    updateStatus: vi.fn(async (_id: string, status: { messages: unknown[] }) => {
+      const g = gate();
+      gates.push(g);
+      writes.push(status.messages.length);
+      await g.opened;
+      return create(UpdateStatusResponseSchema, { signal: answers.shift() ?? ExecutionControlSignal.UNSPECIFIED });
+    }),
+  } as unknown as StigmerClient;
+  return { client, gates, writes };
+}
+
+function chokepointOver(client: StigmerClient, options: { usage?: UsageAccumulator; onPlatformStop?: () => void } = {}) {
+  const status = create(AgentExecutionStatusSchema, {});
+  const heartbeat = vi.fn();
+  const onPlatformStop = options.onPlatformStop ?? vi.fn();
+  const chokepoint = new PersistChokepoint({
+    client,
+    executionId: "aex_test",
+    status,
+    offload: undefined,
+    usage: () => options.usage,
+    heartbeat,
+    onPlatformStop,
+  });
+  return { chokepoint, status, heartbeat, onPlatformStop };
+}
+
+describe("PersistChokepoint: one write", () => {
+  it("withholds secret content, refreshes streaming_usage, writes, heartbeats, and relays STOP", async () => {
+    const { client, gates } = heldClient([ExecutionControlSignal.STOP]);
+    const usage = new UsageAccumulator(ServiceTier.STANDARD, ThinkingMode.DISABLED);
+    usage.addTurn({ inputTokens: 10, estimatedCostUsd: 0.01, model: "m" });
+    const onPlatformStop = vi.fn();
+    const { chokepoint, status, heartbeat } = chokepointOver(client, { usage, onPlatformStop });
+    status.messages.push(
+      create(AgentMessageSchema, {
+        type: MessageType.MESSAGE_AI,
+        toolCalls: [
+          create(ToolCallSchema, {
+            id: "w1",
+            name: "write",
+            status: ToolCallStatus.TOOL_CALL_COMPLETED,
+            args: { path: ".env", content: "SECRET=1" },
+          }),
+        ],
+      }),
+    );
+
+    const written = chokepoint.write();
+    gates[0]!.open();
+    await written;
+
+    expect(status.messages[0]!.toolCalls[0]!.args, "the secret backstop ran before the write").not.toMatchObject({ content: "SECRET=1" });
+    expect(status.streamingUsage?.estimatedCostUsd).toBe(0.01);
+    expect(heartbeat).toHaveBeenCalledTimes(1);
+    expect(onPlatformStop).toHaveBeenCalledTimes(1);
+  });
+
+  it("writes no streaming_usage when no turn was reported", async () => {
+    const { client, gates } = heldClient();
+    const { chokepoint, status } = chokepointOver(client, { usage: new UsageAccumulator() });
+    const written = chokepoint.write();
+    gates[0]!.open();
+    await written;
+    expect(status.streamingUsage).toBeUndefined();
+  });
+});
+
+describe("PersistChokepoint: coalescing", () => {
+  it("a request while a write is in flight schedules ONE follow-up and resolves only when it lands", async () => {
+    const { client, gates, writes } = heldClient();
+    const { chokepoint, status } = chokepointOver(client);
+
+    status.messages.push(create(AgentMessageSchema, { content: "one" }));
+    const first = chokepoint.request();
+    status.messages.push(create(AgentMessageSchema, { content: "two" }));
+    const second = chokepoint.request();
+    status.messages.push(create(AgentMessageSchema, { content: "three" }));
+    const third = chokepoint.request();
+
+    let secondSettled = false;
+    let thirdSettled = false;
+    void second.then(() => (secondSettled = true));
+    void third.then(() => (thirdSettled = true));
+
+    expect(gates, "one write in flight, the follow-up waits").toHaveLength(1);
+    gates[0]!.open();
+    await first;
+    await Promise.resolve();
+    expect(secondSettled, "the follow-up has not landed yet").toBe(false);
+
+    await vi.waitFor(() => expect(gates).toHaveLength(2));
+    expect(writes, "the follow-up carries the state as of the LAST request").toEqual([1, 3]);
+    gates[1]!.open();
+    await Promise.all([second, third]);
+    expect(secondSettled && thirdSettled).toBe(true);
+    expect(client.updateStatus).toHaveBeenCalledTimes(2);
+  });
+
+  it("sequential awaited requests write once each, in order", async () => {
+    const { client, gates } = heldClient();
+    const { chokepoint } = chokepointOver(client);
+    const first = chokepoint.request();
+    gates[0]!.open();
+    await first;
+    const second = chokepoint.request();
+    await vi.waitFor(() => expect(gates).toHaveLength(2));
+    gates[1]!.open();
+    await second;
+    expect(client.updateStatus).toHaveBeenCalledTimes(2);
+  });
+});

package/src/harness/__tests__/registry.test.ts

@@ -0,0 +1,168 @@
+/**
+ * Pins the harness registry's two load-bearing properties — ORDER and ERROR
+ * POSTURE — and the byte-pinned activity names.
+ *
+ * Order: boot in declaration order, one at a time (the Cursor interceptors
+ * must precede anything that dials the control plane); shutdown in reverse.
+ * Posture: boot validates the table before touching any adapter and fails
+ * fast at the first rejection; shutdown and release continue past a failing
+ * adapter and surface every failure in one AggregateError. Names: the map
+ * must equal the server's constants byte for byte; the runner cannot import
+ * the server, so the literals are asserted here and the server's file is
+ * cited beside them.
+ */
+
+import { describe, it, expect } from "vitest";
+
+import { testConfig } from "../../__test-utils__/config-fixture.js";
+import { DEEP_AGENT_VISION_PROFILE } from "../../shared/attachment-vision.js";
+import { HARNESS_ACTIVITY_NAMES, bootHarnesses, releaseHarnessSession, shutdownHarnesses } from "../registry.js";
+import type { HarnessAdapter } from "../types.js";
+
+interface StubBehaviour {
+  readonly bootRejects?: Error;
+  readonly shutdownRejects?: Error;
+  readonly releaseRejects?: Error;
+}
+
+/** An adapter that only records lifecycle calls into a shared, ordered log. */
+function stubAdapter(name: string, log: string[], behaviour: StubBehaviour = {}): HarnessAdapter {
+  return {
+    name,
+    capabilities: {
+      pausePrimitive: "interrupt",
+      stateIdSource: "deterministic",
+      systemPrompt: true,
+      subAgents: false,
+      toolRestriction: true,
+      visionProfile: DEEP_AGENT_VISION_PROFILE,
+      fileReview: { harnessId: "stub", excludePaths: [] },
+    },
+    async boot() {
+      log.push(`boot:${name}`);
+      if (behaviour.bootRejects) throw behaviour.bootRejects;
+    },
+    async shutdown() {
+      log.push(`shutdown:${name}`);
+      if (behaviour.shutdownRejects) throw behaviour.shutdownRejects;
+    },
+    async releaseSession(sessionId) {
+      log.push(`release:${name}:${sessionId}`);
+      if (behaviour.releaseRejects) throw behaviour.releaseRejects;
+    },
+    async runTurn() {
+      throw new Error(`${name}: runTurn is not under test here`);
+    },
+  };
+}
+
+describe("HARNESS_ACTIVITY_NAMES", () => {
+  it("equals the server's byte-pinned activity names (stigmer-server temporal/agentexecution/names.ts)", () => {
+    expect(HARNESS_ACTIVITY_NAMES.cursor).toBe("ExecuteCursor");
+    expect(HARNESS_ACTIVITY_NAMES["deep-agent"]).toBe("ExecuteDeepAgent");
+    expect(Object.keys(HARNESS_ACTIVITY_NAMES).sort()).toEqual(["cursor", "deep-agent"]);
+  });
+});
+
+describe("bootHarnesses", () => {
+  it("boots adapters in declaration order, one at a time", async () => {
+    const log: string[] = [];
+    await bootHarnesses([stubAdapter("first", log), stubAdapter("second", log), stubAdapter("third", log)], testConfig());
+    expect(log).toEqual(["boot:first", "boot:second", "boot:third"]);
+  });
+
+  it("hands every adapter the same config", async () => {
+    const seen: unknown[] = [];
+    const config = testConfig({ taskQueue: "registry-test-queue" });
+    const adapters = ["a", "b"].map((name) => ({
+      ...stubAdapter(name, []),
+      async boot(c: unknown) {
+        seen.push(c);
+      },
+    }));
+    await bootHarnesses(adapters, config);
+    expect(seen, "each adapter must receive the one worker config").toEqual([config, config]);
+  });
+
+  it("refuses duplicate adapter names before booting anything", async () => {
+    const log: string[] = [];
+    const adapters = [stubAdapter("cursor", log), stubAdapter("other", log), stubAdapter("cursor", log)];
+    await expect(bootHarnesses(adapters, testConfig())).rejects.toThrow(/duplicate adapter name 'cursor'/);
+    expect(log, "a table with a duplicate must not boot even its first adapter").toEqual([]);
+  });
+
+  it("fails fast: the first rejection propagates and later adapters never boot", async () => {
+    const log: string[] = [];
+    const adapters = [
+      stubAdapter("first", log),
+      stubAdapter("broken", log, { bootRejects: new Error("interceptor install failed") }),
+      stubAdapter("third", log),
+    ];
+    await expect(bootHarnesses(adapters, testConfig())).rejects.toThrow("interceptor install failed");
+    expect(log).toEqual(["boot:first", "boot:broken"]);
+  });
+
+  it("boots an empty table as a no-op", async () => {
+    await expect(bootHarnesses([], testConfig())).resolves.toBeUndefined();
+  });
+});
+
+describe("shutdownHarnesses", () => {
+  it("shuts adapters down in reverse declaration order", async () => {
+    const log: string[] = [];
+    await shutdownHarnesses([stubAdapter("first", log), stubAdapter("second", log), stubAdapter("third", log)]);
+    expect(log).toEqual(["shutdown:third", "shutdown:second", "shutdown:first"]);
+  });
+
+  it("continues past a failing adapter and reports every failure in one AggregateError", async () => {
+    const log: string[] = [];
+    const adapters = [
+      stubAdapter("first", log, { shutdownRejects: new Error("first leaked") }),
+      stubAdapter("second", log),
+      stubAdapter("third", log, { shutdownRejects: new Error("third leaked") }),
+    ];
+    const failure = await shutdownHarnesses(adapters).catch((e: unknown) => e);
+    expect(failure).toBeInstanceOf(AggregateError);
+    const aggregate = failure as AggregateError;
+    expect(aggregate.message).toContain("third: shutdown rejected: third leaked");
+    expect(aggregate.message).toContain("first: shutdown rejected: first leaked");
+    expect(aggregate.errors.map((e: Error) => e.message)).toEqual([
+      "third: shutdown rejected: third leaked",
+      "first: shutdown rejected: first leaked",
+    ]);
+    expect(log, "every adapter must be shut down even when an earlier one failed").toEqual([
+      "shutdown:third",
+      "shutdown:second",
+      "shutdown:first",
+    ]);
+  });
+
+  it("preserves the original error as the cause of each reported failure", async () => {
+    const original = new Error("socket already closed");
+    const failure = await shutdownHarnesses([stubAdapter("only", [], { shutdownRejects: original })]).catch((e: unknown) => e);
+    expect((failure as AggregateError).errors[0]?.cause).toBe(original);
+  });
+});
+
+describe("releaseHarnessSession", () => {
+  it("tells every adapter, in declaration order, with the session id", async () => {
+    const log: string[] = [];
+    await releaseHarnessSession([stubAdapter("first", log), stubAdapter("second", log)], "ses-42");
+    expect(log).toEqual(["release:first:ses-42", "release:second:ses-42"]);
+  });
+
+  it("continues past a failing adapter and reports the failure with the session id", async () => {
+    const log: string[] = [];
+    const adapters = [
+      stubAdapter("first", log, { releaseRejects: new Error("executor busy") }),
+      stubAdapter("second", log),
+    ];
+    const failure = await releaseHarnessSession(adapters, "ses-7").catch((e: unknown) => e);
+    expect(failure).toBeInstanceOf(AggregateError);
+    expect((failure as AggregateError).message).toContain("releaseSession('ses-7') failed");
+    expect((failure as AggregateError).errors.map((e: Error) => e.message)).toEqual([
+      "first: releaseSession('ses-7') rejected: executor busy",
+    ]);
+    expect(log).toEqual(["release:first:ses-7", "release:second:ses-7"]);
+  });
+});

package/src/harness/__tests__/run-turn.test.ts

@@ -0,0 +1,165 @@
+/**
+ * The turn runtime, proven without any engine: the scripted fake adapter
+ * (`__test-utils__/harness-contract/scripted-adapter.ts`) through the kit's
+ * runtime-side half (`__test-utils__/harness-contract/runtime-contract.ts`)
+ * under `MockActivityEnvironment`, one arm per row of the terminal table.
+ *
+ * The runtime-side contract itself — the throw-vs-return rule end to end, the
+ * single persist chokepoint, the whole-activity heartbeat, the stop
+ * controller's four producers, the reinvocation seam, the byte-pinned copy —
+ * is the kit's and is registered here through `describeHarnessRuntimeContract`
+ * exactly as `activities/execute-cursor/__tests__/hermetic/harness-contract.test.ts`
+ * registers it against the real Cursor adapter. An arm that differs between
+ * the fake and the real engine is an adapter defect, not a runtime one.
+ *
+ * What is asserted HERE and not in the kit are the FAKE's facts: the engine
+ * cadence a real engine has no reason to share. The fake's `say` awaits its
+ * persist and its `propose` persists nothing before returning
+ * `awaiting_approval`, so under the runtime its first full write IS the
+ * WAITING write (`persistedPhases === [WAITING_FOR_APPROVAL]`) where a
+ * streaming engine's IN_PROGRESS writes precede it; the fake has no setup
+ * labels of its own, so the runtime's six are the whole list; the fake states
+ * its own price, so the cost copy reads exactly `~$0.6000`; and the fake's
+ * failure messages reach the status verbatim, where a real engine's
+ * classifier rephrases them.
+ *
+ * The hermetic environment is created at module level because the subject's
+ * `config` is read at collection time; the forks pool keeps it private to
+ * this file.
+ */
+
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { ApprovalAction, ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+vi.mock("../../client/stigmer-client.js", async () =>
+  (await import("../../__test-utils__/hermetic-activity.js")).hermeticStigmerClientModule(),
+);
+
+import { ScriptedClock, createHermeticEnvironment } from "../../__test-utils__/hermetic-activity.js";
+import { stubRegistryFetch } from "../../__test-utils__/model-registry-fixture.js";
+import { scriptedSubject } from "../../__test-utils__/harness-contract/scripted-adapter.js";
+import {
+  COST_CAP_FAKE_PRICE_USD,
+  FAILURE_MESSAGES,
+  NEVER_SEEN,
+  RUNTIME_SETUP_LABELS,
+  RuntimeExecutionDriver,
+  aiMessages,
+  assertApprovalRoundTrip,
+  assertCompletedTurn,
+  assertCostCapTerminates,
+  assertFailedSurfaceWritesItsCopy,
+  assertRejectedBindFails,
+  describeHarnessRuntimeContract,
+  slimOf,
+  systemMessages,
+  type RuntimeContractHarness,
+} from "../../__test-utils__/harness-contract/runtime-contract.js";
+import { scenario } from "../../__test-utils__/harness-contract/types.js";
+import { TERMINAL_COPY } from "../terminal-table.js";
+
+const TASK_QUEUE = "runtime-test-queue";
+
+const env = createHermeticEnvironment();
+const clock = new ScriptedClock();
+const subject = scriptedSubject({
+  pausePrimitive: "interrupt",
+  stateIdSource: "engine-minted",
+  config: { workspaceRootDir: env.workspaceRootDir, taskQueue: TASK_QUEUE },
+});
+const harness: RuntimeContractHarness = { subject, env, clock };
+
+describe("run-turn: the fake adapter through the real runtime", () => {
+  let registry: ReturnType<typeof stubRegistryFetch>;
+
+  beforeAll(() => {
+    registry = stubRegistryFetch();
+    clock.install();
+  });
+
+  afterAll(() => {
+    clock.uninstall();
+    registry.restore();
+    env.dispose();
+  });
+
+  describeHarnessRuntimeContract(harness);
+
+  describe("the fake's own facts", () => {
+    beforeAll(async () => {
+      await subject.adapter.boot(subject.config);
+    });
+
+    it("a completed turn: the runtime's six labels are the whole list, the phases, the stated price and its basis", async () => {
+      clock.reset();
+      const { driver, final } = await assertCompletedTurn(harness, "fake-completed");
+      expect(driver.record.persistedPhases).toEqual([ExecutionPhase.EXECUTION_IN_PROGRESS, ExecutionPhase.EXECUTION_COMPLETED]);
+      expect(driver.record.setupProgress).toEqual([...RUNTIME_SETUP_LABELS]);
+      expect(final.streamingUsage?.estimatedCostUsd, "the summary is the adapter's stated price, summed").toBeCloseTo(0.00136, 9);
+      expect(final.streamingUsage?.model, "the basis the adapter named").toBe("fixture-model");
+      expect(registry.urls.every((u) => u.includes("/model-registry"))).toBe(true);
+    });
+
+    it("the approval round trip: the WAITING write is the fake's first full persist (M3a finding 3)", async () => {
+      clock.reset();
+      const { driver } = await assertApprovalRoundTrip(harness, "fake-approval");
+      expect(driver.record.persistedPhases).toEqual([
+        ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL,
+        ExecutionPhase.EXECUTION_IN_PROGRESS,
+        ExecutionPhase.EXECUTION_COMPLETED,
+      ]);
+      expect(driver.record.sessionUpdates, "an engine-minted adapter binds once across the round trip").toHaveLength(1);
+    });
+
+    it("the cost cap: the fake's stated price reads exactly in the copy", async () => {
+      clock.reset();
+      const { final } = await assertCostCapTerminates(harness, "fake-cost-cap");
+      expect(final.error).toBe(`Agent reached the cost limit for this message (~$${COST_CAP_FAKE_PRICE_USD.toFixed(4)} of the $0.50 budget). Send another message to continue.`);
+      expect(final.streamingUsage?.estimatedCostUsd).toBe(COST_CAP_FAKE_PRICE_USD);
+    });
+
+    it.each([
+      ["engine", []],
+      ["actionable", [`Execution failed: ${FAILURE_MESSAGES.actionable}`]],
+      ["internal", [TERMINAL_COPY.internalFailure.row, `Error details: ${FAILURE_MESSAGES.internal}`]],
+    ] as const)("a %s failure: the fake's message reaches the status verbatim, with that surface's rows", async (surface, rows) => {
+      clock.reset();
+      const { driver, final } = await assertFailedSurfaceWritesItsCopy(harness, surface, FAILURE_MESSAGES[surface], `fake-failed-${surface}`);
+      expect(driver.record.persistedPhases).toEqual([ExecutionPhase.EXECUTION_IN_PROGRESS, ExecutionPhase.EXECUTION_FAILED]);
+      expect(final.error).toBe(FAILURE_MESSAGES[surface]);
+      expect(systemMessages(final)).toEqual(rows);
+    });
+
+    it("a rejected bind: the fake names the failure and nothing of the scenario was folded in", async () => {
+      clock.reset();
+      const { final } = await assertRejectedBindFails(harness, "fake-bind-rejects");
+      expect(final.error).toContain("could not bind engine state");
+      expect(aiMessages(final)).toEqual([]);
+    });
+
+    it("REJECT of an irreversible action settles the reinvocation FAILED before any engine runs (today's runtime; see F1)", async () => {
+      // The runtime fails a reinvocation that carries any REJECT
+      // (`decideReinvocation`, moved from Cursor's orchestrator). The proto
+      // contract as of #197 — the enum doc, the conformance suite, the native
+      // harness's `reconcileNonExecutingDecisions` — says REJECT denies the
+      // tool and the run continues with the row SKIPPED. This arm pins the
+      // runtime AS IT IS so the S3 change is a visible diff, and is
+      // deliberately NOT in the kit (S2 M4 finding F1, Q-M4-1).
+      clock.reset();
+      const driver = new RuntimeExecutionDriver(harness, "fake-reject");
+      const propose = scenario.propose("call-runtime-reject", { kind: "shell", resource: "rm -rf build" });
+
+      const first = await driver.turn([propose]);
+      expect(slimOf(subject, first).phase).toBe("EXECUTION_WAITING_FOR_APPROVAL");
+      driver.decide(ApprovalAction.REJECT);
+
+      const second = await driver.turn([scenario.say(NEVER_SEEN)]);
+      expect(slimOf(subject, second).phase).toBe("EXECUTION_FAILED");
+      const final = driver.record.lastFullStatus!;
+      expect(final.error).toBe(TERMINAL_COPY.rejectedByUser.error);
+      expect(systemMessages(final).at(-1)).toBe(TERMINAL_COPY.rejectedByUser.row);
+      expect(final.completedAt).not.toBe("");
+      expect(aiMessages(final)).not.toContain(NEVER_SEEN);
+    });
+  });
+});

package/src/harness/__tests__/stop-controller.test.ts

@@ -0,0 +1,49 @@
+/**
+ * The stop controller: one signal for every cause, every cause recorded,
+ * the first cause the abort's reason. The terminal table's precedence is
+ * decided at settlement from the recorded evidence, not from which cause
+ * aborted first.
+ */
+
+import { describe, expect, it } from "vitest";
+
+import { StallTimeoutError } from "../../shared/stall-watchdog.js";
+import { StopController } from "../stop-controller.js";
+
+describe("StopController", () => {
+  it("starts live with no evidence", () => {
+    const stop = new StopController();
+    expect(stop.signal.aborted).toBe(false);
+    expect(stop.evidence).toEqual({ stall: undefined, costCapExceeded: false, platformStop: false, cancellation: false });
+  });
+
+  it("the first cause aborts the signal and names the abort; later causes are recorded but do not re-abort", () => {
+    const stop = new StopController();
+    stop.stop({ kind: "cost-cap" });
+    expect(stop.signal.aborted).toBe(true);
+    expect(stop.signal.reason).toBe("cost-cap");
+
+    stop.stop({ kind: "cancellation" });
+    stop.stop({ kind: "platform-stop" });
+    expect(stop.signal.reason, "the abort keeps its first reason").toBe("cost-cap");
+    expect(stop.evidence).toMatchObject({ costCapExceeded: true, cancellation: true, platformStop: true });
+  });
+
+  it("keeps the FIRST stall error when the watchdog reports twice", () => {
+    const stop = new StopController();
+    const first = new StallTimeoutError(3_000, "last tool: shell");
+    stop.stop({ kind: "stall", error: first });
+    stop.stop({ kind: "stall", error: new StallTimeoutError(9_000) });
+    expect(stop.evidence.stall).toBe(first);
+  });
+
+  it("fires abort listeners exactly once", () => {
+    const stop = new StopController();
+    let fired = 0;
+    stop.signal.addEventListener("abort", () => fired++);
+    stop.stop({ kind: "cancellation" });
+    stop.stop({ kind: "cancellation" });
+    stop.stop({ kind: "cost-cap" });
+    expect(fired).toBe(1);
+  });
+});