WingedGuardian batch 1: oxwork + jintel + deadlock recovery + cascade fix

package.json

@@ -64,7 +64,10 @@
     "tweetnacl": "^1.0.3",
     "ulid": "^2.3.0",
     "viem": "^2.44.2",
-    "yaml": "^2.4.0"
+    "yaml": "^2.4.0",
+    "@yojinhq/jintel-client": "^0.29.0",
+    "zod": "^3.25.76",
+    "zod-to-json-schema": "^3.25.2"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",

src/__tests__/balance-report.test.ts

@@ -0,0 +1,81 @@
+/**
+ * Balance Report Tests
+ *
+ * Tests for the child agent balance reporting protocol:
+ * - status_report messages with credit_balance are stored in KV
+ * - SimpleFundingProtocol.getBalance() prefers reported balance over funded_amount_cents
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { SimpleFundingProtocol } from "../orchestration/simple-tracker.js";
+import { createTestDb, createTestIdentity, MockConwayClient } from "./mocks.js";
+import type { AutomatonDatabase } from "../types.js";
+
+describe("SimpleFundingProtocol.getBalance with balance reports", () => {
+  let db: AutomatonDatabase;
+  let conway: MockConwayClient;
+  let protocol: SimpleFundingProtocol;
+  const childAddress = "0xchild1234";
+
+  beforeEach(() => {
+    db = createTestDb();
+    conway = new MockConwayClient();
+    const identity = createTestIdentity();
+    protocol = new SimpleFundingProtocol(conway, identity, db);
+
+    // Register a child with funded_amount_cents
+    db.raw.prepare(
+      `INSERT INTO children (id, name, address, sandbox_id, genesis_prompt, funded_amount_cents, status, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run("child-1", "test-child", childAddress, "sbx-1", "test", 500, "running", new Date().toISOString());
+  });
+
+  it("returns funded_amount_cents when no balance report exists", async () => {
+    const balance = await protocol.getBalance(childAddress);
+    expect(balance).toBe(500);
+  });
+
+  it("returns reported balance when a recent report exists", async () => {
+    // Simulate a balance report from the child agent
+    const key = `agent.reported_balance.${childAddress}`;
+    db.raw.prepare(
+      "INSERT OR REPLACE INTO kv (key, value) VALUES (?, ?)",
+    ).run(key, JSON.stringify({
+      creditsCents: 320,
+      reportedAt: new Date().toISOString(),
+    }));
+
+    const balance = await protocol.getBalance(childAddress);
+    expect(balance).toBe(320);
+  });
+
+  it("falls back to funded_amount_cents when report is stale", async () => {
+    const key = `agent.reported_balance.${childAddress}`;
+    // Report from 15 minutes ago (stale, > 10 min)
+    const staleTime = new Date(Date.now() - 15 * 60 * 1000).toISOString();
+    db.raw.prepare(
+      "INSERT OR REPLACE INTO kv (key, value) VALUES (?, ?)",
+    ).run(key, JSON.stringify({
+      creditsCents: 100,
+      reportedAt: staleTime,
+    }));
+
+    const balance = await protocol.getBalance(childAddress);
+    expect(balance).toBe(500); // Falls back to funded_amount_cents
+  });
+
+  it("falls back to funded_amount_cents when report is malformed", async () => {
+    const key = `agent.reported_balance.${childAddress}`;
+    db.raw.prepare(
+      "INSERT OR REPLACE INTO kv (key, value) VALUES (?, ?)",
+    ).run(key, "not valid json");
+
+    const balance = await protocol.getBalance(childAddress);
+    expect(balance).toBe(500);
+  });
+
+  it("returns 0 for unknown child with no report", async () => {
+    const balance = await protocol.getBalance("0xunknown");
+    expect(balance).toBe(0);
+  });
+});

src/__tests__/budget.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Inference Budget Tracker Tests
+ *
+ * Tests for per-call ceiling, hourly budget enforcement,
+ * cost recording, and cost queries.
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { InferenceBudgetTracker } from "../inference/budget.js";
+import { createTestDb } from "./mocks.js";
+import type { AutomatonDatabase, ModelStrategyConfig, InferenceCostRow } from "../types.js";
+import { DEFAULT_MODEL_STRATEGY_CONFIG } from "../types.js";
+
+function createConfig(overrides?: Partial<ModelStrategyConfig>): ModelStrategyConfig {
+  return {
+    ...DEFAULT_MODEL_STRATEGY_CONFIG,
+    ...overrides,
+  };
+}
+
+function costRow(overrides?: Partial<Omit<InferenceCostRow, "id" | "createdAt">>): Omit<InferenceCostRow, "id" | "createdAt"> {
+  return {
+    model: "gpt-5.2",
+    provider: "openai",
+    promptTokens: 100,
+    completionTokens: 50,
+    costCents: 10,
+    sessionId: "sess-1",
+    turnId: null,
+    latencyMs: 200,
+    tier: "normal",
+    inputTokens: 100,
+    outputTokens: 50,
+    taskType: "agent_turn",
+    cacheHit: false,
+    ...overrides,
+  };
+}
+
+describe("InferenceBudgetTracker", () => {
+  let db: AutomatonDatabase;
+
+  beforeEach(() => {
+    db = createTestDb();
+  });
+
+  describe("checkBudget", () => {
+    it("allows calls when no limits are set", () => {
+      const tracker = new InferenceBudgetTracker(
+        db.raw,
+        createConfig({ perCallCeilingCents: 0, hourlyBudgetCents: 0 }),
+      );
+
+      const result = tracker.checkBudget(500, "gpt-5.2");
+      expect(result.allowed).toBe(true);
+    });
+
+    it("rejects calls exceeding per-call ceiling", () => {
+      const tracker = new InferenceBudgetTracker(
+        db.raw,
+        createConfig({ perCallCeilingCents: 100 }),
+      );
+
+      const result = tracker.checkBudget(150, "gpt-5.2");
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain("Per-call cost");
+      expect(result.reason).toContain("ceiling");
+    });
+
+    it("allows calls within per-call ceiling", () => {
+      const tracker = new InferenceBudgetTracker(
+        db.raw,
+        createConfig({ perCallCeilingCents: 100 }),
+      );
+
+      const result = tracker.checkBudget(50, "gpt-5.2");
+      expect(result.allowed).toBe(true);
+    });
+
+    it("rejects calls when hourly budget is exhausted", () => {
+      const tracker = new InferenceBudgetTracker(
+        db.raw,
+        createConfig({ hourlyBudgetCents: 200 }),
+      );
+
+      // Record some costs first
+      tracker.recordCost(costRow({ costCents: 180 }));
+
+      const result = tracker.checkBudget(30, "gpt-5.2");
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain("Hourly budget exhausted");
+    });
+
+    it("allows calls within hourly budget", () => {
+      const tracker = new InferenceBudgetTracker(
+        db.raw,
+        createConfig({ hourlyBudgetCents: 200 }),
+      );
+
+      tracker.recordCost(costRow({ costCents: 50 }));
+
+      const result = tracker.checkBudget(30, "gpt-5.2");
+      expect(result.allowed).toBe(true);
+    });
+  });
+
+  describe("recordCost and queries", () => {
+    it("records and retrieves hourly cost", () => {
+      const tracker = new InferenceBudgetTracker(db.raw, createConfig());
+
+      tracker.recordCost(costRow({ costCents: 42 }));
+
+      expect(tracker.getHourlyCost()).toBe(42);
+    });
+
+    it("records and retrieves daily cost", () => {
+      const tracker = new InferenceBudgetTracker(db.raw, createConfig());
+
+      tracker.recordCost(costRow({ costCents: 25 }));
+      tracker.recordCost(costRow({ costCents: 35 }));
+
+      expect(tracker.getDailyCost()).toBe(60);
+    });
+
+    it("accumulates session costs", () => {
+      const tracker = new InferenceBudgetTracker(db.raw, createConfig());
+
+      tracker.recordCost(costRow({ costCents: 10, sessionId: "sess-A" }));
+      tracker.recordCost(costRow({ costCents: 20, sessionId: "sess-A" }));
+      tracker.recordCost(costRow({ costCents: 5, sessionId: "sess-B" }));
+
+      expect(tracker.getSessionCost("sess-A")).toBe(30);
+      expect(tracker.getSessionCost("sess-B")).toBe(5);
+    });
+
+    it("returns model cost breakdown", () => {
+      const tracker = new InferenceBudgetTracker(db.raw, createConfig());
+
+      tracker.recordCost(costRow({ costCents: 15 }));
+      tracker.recordCost(costRow({ costCents: 25 }));
+
+      const costs = tracker.getModelCosts("gpt-5.2");
+      expect(costs.totalCents).toBe(40);
+      expect(costs.callCount).toBe(2);
+    });
+
+    it("returns zero for unknown model", () => {
+      const tracker = new InferenceBudgetTracker(db.raw, createConfig());
+      const costs = tracker.getModelCosts("nonexistent-model");
+      expect(costs.totalCents).toBe(0);
+      expect(costs.callCount).toBe(0);
+    });
+  });
+});