@wopr-network/platform-core 1.74.0 → 1.75.0

package/src/monetization/credits/bot-billing.test.ts

@@ -56,6 +56,7 @@ function createMockDeps(nodeId: string | null = "node-1") {
 describe("BotBilling", () => {
   let pool: PGlite;
   let db: DrizzleDb;
+  let repo: DrizzleBotInstanceRepository;
   let billing: BotBilling;
   let ledger: DrizzleLedger;
 
@@ -69,7 +70,8 @@ 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();
@@ -78,6 +80,7 @@ describe("BotBilling", () => {
   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
@@ -100,8 +103,11 @@ 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);
@@ -109,7 +115,9 @@ describe("BotBilling", () => {
 
     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);
@@ -117,6 +125,7 @@ describe("BotBilling", () => {
 
     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);
@@ -126,6 +135,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");
@@ -139,6 +149,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");
@@ -155,8 +166,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");
 
@@ -174,6 +188,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");
 
@@ -188,6 +203,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");
 
@@ -198,6 +214,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");
@@ -209,7 +226,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");
 
@@ -226,6 +245,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);
@@ -235,6 +255,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", {
@@ -261,6 +282,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");
@@ -272,6 +294,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
@@ -293,6 +316,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();
@@ -305,6 +329,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([]);
@@ -386,8 +411,10 @@ 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);
@@ -395,6 +422,7 @@ describe("BotBilling", () => {
 
     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'`);
 
@@ -404,6 +432,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");
 
@@ -414,8 +443,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");
@@ -427,6 +459,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")) as any)?.billingState).toBe("active");
 
@@ -446,6 +479,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'`);

package/src/monetization/credits/runtime-cron.test.ts

@@ -3,10 +3,12 @@ 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: PGlite;
   let ledger: DrizzleLedger;
 
@@ -26,7 +28,7 @@ describe("runRuntimeDeductions", () => {
   });
 
   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 () => {
@@ -60,7 +62,9 @@ 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 () => {
@@ -136,9 +140,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,
@@ -154,9 +156,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,
@@ -194,7 +194,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 () => {
@@ -210,7 +210,7 @@ describe("runRuntimeDeductions", () => {
   });
 
   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,
@@ -223,8 +223,8 @@ describe("runRuntimeDeductions", () => {
   });
 
   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({
@@ -266,7 +266,7 @@ describe("runRuntimeDeductions", () => {
   });
 
   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,
@@ -285,7 +285,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,
@@ -300,9 +300,9 @@ describe("runRuntimeDeductions", () => {
   });
 
   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: string): Promise<string | null> => "pro",
@@ -320,8 +320,7 @@ describe("runRuntimeDeductions", () => {
       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 () => {
@@ -340,30 +339,35 @@ 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),
@@ -373,14 +377,18 @@ 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 () => {
@@ -388,11 +396,12 @@ describe("runRuntimeDeductions", () => {
     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({
@@ -406,23 +415,27 @@ 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,
@@ -434,8 +447,8 @@ describe("runRuntimeDeductions", () => {
     });
 
     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 () => {
@@ -465,7 +478,7 @@ describe("runRuntimeDeductions", () => {
     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`,
     });

package/src/monetization/credits/runtime-cron.ts

@@ -4,9 +4,25 @@ import { logger } from "../../config/logger.js";
 import type { IBotInstanceRepository } from "../../fleet/bot-instance-repository.js";
 import { RESOURCE_TIERS } from "../../fleet/resource-tiers.js";
 
+/** Monthly bot cost in dollars. */
+export const MONTHLY_BOT_COST_DOLLARS = 5;
+
+/**
+ * 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: string): Credit {
+  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);
+}
+
 /**
- * Bot runtime cost: $5/bot/month prorated daily.
- * $5.00 / 30 ≈ $0.1667/day, rounded to $0.17.
+ * @deprecated Use dailyBotCost(date) for accurate per-month proration.
+ * Kept for backwards compat in tests.
  */
 export const DAILY_BOT_COST = Credit.fromCents(17);
 
@@ -118,7 +134,8 @@ export async function runRuntimeDeductions(cfg: RuntimeCronConfig): Promise<Runt
         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)
@@ -126,7 +143,7 @@ export async function runRuntimeDeductions(cfg: RuntimeCronConfig): Promise<Runt
         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,
           });
         } else {

package/src/monetization/credits/storage-tier-billing.test.ts

@@ -8,6 +8,7 @@ import { DrizzleBotBilling } from "./bot-billing.js";
 describe("bot-billing storage tier", () => {
   let pool: PGlite;
   let db: DrizzleDb;
+  let repo: DrizzleBotInstanceRepository;
   let billing: DrizzleBotBilling;
 
   beforeAll(async () => {
@@ -22,16 +23,19 @@ describe("bot-billing storage tier", () => {
 
   beforeEach(async () => {
     await rollbackTestTransaction(pool);
-    billing = new DrizzleBotBilling(new DrizzleBotInstanceRepository(db));
+    repo = new DrizzleBotInstanceRepository(db);
+    billing = new DrizzleBotBilling(repo);
   });
 
   it("new bot defaults to standard storage tier", async () => {
     await billing.registerBot("bot-1", "tenant-1", "TestBot");
+    await repo.startBilling("bot-1");
     expect(await billing.getStorageTier("bot-1")).toBe("standard");
   });
 
   it("setStorageTier updates tier", async () => {
     await billing.registerBot("bot-1", "tenant-1", "TestBot");
+    await repo.startBilling("bot-1");
     await billing.setStorageTier("bot-1", "pro");
     expect(await billing.getStorageTier("bot-1")).toBe("pro");
   });
@@ -42,8 +46,11 @@ describe("bot-billing storage tier", () => {
 
   it("getStorageTierCostsForTenant sums active bot storage costs", async () => {
     await billing.registerBot("bot-1", "tenant-1", "Bot1");
+    await repo.startBilling("bot-1");
     await billing.registerBot("bot-2", "tenant-1", "Bot2");
+    await repo.startBilling("bot-2");
     await billing.registerBot("bot-3", "tenant-1", "Bot3");
+    await repo.startBilling("bot-3");
     await billing.setStorageTier("bot-1", "plus"); // 3 credits/day
     await billing.setStorageTier("bot-2", "max"); // 15 credits/day
     // bot-3 stays standard                        // 0 credits/day
@@ -52,6 +59,7 @@ describe("bot-billing storage tier", () => {
 
   it("getStorageTierCostsForTenant excludes suspended bots", async () => {
     await billing.registerBot("bot-1", "tenant-1", "Bot1");
+    await repo.startBilling("bot-1");
     await billing.setStorageTier("bot-1", "pro"); // 8 credits/day
     await billing.suspendBot("bot-1");
     expect((await billing.getStorageTierCostsForTenant("tenant-1")).toCents()).toBe(0);

package/src/monetization/credits/storage-tier-cron.test.ts

@@ -3,10 +3,11 @@ import { Credit, DrizzleLedger } from "@wopr-network/platform-core/credits";
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
 import type { DrizzleDb } from "../../db/index.js";
 import { createTestDb, truncateAllTables } from "../../test/db.js";
-import { runRuntimeDeductions } from "./runtime-cron.js";
+import { dailyBotCost, runRuntimeDeductions } from "./runtime-cron.js";
 
 describe("runtime cron with storage tiers", () => {
   const TODAY = "2025-01-01";
+  const BASE_COST_CREDIT = dailyBotCost(TODAY);
   let pool: PGlite;
   let db: DrizzleDb;
   let ledger: DrizzleLedger;
@@ -36,8 +37,9 @@ describe("runtime cron with storage tiers", () => {
     });
     expect(result.processed).toBe(1);
     const balance = await ledger.balance("t1");
-    // 1000 - 17 (base) - 8 (pro storage surcharge) = 975
-    expect(balance.toCents()).toBe(975);
+    // 1000 - dailyBotCost (base) - 8 (pro storage surcharge)
+    const expected = Credit.fromCents(1000).subtract(BASE_COST_CREDIT).subtract(Credit.fromCents(8));
+    expect(balance.toCents()).toBe(expected.toCents());
   });
 
   it("debits only base cost for standard storage tier (zero surcharge)", async () => {
@@ -49,7 +51,8 @@ describe("runtime cron with storage tiers", () => {
       getStorageTierCosts: async () => Credit.ZERO,
     });
     expect(result.processed).toBe(1);
-    expect((await ledger.balance("t1")).toCents()).toBe(983); // 1000 - 17
+    const expectedStd = Credit.fromCents(1000).subtract(BASE_COST_CREDIT);
+    expect((await ledger.balance("t1")).toCents()).toBe(expectedStd.toCents());
   });
 
   it("skips storage surcharge when callback not provided (backward compat)", async () => {
@@ -60,11 +63,14 @@ describe("runtime cron with storage tiers", () => {
       getActiveBotCount: async () => 1,
     });
     expect(result.processed).toBe(1);
-    expect((await ledger.balance("t1")).toCents()).toBe(983); // 1000 - 17
+    const expectedBackcompat = Credit.fromCents(1000).subtract(BASE_COST_CREDIT);
+    expect((await ledger.balance("t1")).toCents()).toBe(expectedBackcompat.toCents());
   });
 
   it("suspends tenant when storage surcharge exhausts remaining balance", async () => {
-    await ledger.credit("t1", Credit.fromCents(20), "purchase"); // Only 20 cents
+    // Seed just enough for base cost + 3 cents, so storage surcharge (8) exceeds remainder
+    const seed = BASE_COST_CREDIT.add(Credit.fromCents(3));
+    await ledger.credit("t1", seed, "purchase");
     const suspended: string[] = [];
     const result = await runRuntimeDeductions({
       ledger,
@@ -75,7 +81,7 @@ describe("runtime cron with storage tiers", () => {
         suspended.push(tenantId);
       },
     });
-    // 20 - 17 = 3 remaining, then 8 surcharge > 3, so partial debit + suspend
+    // seed - BASE_COST = 3 remaining, then 8 surcharge > 3, so partial debit + suspend
     expect(result.processed).toBe(1);
     expect(result.suspended).toContain("t1");
     expect((await ledger.balance("t1")).toCents()).toBe(0);

package/src/server/__tests__/container.test.ts

@@ -169,6 +169,8 @@ describe("createTestContainer", () => {
 
     const gateway: GatewayServices = {
       serviceKeyRepo: {} as never,
+      meter: {} as never,
+      budgetChecker: {} as never,
     };
 
     const hotPool: HotPoolServices = {
@@ -189,7 +191,9 @@ describe("createTestContainer", () => {
   });
 
   it("overrides merge without affecting other defaults", () => {
-    const c = createTestContainer({ gateway: { serviceKeyRepo: {} as never } });
+    const c = createTestContainer({
+      gateway: { serviceKeyRepo: {} as never, meter: {} as never, budgetChecker: {} as never },
+    });
 
     // Overridden field
     expect(c.gateway).not.toBeNull();