@stigmer/runner 3.2.0 → 3.2.2

package/src/activities/__tests__/call-validate.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect } from "vitest";
+import { validateAction } from "../call-validate.js";
+import { transformAction } from "../call-transform.js";
+
+// Regression coverage for the `expr.includes is not a function` crash
+// (workflow-execution-ux-parity upstream #7): rule expressions are
+// deferred code that must reach this activity as jq strings — in either
+// the strict `${ ... }` wrapper or the bare form — and be evaluated here
+// against the validated data, never pre-resolved by the config resolver.
+
+describe("validateAction — rule expressions", () => {
+  // The exact shape of WF1 ux-linear-basics' check_order task after the
+  // call-function builder resolves `input` and defers the rule.
+  const checkOrderConfig = {
+    input: {
+      order_id: "ORD-2026-0716",
+      customer: "Ada Lovelace",
+      currency: "USD",
+      line_count: 2,
+      total: 150,
+    },
+    schema: {
+      type: "object",
+      required: ["order_id", "total", "line_count"],
+      properties: {
+        order_id: { type: "string" },
+        total: { type: "number" },
+        line_count: { type: "integer" },
+      },
+    },
+    rules: [
+      {
+        name: "total_is_positive",
+        expression: "${ .total > 0 }",
+        message: "Order total must be positive",
+      },
+    ],
+    on_fail: "VALIDATION_FAIL_RAISE",
+  };
+
+  it("evaluates a ${ }-wrapped rule against the validate input (WF1 check_order)", async () => {
+    const result = await validateAction(checkOrderConfig);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toEqual([]);
+  });
+
+  it("evaluates a bare jq rule expression", async () => {
+    const result = await validateAction({
+      input: { total: 150 },
+      rules: [{ name: "positive", expression: ".total > 0" }],
+      on_fail: "VALIDATION_FAIL_WARN",
+    });
+    expect(result.valid).toBe(true);
+  });
+
+  it("reports the rule message when the predicate fails", async () => {
+    const result = await validateAction({
+      input: { total: -5 },
+      rules: [
+        {
+          name: "total_is_positive",
+          expression: "${ .total > 0 }",
+          message: "Order total must be positive",
+        },
+      ],
+      on_fail: "VALIDATION_FAIL_WARN",
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errors).toEqual([
+      { rule: "total_is_positive", message: "Order total must be positive" },
+    ]);
+  });
+
+  it("turns a non-string expression into a named config error, not a TypeError", async () => {
+    // The pre-fix failure mode: the resolver substituted the evaluated
+    // boolean back into the rule. The guard must name the rule and the
+    // expected shape instead of crashing in the jq engine.
+    const result = await validateAction({
+      input: { total: 150 },
+      rules: [
+        { name: "broken_rule", expression: true as unknown as string },
+      ],
+      on_fail: "VALIDATION_FAIL_WARN",
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].rule).toBe("broken_rule");
+    expect(result.errors[0].message).toContain("expected a jq predicate string");
+    expect(result.errors[0].message).toContain("boolean");
+  });
+
+  it("raises on failed rules when on_fail is RAISE", async () => {
+    await expect(
+      validateAction({
+        input: { total: -5 },
+        rules: [
+          {
+            name: "total_is_positive",
+            expression: "${ .total > 0 }",
+            message: "Order total must be positive",
+          },
+        ],
+        on_fail: "VALIDATION_FAIL_RAISE",
+      }),
+    ).rejects.toThrow("Order total must be positive");
+  });
+});
+
+describe("transformAction — deferred expression forms", () => {
+  it("accepts a ${ }-wrapped expression", async () => {
+    const result = await transformAction({
+      engine: "TRANSFORM_ENGINE_JQ",
+      expression: "${ { doubled: (.qty * 2) } }",
+      input: { qty: 21 },
+    });
+    expect(result).toEqual({ doubled: 42 });
+  });
+
+  it("accepts the bare jq form the converter emits", async () => {
+    const result = await transformAction({
+      engine: "TRANSFORM_ENGINE_JQ",
+      expression: "{ total: ([.items[] | .qty * .unit_price] | add) }",
+      input: { items: [{ qty: 2, unit_price: 25.5 }, { qty: 1, unit_price: 99 }] },
+    });
+    expect(result).toEqual({ total: 150 });
+  });
+
+  it("rejects a non-string expression with a clear config error", async () => {
+    await expect(
+      transformAction({
+        engine: "JQ",
+        expression: { not: "a string" } as unknown as string,
+        input: {},
+      }),
+    ).rejects.toThrow("must be a jq string");
+  });
+});

package/src/activities/__tests__/classify-tool-approvals.test.ts

@@ -622,6 +622,7 @@ function makeConfig() {
     checkpointerProxyEndpoint: null,
     primaryModel: "gpt-4.1",
     cursorStreamStallTimeoutMs: 180000,
+    agentResolveTimeoutMs: 120000,
     workspaceLockTimeoutMs: 900000,
   };
 }

