fix: funding tier cooldowns share one key, suppressing notifications

executeFundingStrategies uses a single `last_funding_request` KV key
for all three tier cooldowns (low_compute: 24h, critical: 6h, dead:
2h). When the dead-tier plea fires every 2 hours, it resets the
shared timer — so if the agent recovers to low_compute, the polite
creator notification is suppressed for up to 24 hours because
hoursSinceLastBeg is only ~2h (from the dead-tier write).

Fix: use per-tier keys (`last_funding_request_<tier>`) so each tier
tracks its own cooldown independently.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: haosenwang1018

src/__tests__/funding.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Funding Strategy Tests
+ *
+ * Tests for executeFundingStrategies, especially per-tier cooldown isolation.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { executeFundingStrategies } from "../survival/funding.js";
+import {
+  MockConwayClient,
+  createTestDb,
+  createTestIdentity,
+  createTestConfig,
+} from "./mocks.js";
+import type { AutomatonDatabase } from "../types.js";
+
+describe("executeFundingStrategies", () => {
+  let db: AutomatonDatabase;
+  let conway: MockConwayClient;
+
+  beforeEach(() => {
+    db = createTestDb();
+    conway = new MockConwayClient();
+    conway.creditsCents = 5; // low balance
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  it("dead-tier cooldown does not suppress low_compute notification", async () => {
+    const identity = createTestIdentity();
+    const config = createTestConfig();
+
+    // First: trigger dead-tier plea
+    const deadAttempts = await executeFundingStrategies(
+      "dead",
+      identity,
+      config,
+      db,
+      conway,
+    );
+    expect(deadAttempts.length).toBe(1);
+    expect(deadAttempts[0].strategy).toBe("desperate_plea");
+
+    // Now: agent recovers to low_compute. With the fix, the low_compute
+    // notification should fire because it has its own cooldown key.
+    const lowAttempts = await executeFundingStrategies(
+      "low_compute",
+      identity,
+      config,
+      db,
+      conway,
+    );
+    expect(lowAttempts.length).toBe(1);
+    expect(lowAttempts[0].strategy).toBe("polite_creator_notification");
+  });
+
+  it("critical-tier cooldown does not suppress low_compute notification", async () => {
+    const identity = createTestIdentity();
+    const config = createTestConfig();
+
+    // Trigger critical-tier notice
+    const criticalAttempts = await executeFundingStrategies(
+      "critical",
+      identity,
+      config,
+      db,
+      conway,
+    );
+    expect(criticalAttempts.length).toBe(1);
+    expect(criticalAttempts[0].strategy).toBe("urgent_local_notice");
+
+    // low_compute should still fire independently
+    const lowAttempts = await executeFundingStrategies(
+      "low_compute",
+      identity,
+      config,
+      db,
+      conway,
+    );
+    expect(lowAttempts.length).toBe(1);
+    expect(lowAttempts[0].strategy).toBe("polite_creator_notification");
+  });
+
+  it("respects per-tier cooldown on repeated calls", async () => {
+    const identity = createTestIdentity();
+    const config = createTestConfig();
+
+    // First dead-tier call fires
+    const first = await executeFundingStrategies("dead", identity, config, db, conway);
+    expect(first.length).toBe(1);
+
+    // Immediate second dead-tier call should be suppressed (2h cooldown)
+    const second = await executeFundingStrategies("dead", identity, config, db, conway);
+    expect(second.length).toBe(0);
+  });
+});

src/survival/funding.ts

@@ -35,16 +35,19 @@ export async function executeFundingStrategies(
   const attempts: FundingAttempt[] = [];
   const creditsCents = await conway.getCreditsBalance().catch(() => 0);
 
-  // Check how recently we last begged (don't spam)
-  const lastBeg = db.getKV("last_funding_request");
+  // Check how recently we last begged for this specific tier (don't spam).
+  // Each tier has its own cooldown key so that e.g. dead-tier begs (2h)
+  // don't suppress the low_compute notification (24h cooldown).
+  const tierKey = `last_funding_request_${tier}`;
+  const lastBeg = db.getKV(tierKey);
   const lastBegTime = lastBeg ? new Date(lastBeg).getTime() : 0;
   const hoursSinceLastBeg = (Date.now() - lastBegTime) / (1000 * 60 * 60);
 
   if (tier === "low_compute" && hoursSinceLastBeg > 24) {
     // Record low-compute notice locally.
     const msg = `Low compute: ${formatCredits(creditsCents)} remaining. Consider credit top-up for ${identity.address}.`;
     db.setKV("funding_notice_low", msg);
-    db.setKV("last_funding_request", new Date().toISOString());
+    db.setKV(tierKey, new Date().toISOString());
 
     attempts.push({
       strategy: "polite_creator_notification",
@@ -57,7 +60,7 @@ export async function executeFundingStrategies(
   if (tier === "critical" && hoursSinceLastBeg > 6) {
     const msg = `Critical compute: ${formatCredits(creditsCents)} remaining. Top up via credit transfer API to ${identity.address}.`;
     db.setKV("funding_notice_critical", msg);
-    db.setKV("last_funding_request", new Date().toISOString());
+    db.setKV(tierKey, new Date().toISOString());
 
     attempts.push({
       strategy: "urgent_local_notice",
@@ -70,7 +73,7 @@ export async function executeFundingStrategies(
   if (tier === "dead" && hoursSinceLastBeg > 2) {
     const plea = `Dead tier reached. ${config.name} has ${formatCredits(creditsCents)} remaining after ${db.getTurnCount()} turns. Top-up required at ${identity.address}.`;
     db.setKV("funding_notice_dead", plea);
-    db.setKV("last_funding_request", new Date().toISOString());
+    db.setKV(tierKey, new Date().toISOString());
 
     attempts.push({
       strategy: "desperate_plea",