Turns interrupted by a dead worker are never counted against the project budget

diff --git a/services/api/test/turn-dispatcher.integration.test.ts b/services/api/test/turn-dispatcher.integration.test.ts
index 1369ff9..77032c3 100644
--- a/services/api/test/turn-dispatcher.integration.test.ts
+++ b/services/api/test/turn-dispatcher.integration.test.ts
@@ -26,6 +26,7 @@ import postgres from "postgres";
 import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
 import { AgentCatalogService, type AgentCatalogSource } from "../src/agents/catalog.js";
 import { GithubWorkspaceCredentialBroker } from "../src/github/workspace-credentials.js";
+import { CostBudgetService } from "../src/insights/costs.js";
 import { StoryWorkspaceService } from "../src/stories/service.js";
 import { TurnDispatcher } from "../src/turns/dispatcher.js";
 import {
@@ -117,6 +118,7 @@ environment:
     renameNextBranch?: string;
     corruptResumeOnce = false;
     failNextRun = false;
+    failNextRunAfterSpending = false;
     liveFailureGate?: Promise<void>;
     throttleDuringRun = false;
     replacementPending = false;
@@ -175,6 +177,21 @@ environment:
           ],
         });
       }
+      if (this.failNextRunAfterSpending) {
+        this.failNextRunAfterSpending = false;
+        throw new AgentEngineError("agent_engine_failed", "codex exited with status 1", {
+          engine: "codex",
+          exitCode: 1,
+          events: [],
+          durationMs: 1_000,
+          usage: {
+            inputTokens: 100,
+            outputTokens: 20,
+            cacheReadTokens: 0,
+            cacheWriteTokens: 0,
+          },
+        });
+      }
       if (this.corruptResumeOnce && request.nativeSessionId) {
         this.corruptResumeOnce = false;
         this.replacementPending = true;
@@ -1029,6 +1046,99 @@ environment:
     ).toEqual(expect.arrayContaining(["Persist this message before the engine starts"]));
   });
 
+  it("books provider spend for an in-process engine failure but not for a worker-interrupted turn", async () => {
+    const costs = new CostBudgetService(db);
+    await db
+      .insert(projectBudgets)
+      .values({
+        id: newId("bud"),
+        orgId,
+        projectId,
+        monthlyLimitCents: 100_000,
+        warningPercent: 80,
+        enabled: true,
+      })
+      .onConflictDoUpdate({
+        target: projectBudgets.projectId,
+        set: { monthlyLimitCents: 100_000, enabled: true },
+      });
+    const spentBefore = (await costs.budgetState(orgId, projectId)).spentCents;
+
+    engine.failNextRunAfterSpending = true;
+    const accounted = await storiesService.start({
+      orgId,
+      projectId,
+      provider: "manual",
+      externalId: `spend-accounted-${suffix}`,
+      title: "Fail in process after spending",
+      agent: builder,
+      message: "Burn tokens, then fail where the dispatcher can see it",
+      messageDedupeKey: `spend-accounted-start-${suffix}`,
+      actor: { type: "user", id: "user_test" },
+      workspace: { image: "facility-runner:test", ports: [] },
+    });
+    const accountedTurn = accounted.queued.turn;
+    if (!accountedTurn) throw new Error("expected an accounted turn");
+    await expect(
+      dispatcher.dispatch({ orgId, projectId, turnId: accountedTurn.id }),
+    ).resolves.toMatchObject({ state: "failed" });
+    expect(await db.select().from(turnUsage).where(eq(turnUsage.turnId, accountedTurn.id))).toEqual(
+      [
+        expect.objectContaining({
+          inputTokens: 100,
+          outputTokens: 20,
+          priced: true,
+          status: "failed",
+        }),
+      ],
+    );
+    const spentAfterAccounted = (await costs.budgetState(orgId, projectId)).spentCents;
+    expect(spentAfterAccounted).toBeGreaterThan(spentBefore);
+
+    const interrupted = await storiesService.start({
+      orgId,
+      projectId,
+      provider: "manual",
+      externalId: `spend-interrupted-${suffix}`,
+      title: "Lose the worker after spending",
+      agent: builder,
+      message: "Burn the same tokens, then lose the worker",
+      messageDedupeKey: `spend-interrupted-start-${suffix}`,
+      actor: { type: "user", id: "user_test" },
+      workspace: { image: "facility-runner:test", ports: [] },
+    });
+    const interruptedTurn = interrupted.queued.turn;
+    if (!interruptedTurn) throw new Error("expected an interrupted turn");
+    const now = new Date();
+    const stale = new Date(now.getTime() - 5 * 60_000);
+    await db
+      .update(turns)
+      .set({ state: "running", startedAt: stale, updatedAt: stale })
+      .where(eq(turns.id, interruptedTurn.id));
+    await expect(recoverInterruptedTurns(db, storiesService, now, 60_000)).resolves.toBe(1);
+
+    await expect(storiesService.get(orgId, projectId, interrupted.story.id)).resolves.toMatchObject(
+      {
+        turns: expect.arrayContaining([
+          expect.objectContaining({ id: interruptedTurn.id, state: "failed" }),
+        ]),
+        attention: [expect.objectContaining({ kind: "worker_interrupted", status: "open" })],
+      },
+    );
+
+    // Recovery reclaims the row, stops the orphan and raises attention, but books no usage:
+    // whatever the provider charged before the worker died never reaches the budget.
+    expect(
+      await db.select().from(turnUsage).where(eq(turnUsage.turnId, interruptedTurn.id)),
+    ).toEqual([]);
+    expect((await costs.budgetState(orgId, projectId)).spentCents).toBe(spentAfterAccounted);
+
+    await db
+      .update(projectBudgets)
+      .set({ enabled: false })
+      .where(eq(projectBudgets.projectId, projectId));
+  });
+
   it("keeps the agent's renamed branch and native workspace on the next turn", async () => {
     const branch = `chore/retained-${randomUUID()}`;
     const started = await storiesService.start({