@wopr-network/platform-core 1.73.0 → 1.74.1

package/dist/fleet/drizzle-bot-instance-repository.d.ts

@@ -24,7 +24,9 @@ export declare class DrizzleBotInstanceRepository implements IBotInstanceReposit
     suspend(botId: string, graceDays: number): Promise<void>;
     reactivate(botId: string): Promise<void>;
     markDestroyed(botId: string): Promise<void>;
-    register(botId: string, tenantId: string, name: string): Promise<void>;
+    register(botId: string, tenantId: string, name: string, billingState?: BillingState): Promise<void>;
+    startBilling(botId: string): Promise<void>;
+    stopBilling(botId: string): Promise<void>;
     getStorageTier(botId: string): Promise<string | null>;
     setStorageTier(botId: string, tier: string): Promise<void>;
     listActiveStorageTiers(tenantId: string): Promise<string[]>;

package/dist/fleet/drizzle-bot-instance-repository.js

@@ -194,14 +194,20 @@ export class DrizzleBotInstanceRepository {
         })
             .where(eq(botInstances.id, botId));
     }
-    async register(botId, tenantId, name) {
+    async register(botId, tenantId, name, billingState = "inactive") {
         await this.db.insert(botInstances).values({
             id: botId,
             tenantId,
             name,
-            billingState: "active",
+            billingState,
         });
     }
+    async startBilling(botId) {
+        await this.db.update(botInstances).set({ billingState: "active" }).where(eq(botInstances.id, botId));
+    }
+    async stopBilling(botId) {
+        await this.db.update(botInstances).set({ billingState: "inactive" }).where(eq(botInstances.id, botId));
+    }
     async getStorageTier(botId) {
         const row = (await this.db
             .select({ storageTier: botInstances.storageTier })

package/dist/fleet/fleet-manager.js

@@ -125,6 +125,15 @@ export class FleetManager {
             }
             const instance = await this.buildInstance(profile);
             instance.emitCreated();
+            // Register in bot_instances DB table for billing
+            if (this.instanceRepo) {
+                try {
+                    await this.instanceRepo.register(id, profile.tenantId, profile.name);
+                }
+                catch (err) {
+                    logger.warn("Failed to register bot instance in DB (non-fatal)", { id, err });
+                }
+            }
             return instance;
         };
         return hasExplicitId ? this.withLock(id, doCreate) : doCreate();
@@ -208,6 +217,15 @@ export class FleetManager {
             if (this.networkPolicy) {
                 await this.networkPolicy.cleanupAfterRemoval(profile.tenantId);
             }
+            // Remove from bot_instances DB table
+            if (this.instanceRepo) {
+                try {
+                    await this.instanceRepo.deleteById(id);
+                }
+                catch (err) {
+                    logger.warn("Failed to delete bot instance from DB (non-fatal)", { id, err });
+                }
+            }
             await this.store.delete(id);
             logger.info(`Removed bot ${id}`);
             this.emitEvent("bot.removed", id, profile.tenantId);

package/dist/fleet/instance.d.ts

@@ -51,6 +51,14 @@ export declare class Instance {
     private withLock;
     /** Emit bot.created — call only from FleetManager.create(), not getInstance() */
     emitCreated(): void;
+    /**
+     * Start billing for this instance ($5/month prorated daily).
+     * Call after creation for persistent, billable instances (e.g., Paperclip).
+     * Ephemeral instances (e.g., Holy Ship) skip this — they bill per-token at the gateway.
+     */
+    startBilling(): Promise<void>;
+    /** Stop billing for this instance (e.g., on suspend or downgrade). */
+    stopBilling(): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;
     /**

package/dist/fleet/instance.js

@@ -71,6 +71,26 @@ export class Instance {
     emitCreated() {
         this.emit("bot.created");
     }
+    /**
+     * Start billing for this instance ($5/month prorated daily).
+     * Call after creation for persistent, billable instances (e.g., Paperclip).
+     * Ephemeral instances (e.g., Holy Ship) skip this — they bill per-token at the gateway.
+     */
+    async startBilling() {
+        if (!this.instanceRepo) {
+            logger.warn("startBilling() called but no instanceRepo available", { id: this.id });
+            return;
+        }
+        await this.instanceRepo.setBillingState(this.id, "active");
+        logger.info("Billing started for instance", { id: this.id, name: this.profile.name });
+    }
+    /** Stop billing for this instance (e.g., on suspend or downgrade). */
+    async stopBilling() {
+        if (!this.instanceRepo)
+            return;
+        await this.instanceRepo.setBillingState(this.id, "suspended");
+        logger.info("Billing stopped for instance", { id: this.id, name: this.profile.name });
+    }
     async start() {
         this.assertLocal("start()");
         return this.withLock(async () => {

package/dist/fleet/repository-types.d.ts

@@ -48,7 +48,7 @@ export interface SelfHostedNodeRegistration extends NodeRegistration {
     nodeSecretHash: string;
 }
 /** Billing lifecycle states for a bot instance. */
-export type BillingState = "active" | "suspended" | "destroyed";
+export type BillingState = "active" | "inactive" | "suspended" | "destroyed";
 /** Plain domain object for a bot instance — mirrors `bot_instances` table. */
 export interface BotInstance {
     id: string;

package/dist/monetization/credits/bot-billing.test.js

@@ -50,6 +50,7 @@ function createMockDeps(nodeId = "node-1") {
 describe("BotBilling", () => {
     let pool;
     let db;
+    let repo;
     let billing;
     let ledger;
     beforeAll(async () => {
@@ -60,13 +61,15 @@ describe("BotBilling", () => {
     });
     beforeEach(async () => {
         await truncateAllTables(pool);
-        billing = new BotBilling(new DrizzleBotInstanceRepository(db));
+        repo = new DrizzleBotInstanceRepository(db);
+        billing = new BotBilling(repo);
         ledger = new DrizzleLedger(db);
         await ledger.seedSystemAccounts();
     });
     describe("registerBot", () => {
         it("registers a bot in active billing state", async () => {
             await billing.registerBot("bot-1", "tenant-1", "my-bot");
+            await repo.startBilling("bot-1");
             const info = await billing.getBotBilling("bot-1");
             expect(info).not.toBeNull();
             // biome-ignore lint/suspicious/noExplicitAny: intentional test cast
@@ -87,19 +90,25 @@ describe("BotBilling", () => {
         });
         it("counts only active bots for the tenant", async () => {
             await billing.registerBot("bot-1", "tenant-1", "bot-a");
+            await repo.startBilling("bot-1");
             await billing.registerBot("bot-2", "tenant-1", "bot-b");
+            await repo.startBilling("bot-2");
             await billing.registerBot("bot-3", "tenant-2", "bot-c");
+            await repo.startBilling("bot-3");
             expect(await billing.getActiveBotCount("tenant-1")).toBe(2);
             expect(await billing.getActiveBotCount("tenant-2")).toBe(1);
         });
         it("does not count suspended bots", async () => {
             await billing.registerBot("bot-1", "tenant-1", "bot-a");
+            await repo.startBilling("bot-1");
             await billing.registerBot("bot-2", "tenant-1", "bot-b");
+            await repo.startBilling("bot-2");
             await billing.suspendBot("bot-1");
             expect(await billing.getActiveBotCount("tenant-1")).toBe(1);
         });
         it("does not count destroyed bots", async () => {
             await billing.registerBot("bot-1", "tenant-1", "bot-a");
+            await repo.startBilling("bot-1");
             await billing.destroyBot("bot-1");
             expect(await billing.getActiveBotCount("tenant-1")).toBe(0);
         });
@@ -107,6 +116,7 @@ describe("BotBilling", () => {
     describe("suspendBot", () => {
         it("transitions bot from active to suspended", async () => {
             await billing.registerBot("bot-1", "tenant-1", "my-bot");
+            await repo.startBilling("bot-1");
             await billing.suspendBot("bot-1");
             const info = await billing.getBotBilling("bot-1");
             // biome-ignore lint/suspicious/noExplicitAny: intentional test cast
@@ -118,6 +128,7 @@ describe("BotBilling", () => {
         });
         it("sets destroyAfter to 30 days after suspension", async () => {
             await billing.registerBot("bot-1", "tenant-1", "my-bot");
+            await repo.startBilling("bot-1");
             await billing.suspendBot("bot-1");
             const info = await billing.getBotBilling("bot-1");
             expect(info).not.toBeNull();
@@ -132,8 +143,11 @@ describe("BotBilling", () => {
     describe("suspendAllForTenant", () => {
         it("suspends all active bots for a tenant", async () => {
             await billing.registerBot("bot-1", "tenant-1", "bot-a");
+            await repo.startBilling("bot-1");
             await billing.registerBot("bot-2", "tenant-1", "bot-b");
+            await repo.startBilling("bot-2");
             await billing.registerBot("bot-3", "tenant-2", "bot-c");
+            await repo.startBilling("bot-3");
             const suspended = await billing.suspendAllForTenant("tenant-1");
             expect(suspended.sort()).toEqual(["bot-1", "bot-2"]);
             expect(await billing.getActiveBotCount("tenant-1")).toBe(0);
@@ -147,6 +161,7 @@ describe("BotBilling", () => {
     describe("reactivateBot", () => {
         it("transitions bot from suspended to active", async () => {
             await billing.registerBot("bot-1", "tenant-1", "my-bot");
+            await repo.startBilling("bot-1");
             await billing.suspendBot("bot-1");
             await billing.reactivateBot("bot-1");
             const info = await billing.getBotBilling("bot-1");
@@ -159,6 +174,7 @@ describe("BotBilling", () => {
         });
         it("does not reactivate a destroyed bot", async () => {
             await billing.registerBot("bot-1", "tenant-1", "my-bot");
+            await repo.startBilling("bot-1");
             await billing.destroyBot("bot-1");
             await billing.reactivateBot("bot-1");
             const info = await billing.getBotBilling("bot-1");
@@ -167,6 +183,7 @@ describe("BotBilling", () => {
         });
         it("does not affect already-active bots", async () => {
             await billing.registerBot("bot-1", "tenant-1", "my-bot");
+            await repo.startBilling("bot-1");
             await billing.reactivateBot("bot-1");
             const info = await billing.getBotBilling("bot-1");
             // biome-ignore lint/suspicious/noExplicitAny: intentional test cast
@@ -176,7 +193,9 @@ describe("BotBilling", () => {
     describe("checkReactivation", () => {
         it("reactivates suspended bots when balance is positive", async () => {
             await billing.registerBot("bot-1", "tenant-1", "bot-a");
+            await repo.startBilling("bot-1");
             await billing.registerBot("bot-2", "tenant-1", "bot-b");
+            await repo.startBilling("bot-2");
             await billing.suspendBot("bot-1");
             await billing.suspendBot("bot-2");
             await ledger.credit("tenant-1", Credit.fromCents(500), "purchase", {
@@ -190,6 +209,7 @@ describe("BotBilling", () => {
         });
         it("does not reactivate when balance is zero", async () => {
             await billing.registerBot("bot-1", "tenant-1", "bot-a");
+            await repo.startBilling("bot-1");
             await billing.suspendBot("bot-1");
             const reactivated = await billing.checkReactivation("tenant-1", ledger);
             expect(reactivated).toEqual([]);
@@ -197,6 +217,7 @@ describe("BotBilling", () => {
         });
         it("does not reactivate destroyed bots", async () => {
             await billing.registerBot("bot-1", "tenant-1", "bot-a");
+            await repo.startBilling("bot-1");
             await billing.destroyBot("bot-1");
             await ledger.credit("tenant-1", Credit.fromCents(500), "purchase", {
                 description: "test credit",
@@ -219,6 +240,7 @@ describe("BotBilling", () => {
     describe("destroyBot", () => {
         it("marks bot as destroyed", async () => {
             await billing.registerBot("bot-1", "tenant-1", "my-bot");
+            await repo.startBilling("bot-1");
             await billing.destroyBot("bot-1");
             const info = await billing.getBotBilling("bot-1");
             // biome-ignore lint/suspicious/noExplicitAny: intentional test cast
@@ -228,6 +250,7 @@ describe("BotBilling", () => {
     describe("destroyExpiredBots", () => {
         it("destroys bots past their grace period", async () => {
             await billing.registerBot("bot-1", "tenant-1", "bot-a");
+            await repo.startBilling("bot-1");
             // Set destroyAfter to the past using drizzle sql
             await db
                 .update(botInstances)
@@ -245,6 +268,7 @@ describe("BotBilling", () => {
         });
         it("does not destroy bots still within grace period", async () => {
             await billing.registerBot("bot-1", "tenant-1", "bot-a");
+            await repo.startBilling("bot-1");
             await billing.suspendBot("bot-1");
             const destroyed = await billing.destroyExpiredBots();
             expect(destroyed).toEqual([]);
@@ -254,6 +278,7 @@ describe("BotBilling", () => {
         });
         it("does not touch active bots", async () => {
             await billing.registerBot("bot-1", "tenant-1", "bot-a");
+            await repo.startBilling("bot-1");
             const destroyed = await billing.destroyExpiredBots();
             expect(destroyed).toEqual([]);
         });
@@ -316,13 +341,16 @@ describe("BotBilling", () => {
         });
         it("returns correct daily cost for known storage tiers", async () => {
             await billing.registerBot("bot-1", "tenant-1", "bot-a");
+            await repo.startBilling("bot-1");
             await billing.setStorageTier("bot-1", "pro");
             await billing.registerBot("bot-2", "tenant-1", "bot-b");
+            await repo.startBilling("bot-2");
             await billing.setStorageTier("bot-2", "plus");
             expect((await billing.getStorageTierCostsForTenant("tenant-1")).toCents()).toBe(11);
         });
         it("returns 0 for unknown storage tier (fallback branch)", async () => {
             await billing.registerBot("bot-1", "tenant-1", "bot-a");
+            await repo.startBilling("bot-1");
             // Bypass setStorageTier to insert an unrecognized tier value directly
             await pool.query(`UPDATE bot_instances SET storage_tier = 'unknown_tier' WHERE id = 'bot-1'`);
             // STORAGE_TIERS['unknown_tier'] is undefined → Credit.ZERO fallback
@@ -330,6 +358,7 @@ describe("BotBilling", () => {
         });
         it("does not include suspended bots in storage tier cost", async () => {
             await billing.registerBot("bot-1", "tenant-1", "bot-a");
+            await repo.startBilling("bot-1");
             await billing.setStorageTier("bot-1", "pro");
             await billing.suspendBot("bot-1");
             expect((await billing.getStorageTierCostsForTenant("tenant-1")).toCents()).toBe(0);
@@ -338,8 +367,11 @@ describe("BotBilling", () => {
     describe("listForTenant", () => {
         it("lists all bots regardless of billing state", async () => {
             await billing.registerBot("bot-1", "tenant-1", "bot-a");
+            await repo.startBilling("bot-1");
             await billing.registerBot("bot-2", "tenant-1", "bot-b");
+            await repo.startBilling("bot-2");
             await billing.registerBot("bot-3", "tenant-2", "bot-c");
+            await repo.startBilling("bot-3");
             await billing.suspendBot("bot-2");
             const bots = await billing.listForTenant("tenant-1");
             // biome-ignore lint/suspicious/noExplicitAny: intentional test cast
@@ -349,6 +381,7 @@ describe("BotBilling", () => {
     describe("full lifecycle", () => {
         it("active -> suspended -> reactivated -> active", async () => {
             await billing.registerBot("bot-1", "tenant-1", "my-bot");
+            await repo.startBilling("bot-1");
             // biome-ignore lint/suspicious/noExplicitAny: intentional test cast
             expect((await billing.getBotBilling("bot-1"))?.billingState).toBe("active");
             await billing.suspendBot("bot-1");
@@ -365,6 +398,7 @@ describe("BotBilling", () => {
         });
         it("active -> suspended -> destroyed (after grace period)", async () => {
             await billing.registerBot("bot-1", "tenant-1", "my-bot");
+            await repo.startBilling("bot-1");
             await billing.suspendBot("bot-1");
             await db.update(botInstances).set({ destroyAfter: sql `now() - interval '1 day'` }).where(sql `id = 'bot-1'`);
             await billing.destroyExpiredBots();

package/dist/monetization/credits/runtime-cron.d.ts

@@ -1,9 +1,17 @@
 import type { ILedger } from "@wopr-network/platform-core/credits";
 import { Credit } from "@wopr-network/platform-core/credits";
 import type { IBotInstanceRepository } from "../../fleet/bot-instance-repository.js";
+/** Monthly bot cost in dollars. */
+export declare const MONTHLY_BOT_COST_DOLLARS = 5;
 /**
- * Bot runtime cost: $5/bot/month prorated daily.
- * $5.00 / 30 ≈ $0.1667/day, rounded to $0.17.
+ * Compute the daily bot cost for a given date, prorated by the actual
+ * number of days in that month. Uses nano-dollar precision so totals
+ * sum to exactly $5.00/month (no over/under-billing).
+ */
+export declare function dailyBotCost(date: string): Credit;
+/**
+ * @deprecated Use dailyBotCost(date) for accurate per-month proration.
+ * Kept for backwards compat in tests.
  */
 export declare const DAILY_BOT_COST: Credit;
 /** Callback invoked when a tenant's balance hits zero during deduction. */

package/dist/monetization/credits/runtime-cron.js

@@ -1,9 +1,23 @@
 import { Credit, InsufficientBalanceError } from "@wopr-network/platform-core/credits";
 import { logger } from "../../config/logger.js";
 import { RESOURCE_TIERS } from "../../fleet/resource-tiers.js";
+/** Monthly bot cost in dollars. */
+export const MONTHLY_BOT_COST_DOLLARS = 5;
 /**
- * Bot runtime cost: $5/bot/month prorated daily.
- * $5.00 / 30 ≈ $0.1667/day, rounded to $0.17.
+ * Compute the daily bot cost for a given date, prorated by the actual
+ * number of days in that month. Uses nano-dollar precision so totals
+ * sum to exactly $5.00/month (no over/under-billing).
+ */
+export function dailyBotCost(date) {
+    const d = new Date(date);
+    const year = d.getFullYear();
+    const month = d.getMonth();
+    const daysInMonth = new Date(year, month + 1, 0).getDate();
+    return Credit.fromDollars(MONTHLY_BOT_COST_DOLLARS / daysInMonth);
+}
+/**
+ * @deprecated Use dailyBotCost(date) for accurate per-month proration.
+ * Kept for backwards compat in tests.
  */
 export const DAILY_BOT_COST = Credit.fromCents(17);
 /** Low balance threshold ($1.00 = 20% of signup grant). */
@@ -66,14 +80,15 @@ export async function runRuntimeDeductions(cfg) {
                     result.skipped.push(tenantId);
                 continue;
             }
-            const totalCost = DAILY_BOT_COST.multiply(botCount);
+            const dailyCost = dailyBotCost(cfg.date);
+            const totalCost = dailyCost.multiply(botCount);
             let didBillAnything = false;
             // Bill runtime debit (skipped if already billed on a previous run)
             if (!runtimeAlreadyBilled) {
                 if (!balance.lessThan(totalCost)) {
                     // Full deduction
                     await cfg.ledger.debit(tenantId, totalCost, "bot_runtime", {
-                        description: `Daily runtime: ${botCount} bot(s) x $${DAILY_BOT_COST.toDollars().toFixed(2)}`,
+                        description: `Daily runtime: ${botCount} bot(s) x $${dailyCost.toDollars().toFixed(4)}`,
                         referenceId: runtimeRef,
                     });
                 }

package/dist/monetization/credits/runtime-cron.test.js

@@ -2,9 +2,11 @@ import { Credit, DrizzleLedger, InsufficientBalanceError } from "@wopr-network/p
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 import { RESOURCE_TIERS } from "../../fleet/resource-tiers.js";
 import { createTestDb, truncateAllTables } from "../../test/db.js";
-import { buildResourceTierCosts, DAILY_BOT_COST, runRuntimeDeductions } from "./runtime-cron.js";
+import { buildResourceTierCosts, DAILY_BOT_COST, dailyBotCost, runRuntimeDeductions } from "./runtime-cron.js";
 describe("runRuntimeDeductions", () => {
     const TODAY = "2025-01-01";
+    /** Dynamic daily cost for TODAY's month (January = 31 days) */
+    const COST = dailyBotCost(TODAY);
     let pool;
     let ledger;
     beforeAll(async () => {
@@ -20,7 +22,7 @@ describe("runRuntimeDeductions", () => {
         await ledger.seedSystemAccounts();
     });
     it("DAILY_BOT_COST equals 17 cents", () => {
-        expect(DAILY_BOT_COST.toCents()).toBe(17);
+        expect(DAILY_BOT_COST.toCentsRounded()).toBe(17);
     });
     it("returns empty result when no tenants have balance", async () => {
         const result = await runRuntimeDeductions({
@@ -51,7 +53,7 @@ describe("runRuntimeDeductions", () => {
         });
         expect(result.processed).toBe(1);
         expect(result.suspended).toEqual([]);
-        expect((await ledger.balance("tenant-1")).toCents()).toBe(500 - 2 * 17);
+        expect((await ledger.balance("tenant-1")).toCentsRounded()).toBe(Credit.fromCents(500).subtract(COST.multiply(2)).toCentsRounded());
     });
     it("partial deduction and suspension when balance is insufficient", async () => {
         await ledger.credit("tenant-1", Credit.fromCents(10), "purchase", { description: "top-up" });
@@ -120,7 +122,7 @@ describe("runRuntimeDeductions", () => {
     });
     it("catches InsufficientBalanceError from debit and suspends", async () => {
         await ledger.credit("tenant-1", Credit.fromCents(500), "purchase", { description: "top-up" });
-        vi.spyOn(ledger, "debit").mockRejectedValue(new InsufficientBalanceError(Credit.fromCents(0), Credit.fromCents(17)));
+        vi.spyOn(ledger, "debit").mockRejectedValue(new InsufficientBalanceError(Credit.fromCents(0), COST));
         const onSuspend = vi.fn();
         const result = await runRuntimeDeductions({
             ledger,
@@ -135,7 +137,7 @@ describe("runRuntimeDeductions", () => {
     });
     it("catches InsufficientBalanceError without onSuspend callback", async () => {
         await ledger.credit("tenant-1", Credit.fromCents(500), "purchase", { description: "top-up" });
-        vi.spyOn(ledger, "debit").mockRejectedValue(new InsufficientBalanceError(Credit.fromCents(0), Credit.fromCents(17)));
+        vi.spyOn(ledger, "debit").mockRejectedValue(new InsufficientBalanceError(Credit.fromCents(0), COST));
         const result = await runRuntimeDeductions({
             ledger,
             date: TODAY,
@@ -171,7 +173,7 @@ describe("runRuntimeDeductions", () => {
         expect(onLowBalance).toHaveBeenCalledOnce();
         const [calledTenant, calledBalance] = onLowBalance.mock.calls[0];
         expect(calledTenant).toBe("tenant-1");
-        expect(calledBalance.toCents()).toBe(93);
+        expect(calledBalance.toCentsRounded()).toBe(Credit.fromCents(110).subtract(COST).toCentsRounded());
     });
     it("does NOT fire onLowBalance when balance was already below threshold before deduction", async () => {
         await ledger.credit("tenant-1", Credit.fromCents(90), "purchase", { description: "top-up" });
@@ -185,7 +187,7 @@ describe("runRuntimeDeductions", () => {
         expect(onLowBalance).not.toHaveBeenCalled();
     });
     it("fires onCreditsExhausted when full deduction causes balance to drop to 0", async () => {
-        await ledger.credit("tenant-1", Credit.fromCents(17), "purchase", { description: "top-up" });
+        await ledger.credit("tenant-1", COST, "purchase", { description: "top-up" });
         const onCreditsExhausted = vi.fn();
         await runRuntimeDeductions({
             ledger,
@@ -197,8 +199,8 @@ describe("runRuntimeDeductions", () => {
         expect((await ledger.balance("tenant-1")).toCents()).toBe(0);
     });
     it("suspends tenant when full deduction causes balance to drop to exactly 0", async () => {
-        // Balance = exactly 1 bot * DAILY_BOT_COST = 17 cents → full deduction → 0
-        await ledger.credit("tenant-1", Credit.fromCents(17), "purchase", { description: "top-up" });
+        // Balance = exactly 1 bot * dailyBotCost → full deduction → 0
+        await ledger.credit("tenant-1", COST, "purchase", { description: "top-up" });
         const onSuspend = vi.fn();
         const onCreditsExhausted = vi.fn();
         const result = await runRuntimeDeductions({
@@ -237,7 +239,7 @@ describe("runRuntimeDeductions", () => {
         expect((await ledger.balance("tenant-1")).toCents()).toBe(0);
     });
     it("skips resource tier partial debit when balance is exactly 0 after runtime", async () => {
-        await ledger.credit("tenant-1", Credit.fromCents(17), "purchase", { description: "top-up" });
+        await ledger.credit("tenant-1", COST, "purchase", { description: "top-up" });
         const onCreditsExhausted = vi.fn();
         const result = await runRuntimeDeductions({
             ledger,
@@ -255,7 +257,7 @@ describe("runRuntimeDeductions", () => {
         // triggering the zero-crossing suspend in the runtime block.
         // Storage cost (5 cents) then tries to suspend again via its else-branch (balance 0 < 5).
         // The !result.suspended.includes(tenantId) guard must prevent onSuspend being called twice.
-        await ledger.credit("tenant-1", Credit.fromCents(17), "purchase", { description: "top-up" });
+        await ledger.credit("tenant-1", COST, "purchase", { description: "top-up" });
         const onSuspend = vi.fn();
         const result = await runRuntimeDeductions({
             ledger,
@@ -269,9 +271,9 @@ describe("runRuntimeDeductions", () => {
         expect(onSuspend).toHaveBeenCalledTimes(1);
     });
     it("buildResourceTierCosts: deducts pro tier surcharge via getResourceTierCosts", async () => {
-        const proTierCost = RESOURCE_TIERS.pro.dailyCost.toCents();
-        const startBalance = 17 + proTierCost + 10;
-        await ledger.credit("tenant-1", Credit.fromCents(startBalance), "purchase", { description: "top-up" });
+        const proTierCost = RESOURCE_TIERS.pro.dailyCost;
+        const startCredit = COST.add(proTierCost).add(Credit.fromCents(10));
+        await ledger.credit("tenant-1", startCredit, "purchase", { description: "top-up" });
         const mockRepo = {
             getResourceTier: async (_botId) => "pro",
         };
@@ -282,8 +284,7 @@ describe("runRuntimeDeductions", () => {
             getActiveBotCount: async () => 1,
             getResourceTierCosts,
         });
-        const expected = startBalance - 17 - proTierCost;
-        expect((await ledger.balance("tenant-1")).toCents()).toBe(expected);
+        expect((await ledger.balance("tenant-1")).toCentsRounded()).toBe(10);
     });
     it("treats unique constraint violation from concurrent debit as already-billed (skip, not error)", async () => {
         await ledger.credit("tenant-1", Credit.fromCents(500), "purchase", { description: "top-up" });
@@ -300,26 +301,31 @@ describe("runRuntimeDeductions", () => {
     });
     it("is idempotent — second run on same date does not double-deduct", async () => {
         await ledger.credit("tenant-1", Credit.fromCents(500), "purchase", { description: "top-up" });
+        const JUNE_DATE = "2025-06-15";
+        const JUNE_COST = dailyBotCost(JUNE_DATE);
+        const expectedBalance = Credit.fromCents(500).subtract(JUNE_COST);
         const cfg = {
             ledger,
             getActiveBotCount: async () => 1,
-            date: "2025-06-15",
+            date: JUNE_DATE,
         };
         const first = await runRuntimeDeductions(cfg);
         expect(first.processed).toBe(1);
-        expect((await ledger.balance("tenant-1")).toCents()).toBe(500 - 17);
+        expect((await ledger.balance("tenant-1")).toCentsRounded()).toBe(expectedBalance.toCentsRounded());
         const second = await runRuntimeDeductions(cfg);
         expect(second.processed).toBe(0);
         expect(second.skipped).toContain("tenant-1");
         // Balance unchanged after second run
-        expect((await ledger.balance("tenant-1")).toCents()).toBe(500 - 17);
+        expect((await ledger.balance("tenant-1")).toCentsRounded()).toBe(expectedBalance.toCentsRounded());
     });
     it("bills surcharges on retry when runtime was already billed (crash recovery)", async () => {
         // Setup: tenant with enough balance for runtime + tier + storage + addon
         await ledger.credit("tenant-1", Credit.fromCents(1000), "purchase", { description: "top-up" });
+        const JUL_DATE = "2025-07-01";
+        const JUL_COST = dailyBotCost(JUL_DATE);
         const cfg = {
             ledger,
-            date: "2025-07-01",
+            date: JUL_DATE,
             getActiveBotCount: async () => 1,
             getResourceTierCosts: async () => Credit.fromCents(10),
             getStorageTierCosts: async () => Credit.fromCents(8),
@@ -328,23 +334,28 @@ describe("runRuntimeDeductions", () => {
         // First run — bills everything
         const first = await runRuntimeDeductions(cfg);
         expect(first.processed).toBe(1);
-        // 1000 - 17 (runtime) - 10 (tier) - 8 (storage) - 5 (addon) = 960
-        expect((await ledger.balance("tenant-1")).toCents()).toBe(960);
+        const expectedAfterFirst = Credit.fromCents(1000)
+            .subtract(JUL_COST)
+            .subtract(Credit.fromCents(10))
+            .subtract(Credit.fromCents(8))
+            .subtract(Credit.fromCents(5));
+        expect((await ledger.balance("tenant-1")).toCentsRounded()).toBe(expectedAfterFirst.toCentsRounded());
         // Second run — all already billed, should skip
         const second = await runRuntimeDeductions(cfg);
         expect(second.skipped).toContain("tenant-1");
         expect(second.processed).toBe(0);
-        expect((await ledger.balance("tenant-1")).toCents()).toBe(960);
+        expect((await ledger.balance("tenant-1")).toCentsRounded()).toBe(expectedAfterFirst.toCentsRounded());
     });
     it("bills remaining surcharges when runtime was billed but surcharges were not (simulated crash)", async () => {
         // Setup: tenant with enough balance
         await ledger.credit("tenant-1", Credit.fromCents(1000), "purchase", { description: "top-up" });
         // Simulate crash: manually debit only the runtime charge (as if the cron crashed after this)
-        await ledger.debit("tenant-1", DAILY_BOT_COST, "bot_runtime", {
-            description: "Daily runtime: 1 bot(s) x $0.17",
+        await ledger.debit("tenant-1", COST, "bot_runtime", {
+            description: `Daily runtime: 1 bot(s) x $${COST.toDollars().toFixed(4)}`,
             referenceId: `runtime:2025-07-02:tenant-1`,
         });
-        expect((await ledger.balance("tenant-1")).toCents()).toBe(983); // 1000 - 17
+        const afterRuntime = Credit.fromCents(1000).subtract(COST);
+        expect((await ledger.balance("tenant-1")).toCentsRounded()).toBe(afterRuntime.toCentsRounded());
         // Retry run — runtime already billed, but surcharges should still be billed
         const result = await runRuntimeDeductions({
             ledger,
@@ -356,21 +367,25 @@ describe("runRuntimeDeductions", () => {
         });
         expect(result.processed).toBe(1);
         expect(result.skipped).not.toContain("tenant-1");
-        // 983 - 10 (tier) - 8 (storage) - 5 (addon) = 960
-        expect((await ledger.balance("tenant-1")).toCents()).toBe(960);
+        const expectedFinal = afterRuntime
+            .subtract(Credit.fromCents(10))
+            .subtract(Credit.fromCents(8))
+            .subtract(Credit.fromCents(5));
+        expect((await ledger.balance("tenant-1")).toCentsRounded()).toBe(expectedFinal.toCentsRounded());
     });
     it("bills only missing surcharges when some were already committed (simulated partial crash)", async () => {
         await ledger.credit("tenant-1", Credit.fromCents(1000), "purchase", { description: "top-up" });
         // Simulate: runtime + tier already billed, storage + addon not yet
-        await ledger.debit("tenant-1", DAILY_BOT_COST, "bot_runtime", {
-            description: "Daily runtime: 1 bot(s) x $0.17",
+        await ledger.debit("tenant-1", COST, "bot_runtime", {
+            description: `Daily runtime: 1 bot(s) x $${COST.toDollars().toFixed(4)}`,
             referenceId: `runtime:2025-07-03:tenant-1`,
         });
         await ledger.debit("tenant-1", Credit.fromCents(10), "resource_upgrade", {
             description: "Daily resource tier surcharge",
             referenceId: `runtime-tier:2025-07-03:tenant-1`,
         });
-        expect((await ledger.balance("tenant-1")).toCents()).toBe(973); // 1000 - 17 - 10
+        const afterRuntimeAndTier = Credit.fromCents(1000).subtract(COST).subtract(Credit.fromCents(10));
+        expect((await ledger.balance("tenant-1")).toCentsRounded()).toBe(afterRuntimeAndTier.toCentsRounded());
         const result = await runRuntimeDeductions({
             ledger,
             date: "2025-07-03",
@@ -380,8 +395,8 @@ describe("runRuntimeDeductions", () => {
             getAddonCosts: async () => Credit.fromCents(5),
         });
         expect(result.processed).toBe(1);
-        // 973 - 8 (storage) - 5 (addon) = 960
-        expect((await ledger.balance("tenant-1")).toCents()).toBe(960);
+        const expectedFinal = afterRuntimeAndTier.subtract(Credit.fromCents(8)).subtract(Credit.fromCents(5));
+        expect((await ledger.balance("tenant-1")).toCentsRounded()).toBe(expectedFinal.toCentsRounded());
     });
     it("does not double-debit runtime on retry after partial deduction + crash", async () => {
         await ledger.credit("tenant-1", Credit.fromCents(10), "purchase", { description: "top-up" });
@@ -405,7 +420,7 @@ describe("runRuntimeDeductions", () => {
     it("trial balance remains balanced after crash-recovery billing", async () => {
         await ledger.credit("tenant-1", Credit.fromCents(1000), "purchase", { description: "top-up" });
         // Simulate crash: only runtime billed
-        await ledger.debit("tenant-1", DAILY_BOT_COST, "bot_runtime", {
+        await ledger.debit("tenant-1", COST, "bot_runtime", {
             description: "Daily runtime: 1 bot(s) x $0.17",
             referenceId: `runtime:2025-07-05:tenant-1`,
         });