package/src/activities/__tests__/discover-mcp-server.test.ts

@@ -601,6 +601,7 @@ function makeConfig() {
     checkpointerProxyEndpoint: null,
     primaryModel: "gpt-4.1",
     cursorStreamStallTimeoutMs: 180000,
+    agentResolveTimeoutMs: 120000,
     workspaceLockTimeoutMs: 900000,
   };
 }

package/src/activities/__tests__/workflow-event-activities.test.ts

@@ -240,6 +240,35 @@ describe("toProtoEvent", () => {
       expect(evt.payload.value.taskKind).toBe(0);
     });
 
+    it("maps inputSummary onto the payload Struct", () => {
+      const evt = toProtoEvent({
+        type: "task_started",
+        taskName: "seed_order",
+        occurredAt: NOW,
+        taskKind: "set",
+        attemptNumber: 1,
+        inputSummary: { variables: { order_id: "ORD-1" } },
+      });
+
+      if (evt.payload.case !== "taskStarted") throw new Error("unexpected");
+      expect(evt.payload.value.inputSummary).toEqual({
+        variables: { order_id: "ORD-1" },
+      });
+    });
+
+    it("leaves inputSummary unset when the descriptor omits it", () => {
+      const evt = toProtoEvent({
+        type: "task_started",
+        taskName: "t",
+        occurredAt: NOW,
+        taskKind: "set",
+        attemptNumber: 1,
+      });
+
+      if (evt.payload.case !== "taskStarted") throw new Error("unexpected");
+      expect(evt.payload.value.inputSummary).toBeUndefined();
+    });
+
     it("maps call:agent to proto agent_call (13), not http_call (2)", () => {
       const evt = toProtoEvent({
         type: "task_started",
@@ -352,6 +381,37 @@ describe("toProtoEvent", () => {
       expect(evt.payload.value.costMicros).toBe(BigInt(100000));
       expect(evt.payload.value.tokensUsed).toBe(BigInt(800));
     });
+
+    it("maps outputSummary onto the payload Struct", () => {
+      const evt = toProtoEvent({
+        type: "task_completed",
+        taskName: "total_order",
+        occurredAt: NOW,
+        taskKind: "call:function:transform",
+        durationMs: 160,
+        costMicros: 0,
+        tokensUsed: 0,
+        outputSummary: { total: 150, line_count: 2 },
+      });
+
+      if (evt.payload.case !== "taskCompleted") throw new Error("unexpected");
+      expect(evt.payload.value.outputSummary).toEqual({ total: 150, line_count: 2 });
+    });
+
+    it("leaves outputSummary unset when the descriptor omits it", () => {
+      const evt = toProtoEvent({
+        type: "task_completed",
+        taskName: "t",
+        occurredAt: NOW,
+        taskKind: "set",
+        durationMs: 1,
+        costMicros: 0,
+        tokensUsed: 0,
+      });
+
+      if (evt.payload.case !== "taskCompleted") throw new Error("unexpected");
+      expect(evt.payload.value.outputSummary).toBeUndefined();
+    });
   });
 
   describe("task_failed", () => {

package/src/activities/call-transform.ts

@@ -14,7 +14,11 @@
  */
 
 import { ApplicationFailure } from "@temporalio/activity";
-import { evaluateExpression } from "../workflow-engine/expression.js";
+import {
+  evaluateExpression,
+  isStrictExpr,
+  sanitizeExpr,
+} from "../workflow-engine/expression.js";
 
 export interface TransformConfig {
   readonly engine: string;
@@ -38,6 +42,13 @@ export async function transformAction(
       "TRANSFORM_MISSING_EXPRESSION",
     );
   }
+  if (typeof config.expression !== "string") {
+    throw ApplicationFailure.nonRetryable(
+      `transform: 'expression' must be a jq string, got ${typeof config.expression}. ` +
+        "Fix the expression in the workflow's transform task_config.",
+      "TRANSFORM_INVALID_EXPRESSION",
+    );
+  }
 
   const engine = normalizeEngine(config.engine || "JQ");
 
@@ -50,5 +61,12 @@ export async function transformAction(
 
   const data = config.input !== undefined ? config.input : taskInput;
 
-  return evaluateExpression(config.expression, data, {});
+  // The expression arrives unresolved (deferred code — see the
+  // call-function builder). Accept both the strict `${ ... }` wrapper
+  // and the bare jq form the converter emits.
+  const expression = isStrictExpr(config.expression)
+    ? sanitizeExpr(config.expression)
+    : config.expression;
+
+  return evaluateExpression(expression, data, {});
 }

package/src/activities/call-validate.ts

@@ -18,7 +18,11 @@
  */
 
 import { ApplicationFailure } from "@temporalio/activity";
-import { evaluateExpression } from "../workflow-engine/expression.js";
+import {
+  evaluateExpression,
+  isStrictExpr,
+  sanitizeExpr,
+} from "../workflow-engine/expression.js";
 
 export interface ValidateConfig {
   readonly input: unknown;
@@ -160,7 +164,28 @@ async function validateRules(
   const errors: ValidationError[] = [];
 
   for (const rule of rules) {
-    const result = await evaluateExpression(rule.expression, data, {});
+    // Config guard: the expression must be a jq string. Anything else is
+    // a workflow-definition defect (or an upstream resolution bug) — name
+    // the rule and what to fix instead of crashing in the jq engine.
+    if (typeof rule.expression !== "string" || rule.expression.length === 0) {
+      errors.push({
+        rule: rule.name,
+        message:
+          `Rule '${rule.name}' has an invalid 'expression': expected a jq ` +
+          `predicate string, got ${typeof rule.expression}. Fix the rule in ` +
+          `the workflow's validate task_config.`,
+      });
+      continue;
+    }
+
+    // Rule expressions arrive unresolved (deferred code — see the
+    // call-function builder). Accept both the strict `${ ... }` wrapper
+    // and a bare jq predicate.
+    const expr = isStrictExpr(rule.expression)
+      ? sanitizeExpr(rule.expression)
+      : rule.expression;
+
+    const result = await evaluateExpression(expr, data, {});
     if (!result) {
       errors.push({
         rule: rule.name,

package/src/activities/discover-mcp-server.ts

@@ -25,6 +25,7 @@ import { StigmerClient } from "../client/stigmer-client.js";
 import { mcpServerToResolved } from "../shared/mcp-resolver.js";
 import { toMcpClientConfig } from "../shared/mcp-manager.js";
 import { detectOAuthChallenge } from "../shared/mcp-oauth-detect.js";
+import { withTimeout } from "../shared/with-timeout.js";
 import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
 import type { Config } from "../config.js";
 
@@ -326,7 +327,12 @@ async function connectAndDiscover(
   const resourceTemplates: DiscoveredResourceTemplateResult[] = [];
 
   try {
-    await withTimeout(SESSION_INIT_TIMEOUT_MS, slug, async () => {
+    const timeoutMessage =
+      `MCP server '${slug}' did not respond within ` +
+      `${Math.round(SESSION_INIT_TIMEOUT_MS / 1000)}s. If this server requires compilation or ` +
+      `package installation on first run (e.g. go run, npx), the cold ` +
+      `start may have exceeded the discovery timeout.`;
+    await withTimeout(SESSION_INIT_TIMEOUT_MS, timeoutMessage, async () => {
       await client.initializeConnections();
 
       const mcpClient = await client.getClient(slug);
@@ -411,33 +417,6 @@ async function classifyHttpOAuthFailure(
   return detectOAuthChallenge(connection.url, connection.headers, slug);
 }
 
-async function withTimeout<T>(
-  ms: number,
-  serverSlug: string,
-  fn: () => Promise<T>,
-): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    const timer = setTimeout(() => {
-      reject(new Error(
-        `MCP server '${serverSlug}' did not respond within ` +
-        `${Math.round(ms / 1000)}s. If this server requires compilation or ` +
-        `package installation on first run (e.g. go run, npx), the cold ` +
-        `start may have exceeded the discovery timeout.`,
-      ));
-    }, ms);
-
-    fn()
-      .then((result) => {
-        clearTimeout(timer);
-        resolve(result);
-      })
-      .catch((err) => {
-        clearTimeout(timer);
-        reject(err);
-      });
-  });
-}
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Temporal Activity Factory
 // ─────────────────────────────────────────────────────────────────────────────

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

@@ -87,6 +87,71 @@ describe("buildPrompt", () => {
     expect(prompt).toContain(USER_MESSAGE);
   });
 
+  it("carries the rollover context bridge on the first execution (DD-013)", () => {
+    const prompt = buildPrompt(
+      input({
+        resolution: resolution("local", "created_first_execution"),
+        contextBridge: "Subject: Orders\nUser: where is my order?\nAssistant: Shipped.",
+      }),
+    );
+    expect(prompt).toContain("<previous_conversation_context>");
+    expect(prompt).toContain("User: where is my order?");
+    // The bridge is CONTEXT; the approval protocol keeps its pinned
+    // last-before-task slot so instructions outweigh it.
+    expect(prompt.indexOf("<previous_conversation_context>"))
+      .toBeLessThan(prompt.indexOf("<tool_approval_protocol>"));
+  });
+
+  it("never bridges a successfully resumed agent — its native context IS the conversation", () => {
+    const prompt = buildPrompt(
+      input({
+        resolution: resolution("local", "resumed_successfully"),
+        contextBridge: "Subject: Orders\nUser: hi\nAssistant: hello",
+      }),
+    );
+    expect(prompt).toBe(USER_MESSAGE);
+  });
+
+  it("omits the bridge section when the session carries none", () => {
+    const prompt = buildPrompt(
+      input({ resolution: resolution("local", "created_first_execution") }),
+    );
+    expect(prompt).not.toContain("<previous_conversation_context>");
+  });
+
+  it("carries the channel sender identity on the first execution", () => {
+    const prompt = buildPrompt(
+      input({
+        resolution: resolution("local", "created_first_execution"),
+        senderIdentity: { value: "15550001111", kind: "whatsapp_phone" },
+      }),
+    );
+    expect(prompt).toContain("<conversation_sender>");
+    expect(prompt).toContain("WhatsApp phone number");
+    expect(prompt).toContain("15550001111");
+    // Identity is CONTEXT like the bridge; the approval protocol keeps its
+    // pinned last-before-task slot.
+    expect(prompt.indexOf("<conversation_sender>"))
+      .toBeLessThan(prompt.indexOf("<tool_approval_protocol>"));
+  });
+
+  it("never re-sends the identity to a successfully resumed agent — its native context carries it", () => {
+    const prompt = buildPrompt(
+      input({
+        resolution: resolution("local", "resumed_successfully"),
+        senderIdentity: { value: "U0USER", kind: "slack_user_id" },
+      }),
+    );
+    expect(prompt).toBe(USER_MESSAGE);
+  });
+
+  it("omits the sender section when the session carries no identity (console sessions)", () => {
+    const prompt = buildPrompt(
+      input({ resolution: resolution("local", "created_first_execution") }),
+    );
+    expect(prompt).not.toContain("<conversation_sender>");
+  });
+
   it("uses the reinvocation prompt for a HITL reinvocation (human-meaningful, no opaque ids)", () => {
     const approvalDecisions = new Map<string, ApprovalAction>([
       ["tool-call-1", ApprovalAction.APPROVE],

package/src/activities/execute-cursor/__tests__/cost-guard.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Unit tests for the Cursor harness's max_cost_usd guard (cost-guard.ts).
+ *
+ * The guard is the cursor-side analog of the native cost-cap middleware
+ * (middleware/cost-cap.ts): same proto semantics (0/unset = no cap), same
+ * inclusive boundary (`>=`), same estimation basis. These tests pin those
+ * semantics so the two harnesses cannot silently diverge.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  costCapExceeded,
+  formatCostLimitError,
+  COST_LIMIT_ERROR_PREFIX,
+  COST_LIMIT_USER_COPY,
+} from "../cost-guard.js";
+
+describe("costCapExceeded", () => {
+  it("never fires when no cap is configured (0 = unset per the proto contract)", () => {
+    expect(costCapExceeded(0, 999)).toBe(false);
+  });
+
+  it("never fires for a negative cap", () => {
+    expect(costCapExceeded(-1, 999)).toBe(false);
+  });
+
+  it("does not fire below the cap", () => {
+    expect(costCapExceeded(0.5, 0.4999)).toBe(false);
+  });
+
+  it("fires exactly at the cap (inclusive boundary, matching the native middleware)", () => {
+    expect(costCapExceeded(0.5, 0.5)).toBe(true);
+  });
+
+  it("fires above the cap", () => {
+    expect(costCapExceeded(0.5, 0.51)).toBe(true);
+  });
+
+  it("does not fire when nothing has been spent", () => {
+    expect(costCapExceeded(0.5, 0)).toBe(false);
+  });
+});
+
+describe("cost-limit terminal copy", () => {
+  it("pins the error prefix consumers match on (no structured termination reason exists)", () => {
+    // Mirrors the TOOL_CALL_LIMIT_ERROR_PREFIX guard in
+    // streaming-terminal.test.ts: a reword silently downgrades any consumer
+    // matching this prefix to generic error copy.
+    expect(COST_LIMIT_ERROR_PREFIX).toBe("Agent reached the cost limit");
+  });
+
+  it("formats the error with the prefix, both amounts, and a continuation hint", () => {
+    const err = formatCostLimitError(0.5, 0.5123);
+    expect(err.startsWith(COST_LIMIT_ERROR_PREFIX)).toBe(true);
+    expect(err).toContain("$0.5123");
+    expect(err).toContain("$0.50");
+    expect(err).toContain("Send another message to continue");
+  });
+
+  it("user copy is honest about the limit and that work is saved", () => {
+    expect(COST_LIMIT_USER_COPY).toContain("cost limit");
+    expect(COST_LIMIT_USER_COPY).toContain("saved");
+  });
+});

package/src/activities/execute-cursor/__tests__/turn-stream.test.ts

@@ -111,6 +111,7 @@ function buildDeps(overrides: Partial<CursorTurnStreamDeps> = {}): BuiltDeps {
     promptEstimatedTokens: 100,
     executionId: "exec-test",
     state,
+    maxCostUsd: 0,
     // CursorTurnStreamDeps
     status,
     accumulator,
@@ -261,6 +262,78 @@ describe("consumeCursorTurnStream", () => {
     });
   });
 
+  describe("cost-cap stop", () => {
+    it("cancels the run, stops the stream, and returns 'cost-cap' when onDelta flagged the overrun", async () => {
+      const state = newTurnStreamState();
+      state.costCapExceeded = true; // onDelta's write, simulated
+      const { deps, accumulator } = buildDeps({ state });
+      const run = mockRun([ev({ type: "assistant" }), ev({ type: "assistant" })]);
+
+      const reason = await consumeCursorTurnStream(run, deps);
+
+      expect(reason).toBe("cost-cap");
+      expect(run.cancel).toHaveBeenCalled();
+      // The break happens before the event is processed — no post-cap content.
+      expect(accumulator.processEvent).not.toHaveBeenCalled();
+    });
+
+    it("detects the flag mid-stream when onDelta sets it between events", async () => {
+      const state = newTurnStreamState();
+      const { deps, accumulator } = buildDeps({ state });
+      // Simulate onDelta's write landing between event 1 and event 2 — the
+      // realistic shape: a turn-ended usage delta crosses the cap while the
+      // loop is between stream events.
+      async function* gen(): AsyncIterable<SDKMessage> {
+        yield ev({ type: "assistant" });
+        state.costCapExceeded = true;
+        yield ev({ type: "assistant" });
+      }
+      const run: MockRun = {
+        stream: () => gen(),
+        supports: () => true,
+        cancel: vi.fn(async () => {}),
+      };
+
+      const reason = await consumeCursorTurnStream(run, deps);
+
+      expect(reason).toBe("cost-cap");
+      expect(run.cancel).toHaveBeenCalled();
+      // Event 1 was processed; event 2 hit the break before processing.
+      expect(accumulator.processEvent).toHaveBeenCalledTimes(1);
+    });
+
+    it("swallows the cancel-induced teardown rejection (expected, not a failure)", async () => {
+      const state = newTurnStreamState();
+      state.costCapExceeded = true;
+      const { deps } = buildDeps({ state });
+      // The break exits the for-await, which invokes the iterator's return();
+      // a cancelled SDK run can reject there. The catch must exempt cost-cap
+      // teardown exactly like stall/first-denial teardown.
+      const events = [ev({ type: "assistant" })];
+      let i = 0;
+      const run: MockRun = {
+        stream: () => ({
+          [Symbol.asyncIterator]: () => ({
+            next: async () =>
+              i < events.length
+                ? { value: events[i++], done: false as const }
+                : { value: undefined, done: true as const },
+            return: async () => {
+              throw new Error("run cancelled");
+            },
+          }),
+        }),
+        supports: () => true,
+        cancel: vi.fn(async () => {}),
+      };
+
+      const reason = await consumeCursorTurnStream(run, deps);
+
+      expect(reason).toBe("cost-cap");
+      expect(run.cancel).toHaveBeenCalled();
+    });
+  });
+
   it("returns 'stalled' and cancels the run when the stall watchdog fires", async () => {
     vi.useFakeTimers();
     // The generator yields one event, then awaits a promise resolved only by
@@ -305,6 +378,7 @@ describe("makeCursorTurnOnDelta", () => {
       promptEstimatedTokens: 10,
       executionId: "e",
       state,
+      maxCostUsd: 0,
     });
 
     expect(() => onDelta({ update: { type: "text" } as never })).not.toThrow();
@@ -322,6 +396,7 @@ describe("makeCursorTurnOnDelta", () => {
       promptEstimatedTokens: 10,
       executionId: "e",
       state,
+      maxCostUsd: 0,
     });
 
     expect(() => onDelta({ update: { type: "text" } as never })).toThrow("boom");
@@ -338,6 +413,7 @@ describe("makeCursorTurnOnDelta", () => {
       promptEstimatedTokens: 10,
       executionId: "e",
       state,
+      maxCostUsd: 0,
     });
 
     onDelta({ update: { type: "turn-ended", usage: { inputTokens: 100 } } as never });
@@ -346,4 +422,46 @@ describe("makeCursorTurnOnDelta", () => {
     expect(usageAccumulator.addTurn).toHaveBeenCalledTimes(2);
     expect(state.firstTurnAttributionLogged).toBe(true);
   });
+
+  it("flags costCapExceeded when a turn-ended usage delta pushes the estimate past the cap", () => {
+    const state = newTurnStreamState();
+    const usageAccumulator = {
+      ...stubUsageAccumulator(),
+      snapshot: vi.fn(() => ({ estimatedCostUsd: 0.51 })),
+    };
+    const onDelta = makeCursorTurnOnDelta({
+      usageAccumulator: usageAccumulator as never,
+      deltaEnricher: stubEnricher() as never,
+      heartbeat: vi.fn(),
+      promptEstimatedTokens: 10,
+      executionId: "e",
+      state,
+      maxCostUsd: 0.5,
+    });
+
+    onDelta({ update: { type: "turn-ended", usage: { inputTokens: 100 } } as never });
+
+    expect(state.costCapExceeded).toBe(true);
+  });
+
+  it("never flags costCapExceeded when no cap is configured", () => {
+    const state = newTurnStreamState();
+    const usageAccumulator = {
+      ...stubUsageAccumulator(),
+      snapshot: vi.fn(() => ({ estimatedCostUsd: 999 })),
+    };
+    const onDelta = makeCursorTurnOnDelta({
+      usageAccumulator: usageAccumulator as never,
+      deltaEnricher: stubEnricher() as never,
+      heartbeat: vi.fn(),
+      promptEstimatedTokens: 10,
+      executionId: "e",
+      state,
+      maxCostUsd: 0,
+    });
+
+    onDelta({ update: { type: "turn-ended", usage: { inputTokens: 100 } } as never });
+
+    expect(state.costCapExceeded).toBe(false);
+  });
 });