@tokenbuddy/tokenbuddy 1.0.11 → 1.0.13

package/tests/tokenbuddy.test.ts

@@ -2,6 +2,7 @@ import { TokenbuddyDaemon } from "../src/daemon.js";
 import { BuyerStore, resolveBuyerStorePath, type PaymentConfig } from "../src/buyer-store.js";
 import type { ProviderRuntimeConfig } from "../src/provider-install.js";
 import {
+  buildLaunchdPlistContent,
   buildCli,
   fetchClawtipBootstrap,
   normalizeClawtipBootstrapResourceUrl,
@@ -44,6 +45,7 @@ import * as fs from "fs";
 import http from "http";
 import { AddressInfo } from "net";
 import zlib from "zlib";
+import { resolveModuleLogFile } from "@tokenbuddy/logging";
 
 const TEMP_BUYER_DB = path.resolve(__dirname, "../../data-test/buyer-cache-test.db");
 const TEMP_STORE_ROOT = path.resolve(__dirname, "../../data-test/buyer-store-test");
@@ -69,7 +71,7 @@ describe("TokenBuddy CLI command surface", () => {
       .filter(command => command !== "help")
       .sort();
 
-    expect(commandNames).toEqual(["doctor", "init", "models", "payment"]);
+    expect(commandNames).toEqual(["doctor", "init", "models", "payment", "routing"]);
   });
 
   test("tb payment help only exposes list, add, and remove", () => {
@@ -106,6 +108,49 @@ describe("TokenBuddy CLI command surface", () => {
       "tb-proxyd": "./bin/tb-proxyd.js"
     });
   });
+
+  test("launchd plist pins tb-proxyd ports and seller registry", () => {
+    const plist = buildLaunchdPlistContent({
+      label: "com.tokenbuddy.proxyd",
+      nodePath: "/opt/homebrew/bin/node",
+      scriptPath: "/opt/homebrew/bin/tb-proxyd.js",
+      stdoutPath: "/Users/example/.tokenbuddy-store/tb-proxyd.stdout.log",
+      stderrPath: "/Users/example/.tokenbuddy-store/tb-proxyd.stderr.log",
+      controlPort: 17820,
+      proxyPort: 17821,
+      sellerRegistryUrl: "https://tb-wallet-bootstrap.fly.dev/registry/sellers",
+    });
+
+    expect(plist).toContain("<key>EnvironmentVariables</key>");
+    expect(plist).toContain("<key>TB_PROXYD_CONTROL_PORT</key>");
+    expect(plist).toContain("<string>17820</string>");
+    expect(plist).toContain("<key>TB_PROXYD_PROXY_PORT</key>");
+    expect(plist).toContain("<string>17821</string>");
+    expect(plist).toContain("<key>TB_PROXYD_SELLER_REGISTRY_URL</key>");
+    expect(plist).toContain("<string>https://tb-wallet-bootstrap.fly.dev/registry/sellers</string>");
+  });
+
+  test("launchd plist can inject the ClawTip proof provider without embedding proofs", () => {
+    const plist = buildLaunchdPlistContent({
+      label: "com.tokenbuddy.proxyd",
+      nodePath: "/opt/homebrew/bin/node",
+      scriptPath: "/opt/homebrew/bin/tb-proxyd.js",
+      stdoutPath: "/Users/example/.tokenbuddy-store/tb-proxyd.stdout.log",
+      stderrPath: "/Users/example/.tokenbuddy-store/tb-proxyd.stderr.log",
+      controlPort: 17820,
+      proxyPort: 17821,
+      sellerRegistryUrl: "https://tb-wallet-bootstrap.fly.dev/registry/sellers",
+      clawtipProofCommand: "/Users/example/bin/tokenbuddy-clawtip-proof-openclaw.sh",
+      clawtipProofTimeoutMs: 180000,
+    });
+
+    expect(plist).toContain("<key>TB_PROXYD_CLAWTIP_PROOF_COMMAND</key>");
+    expect(plist).toContain("<string>/Users/example/bin/tokenbuddy-clawtip-proof-openclaw.sh</string>");
+    expect(plist).toContain("<key>TB_PROXYD_CLAWTIP_PROOF_TIMEOUT_MS</key>");
+    expect(plist).toContain("<string>180000</string>");
+    expect(plist).not.toContain("payCredential");
+    expect(plist).not.toContain("PAYMENT_PROOF");
+  });
 });
 
 describe("BuyerStore safe SQLite persistence", () => {
@@ -198,7 +243,6 @@ describe("BuyerStore safe SQLite persistence", () => {
       selectionKind: "single-model",
       protocolPreference: "responses",
       defaultModel: "gpt-5.5",
-      sellerId: "seller-a",
     });
     store.saveDaemonRuntimeConfig("routing", {
       mode: "fixed",
@@ -209,7 +253,6 @@ describe("BuyerStore safe SQLite persistence", () => {
       providerId: "opencode",
       config: expect.objectContaining({
         defaultModel: "gpt-5.5",
-        sellerId: "seller-a",
       }),
     });
     expect(store.getDaemonRuntimeConfig("routing")).toMatchObject({
@@ -475,6 +518,87 @@ describe("TokenBuddy payment CLI", () => {
     expect(logs.join("\n")).toContain("Mock payment method registered");
     expect(logs.join("\n")).toContain("removed");
   });
+
+  test("routing set/show updates buyer routing config without requiring tb-proxyd", async () => {
+    await new Promise<void>((resolve) => controlServer.close(() => {
+      controlServerOpen = false;
+      resolve();
+    }));
+    const output: string[] = [];
+    jest.spyOn(console, "log").mockImplementation((message?: unknown) => {
+      output.push(String(message));
+    });
+
+    await buildCli().parseAsync([
+      "node",
+      "tb",
+      "routing",
+      "set",
+      "fixedSet",
+      "--seller-set",
+      "seller-a,seller-b",
+      "--scorer",
+      "speed"
+    ]);
+
+    const store = new BuyerStore({ root: CLI_STORE_ROOT });
+    expect(store.getDaemonRuntimeConfig("routing")).toMatchObject({
+      config: {
+        mode: "fixedSet",
+        sellerIds: ["seller-a", "seller-b"],
+        scorer: "speed"
+      }
+    });
+    store.close();
+
+    output.length = 0;
+    await buildCli().parseAsync(["node", "tb", "routing", "show", "--json"]);
+    const parsed = JSON.parse(output[0]) as any;
+    expect(parsed.routing).toEqual({
+      mode: "fixedSet",
+      sellerIds: ["seller-a", "seller-b"],
+      scorer: "speed"
+    });
+
+    await buildCli().parseAsync([
+      "node",
+      "tb",
+      "routing",
+      "set",
+      "fixed",
+      "--seller",
+      "seller-c",
+      "--scorer",
+      "discount"
+    ]);
+    let refreshed = new BuyerStore({ root: CLI_STORE_ROOT });
+    expect(refreshed.getDaemonRuntimeConfig("routing")).toMatchObject({
+      config: {
+        mode: "fixed",
+        sellerId: "seller-c",
+        scorer: "discount"
+      }
+    });
+    refreshed.close();
+
+    await buildCli().parseAsync([
+      "node",
+      "tb",
+      "routing",
+      "set",
+      "fullAuto",
+      "--scorer",
+      "balanced"
+    ]);
+    refreshed = new BuyerStore({ root: CLI_STORE_ROOT });
+    expect(refreshed.getDaemonRuntimeConfig("routing")).toMatchObject({
+      config: {
+        mode: "fullAuto",
+        scorer: "balanced"
+      }
+    });
+    refreshed.close();
+  });
 });
 
 describe("TokenBuddy init payment options", () => {
@@ -1485,6 +1609,19 @@ describe("Provider install planning", () => {
     ]));
   });
 
+  test("treats existing non-TokenBuddy OpenCode config as installed, not configured", () => {
+    const providers = detectProviders({ home: PROVIDER_HOME });
+
+    expect(providers).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        id: "opencode",
+        status: "installed",
+        configured: false,
+        executablePath: expect.stringContaining(path.join("provider-bin", "opencode")),
+      }),
+    ]));
+  });
+
   test("applies provider config and rolls back existing and created files", () => {
     const store = new BuyerStore({ root: PROVIDER_STORE_ROOT });
     try {
@@ -1496,7 +1633,6 @@ describe("Provider install planning", () => {
             selectionKind: "single-model",
             protocolPreference: "responses",
             defaultModel: "gpt-4",
-            sellerId: "seller-one",
           },
           "claude-code": {
             selectionKind: "claude-role-mapping",
@@ -1524,25 +1660,18 @@ describe("Provider install planning", () => {
             selectionKind: "single-model",
             protocolPreference: "chat_completions",
             defaultModel: "gpt-4",
-            sellerId: "seller-one",
           },
           opencode: {
             selectionKind: "single-model",
             protocolPreference: "responses",
             defaultModel: "gpt-4",
-            sellerId: "seller-one",
           },
           hermes: {
             selectionKind: "single-model",
             protocolPreference: "chat_completions",
             defaultModel: "gpt-4",
-            sellerId: "seller-one",
           },
         },
-        sellerRouting: {
-          mode: "fixed",
-          sellerId: "seller-one",
-        },
         home: PROVIDER_HOME
       }, store);
       expect(applied).toEqual(expect.arrayContaining([
@@ -1563,20 +1692,24 @@ describe("Provider install planning", () => {
       expect(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL).toBe("claude-haiku-4-5");
       expect(claude.env.ANTHROPIC_DEFAULT_SONNET_MODEL_NAME).toBe("MiniMax-M2.7-highspeed");
       expect(store.getProviderRuntimeConfig("claude-code")).toBeDefined();
-      expect(store.getDaemonRuntimeConfig("routing")).toMatchObject({
-        config: expect.objectContaining({
-          mode: "fixed",
-          sellerId: "seller-one",
-        }),
-      });
+      expect(store.getDaemonRuntimeConfig("routing")).toBeUndefined();
+      expect(store.getProviderRuntimeConfig("opencode")?.config).not.toHaveProperty("sellerId");
 
       const openclaw = JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".openclaw", "config.json"), "utf8"));
       expect(openclaw.keep).toBe("field");
       expect(openclaw.api_url).toBe(proxyUrl);
       const opencode = JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".config", "opencode", "opencode.json"), "utf8"));
       expect(opencode.share).toBe("disabled");
+      expect(JSON.stringify(opencode)).not.toContain("sellerId");
       expect(opencode.provider.tokenbuddy.options.baseURL).toBe(`${proxyUrl}/v1`);
       expect(opencode.provider.tokenbuddy.models["gpt-4"].name).toBe("gpt-4");
+      expect(detectProviders({ home: PROVIDER_HOME })).toEqual(expect.arrayContaining([
+        expect.objectContaining({
+          id: "opencode",
+          status: "configured",
+          configured: true,
+        }),
+      ]));
       expect(fs.existsSync(path.join(PROVIDER_HOME, ".hermes", "settings.json"))).toBe(true);
       expect(store.getProviderInstallSnapshot("codex")).toBeDefined();
 
@@ -1595,21 +1728,15 @@ describe("Provider install planning", () => {
       expect(fs.existsSync(path.join(PROVIDER_HOME, ".hermes", "settings.json"))).toBe(false);
       expect(store.getProviderInstallSnapshot("codex")).toBeUndefined();
       expect(store.getProviderRuntimeConfig("claude-code")).toBeUndefined();
-      expect(store.getDaemonRuntimeConfig("routing")).toBeUndefined();
     } finally {
       store.close();
     }
   });
 
-  test("opencode provider install uses @ai-sdk/openai-responses by default (Responses API)", () => {
-    // 锁住不变量：v1.0.10+ tb-proxy install opencode 必须默认走 Responses API 协议，
-    // 而不是 chat completions。原因：code.shoestravel.xin 等上游原生 SSE 事件链
-    // 才是 Responses API 风格（response.created / response.output_text.delta / response.completed），
-    // buyer 端 SseUsageExtractor 解析 usage 字段更稳定。改回 @ai-sdk/openai 需先
-    // 评估 5-seller 架构是否仍能端到端 work。
+  test("opencode provider install uses @ai-sdk/openai-compatible for chat completions", () => {
     const config: ProviderRuntimeConfig = {
       selectionKind: "single-model",
-      protocolPreference: "responses",
+      protocolPreference: "chat_completions",
       defaultModel: "gpt-5.4",
     };
     const changes = previewProviderInstall({
@@ -1622,7 +1749,7 @@ describe("Provider install planning", () => {
     expect(change).toBeDefined();
     expect(change?.content).toBeDefined();
     const parsed = JSON.parse(change!.content!);
-    expect(parsed.provider.tokenbuddy.npm).toBe("@ai-sdk/openai-responses");
+    expect(parsed.provider.tokenbuddy.npm).toBe("@ai-sdk/openai-compatible");
     expect(parsed.model).toBe("tokenbuddy/gpt-5.4");
     expect(parsed.provider.tokenbuddy.options.baseURL).toBe("http://127.0.0.1:17821/v1");
   });
@@ -1801,6 +1928,12 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
         if (body.stream) {
           res.writeHead(200, { "Content-Type": "text/event-stream" });
           res.write("data: {\"id\":\"chatcmpl-stream\",\"choices\":[{\"delta\":{\"content\":\"hello\"}}]}\n\n");
+          if (body.requestId === "stream_req_slow_after_headers") {
+            await new Promise((resolve) => setTimeout(resolve, 120));
+            res.write("data: {\"id\":\"chatcmpl-stream\",\"choices\":[{\"delta\":{\"content\":\" later\"}}]}\n\n");
+            res.end("data: [DONE]\n\n");
+            return;
+          }
           res.write("event: tokenbuddy.settlement\n");
           res.write(`data: ${JSON.stringify({
             requestId: body.requestId || "stream_req_mock",
@@ -2282,6 +2415,8 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
     const body = await response.text();
     expect(body).toContain("chatcmpl-stream");
     expect(body).toContain("[DONE]");
+    expect(body).not.toContain("}data:");
+    expect(body).toContain("}\n\ndata: [DONE]");
     expect(body).not.toContain("tokenbuddy.settlement");
     expect(sellerRequests.find((request) => request.url === "/v1/chat/completions" && request.body?.stream)?.idempotencyKey).toBe("idem-stream-preserved");
 
@@ -2302,6 +2437,35 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
     expect(publicOutput).not.toContain("chatcmpl-stream");
   });
 
+  test("does not abort an active SSE stream after seller response headers arrive", async () => {
+    const previousDeadline = process.env.TB_PROXYD_REQUEST_DEADLINE_MS;
+    process.env.TB_PROXYD_REQUEST_DEADLINE_MS = "50";
+    try {
+      const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model: "gpt-4",
+          stream: true,
+          messages: [{ role: "user", content: "slow active stream" }],
+          requestId: "stream_req_slow_after_headers"
+        })
+      });
+
+      expect(response.ok).toBe(true);
+      const body = await response.text();
+      expect(body).toContain("hello");
+      expect(body).toContain(" later");
+      expect(body).toContain("[DONE]");
+    } finally {
+      if (previousDeadline === undefined) {
+        delete process.env.TB_PROXYD_REQUEST_DEADLINE_MS;
+      } else {
+        process.env.TB_PROXYD_REQUEST_DEADLINE_MS = previousDeadline;
+      }
+    }
+  });
+
   test("passes through responses SSE bytes unchanged for OpenAI Responses API clients", async () => {
     const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/responses`, {
       method: "POST",
@@ -2345,13 +2509,15 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
   });
 });
 
-describe("TokenBuddy manual routing mode", () => {
+describe("TokenBuddy seller routing strategies", () => {
   let server: http.Server;
   let sellerPort: number;
   let daemon: TokenbuddyDaemon;
   let daemonProxyPort: number;
   let daemonControlPort: number;
   const events: Array<{ seller: string; url?: string }> = [];
+  let primaryPurchaseSucceeds = false;
+  let primaryInferenceFails = false;
   const dbPath = path.resolve(__dirname, "../../data-test/manual-routing-test.db");
 
   const readJsonBody = (req: http.IncomingMessage): Promise<any> => new Promise((resolve) => {
@@ -2419,11 +2585,48 @@ describe("TokenBuddy manual routing mode", () => {
       if (req.url === "/primary/purchase/create") {
         expect(body.paymentMethod).toBe("mock");
         events.push({ seller: "primary-seller", url: req.url });
+        if (primaryPurchaseSucceeds) {
+          res.end(JSON.stringify({
+            purchaseId: "pur_primary_123",
+            status: "pending",
+            creditMicros: 2000000,
+            currency: "USD",
+            expiresAt: new Date(Date.now() + 86400 * 1000).toISOString()
+          }));
+          return;
+        }
         res.statusCode = 503;
         res.end(JSON.stringify({ error: { code: "seller_unavailable" } }));
         return;
       }
 
+      if (req.url === "/primary/purchase/complete") {
+        events.push({ seller: "primary-seller", url: req.url });
+        res.end(JSON.stringify({
+          purchaseId: "pur_primary_123",
+          status: "active",
+          accessToken: "tok_primary_token_abc",
+          tokenClass: "model:gpt-manual",
+          creditMicros: 2000000,
+          currency: "USD"
+        }));
+        return;
+      }
+
+      if (req.url === "/primary/v1/chat/completions") {
+        events.push({ seller: "primary-seller", url: req.url });
+        if (primaryInferenceFails) {
+          res.statusCode = 500;
+          res.end(JSON.stringify({ error: { code: "upstream_failed", message: "primary seller failed" } }));
+          return;
+        }
+        res.end(JSON.stringify({
+          id: "primary-chat",
+          usage: { prompt_tokens: 4, completion_tokens: 5 }
+        }));
+        return;
+      }
+
       if (req.url === "/backup/purchase/create") {
         expect(body.paymentMethod).toBe("mock");
         events.push({ seller: "backup-seller", url: req.url });
@@ -2481,6 +2684,8 @@ describe("TokenBuddy manual routing mode", () => {
 
   beforeEach(() => {
     events.length = 0;
+    primaryPurchaseSucceeds = false;
+    primaryInferenceFails = false;
     rmSqliteFiles(dbPath);
     const store = new BuyerStore({ dbPath });
     store.savePayment({
@@ -2496,7 +2701,11 @@ describe("TokenBuddy manual routing mode", () => {
       proxyPort: 0,
       dbPath,
       sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
-      selectionMode: "manual"
+      sellerRouting: {
+        mode: "fixed",
+        sellerId: "primary-seller",
+        scorer: "balanced"
+      }
     });
     daemon.start();
     daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
@@ -2508,9 +2717,11 @@ describe("TokenBuddy manual routing mode", () => {
     rmSqliteFiles(dbPath);
   });
 
-  test("uses only the default seller and does not prewarm or fail over to backup", async () => {
+  test("fixed routing uses only the configured seller and does not fail over to backup", async () => {
     const status = await (await fetch(`http://127.0.0.1:${daemonControlPort}/status`)).json() as any;
     expect(status.selectionMode).toBe("manual");
+    expect(status.sellerRoutingMode).toBe("fixed");
+    expect(status.selectedSellerId).toBe("primary-seller");
 
     const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
       method: "POST",
@@ -2537,7 +2748,7 @@ describe("TokenBuddy manual routing mode", () => {
     expect(inferences.inferences.some((entry: any) => entry.sellerKey === "backup-seller")).toBe(false);
   });
 
-  test("pins manual routing to the configured seller id when selectedSellerId is set", async () => {
+  test("fixed routing pins to the configured seller id", async () => {
     daemon.stop();
     events.length = 0;
     daemon = new TokenbuddyDaemon({
@@ -2545,8 +2756,11 @@ describe("TokenBuddy manual routing mode", () => {
       proxyPort: 0,
       dbPath,
       sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
-      selectionMode: "manual",
-      selectedSellerId: "backup-seller"
+      sellerRouting: {
+        mode: "fixed",
+        sellerId: "backup-seller",
+        scorer: "balanced"
+      }
     });
     daemon.start();
     daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
@@ -2554,6 +2768,7 @@ describe("TokenBuddy manual routing mode", () => {
 
     const status = await (await fetch(`http://127.0.0.1:${daemonControlPort}/status`)).json() as any;
     expect(status.selectionMode).toBe("manual");
+    expect(status.sellerRoutingMode).toBe("fixed");
     expect(status.selectedSellerId).toBe("backup-seller");
 
     const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
@@ -2567,7 +2782,7 @@ describe("TokenBuddy manual routing mode", () => {
 
     expect(response.ok).toBe(true);
     // v1.2: the buyer no longer fetches the seller manifest per request.
-    // The backup-seller is selected via `selectedSellerId`; the manifest
+    // The backup-seller is selected via the fixed seller routing config; the manifest
     // is sourced from the registry's `models` field.
     expect(events).toEqual([
       { seller: "backup-seller", url: "/backup/purchase/create" },
@@ -2575,4 +2790,203 @@ describe("TokenBuddy manual routing mode", () => {
       { seller: "backup-seller", url: "/backup/v1/chat/completions" }
     ]);
   });
+
+  test("daemon loads fixed routing from buyer runtime config", async () => {
+    daemon.stop();
+    events.length = 0;
+    const store = new BuyerStore({ dbPath });
+    store.saveDaemonRuntimeConfig("routing", {
+      mode: "fixed",
+      sellerId: "backup-seller",
+      scorer: "balanced"
+    });
+    store.close();
+
+    daemon = new TokenbuddyDaemon({
+      controlPort: 0,
+      proxyPort: 0,
+      dbPath,
+      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`
+    });
+    daemon.start();
+    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
+    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
+
+    const status = await (await fetch(`http://127.0.0.1:${daemonControlPort}/status`)).json() as any;
+    expect(status.sellerRoutingMode).toBe("fixed");
+    expect(status.selectedSellerId).toBe("backup-seller");
+
+    const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-manual",
+        messages: [{ role: "user", content: "buyer store routing should be active" }]
+      })
+    });
+
+    expect(response.ok).toBe(true);
+    expect(events).toEqual([
+      { seller: "backup-seller", url: "/backup/purchase/create" },
+      { seller: "backup-seller", url: "/backup/purchase/complete" },
+      { seller: "backup-seller", url: "/backup/v1/chat/completions" }
+    ]);
+  });
+
+  test("fixedSet routing only uses sellers in the configured pool", async () => {
+    daemon.stop();
+    events.length = 0;
+    daemon = new TokenbuddyDaemon({
+      controlPort: 0,
+      proxyPort: 0,
+      dbPath,
+      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
+      sellerRouting: {
+        mode: "fixedSet",
+        sellerIds: ["backup-seller"],
+        scorer: "balanced"
+      }
+    });
+    daemon.start();
+    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
+    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
+
+    const status = await (await fetch(`http://127.0.0.1:${daemonControlPort}/status`)).json() as any;
+    expect(status.selectionMode).toBe("manual");
+    expect(status.sellerRoutingMode).toBe("fixedSet");
+    expect(status.selectedSellerId).toBeUndefined();
+
+    const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-manual",
+        messages: [{ role: "user", content: "fixedSet should stay inside the configured pool" }]
+      })
+    });
+
+    expect(response.ok).toBe(true);
+    expect(events).toEqual([
+      { seller: "backup-seller", url: "/backup/purchase/create" },
+      { seller: "backup-seller", url: "/backup/purchase/complete" },
+      { seller: "backup-seller", url: "/backup/v1/chat/completions" }
+    ]);
+  });
+
+  test("fullAuto routing fails over from a 500 primary seller to the backup seller", async () => {
+    daemon.stop();
+    events.length = 0;
+    primaryPurchaseSucceeds = true;
+    primaryInferenceFails = true;
+    const requestId = "auto_failover_500_log_detail";
+    const rawPrompt = "raw prompt must stay out of tb-proxyd logs: tb-log-secret-500";
+    daemon = new TokenbuddyDaemon({
+      controlPort: 0,
+      proxyPort: 0,
+      dbPath,
+      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
+      sellerRouting: {
+        mode: "fullAuto",
+        scorer: "balanced"
+      }
+    });
+    daemon.start();
+    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
+    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
+
+    const status = await (await fetch(`http://127.0.0.1:${daemonControlPort}/status`)).json() as any;
+    expect(status.selectionMode).toBe("auto");
+    expect(status.sellerRoutingMode).toBe("fullAuto");
+    expect(status.selectedSellerId).toBeUndefined();
+
+    const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-manual",
+        messages: [{ role: "user", content: rawPrompt }],
+        requestId
+      })
+    });
+
+    expect(response.ok).toBe(true);
+    expect((await response.json() as any).id).toBe("backup-chat");
+    expect(events).toEqual([
+      { seller: "primary-seller", url: "/primary/purchase/create" },
+      { seller: "primary-seller", url: "/primary/purchase/complete" },
+      { seller: "primary-seller", url: "/primary/v1/chat/completions" },
+      { seller: "primary-seller", url: "/primary/v1/chat/completions" },
+      { seller: "primary-seller", url: "/primary/v1/chat/completions" },
+      { seller: "backup-seller", url: "/backup/purchase/create" },
+      { seller: "backup-seller", url: "/backup/purchase/complete" },
+      { seller: "backup-seller", url: "/backup/v1/chat/completions" }
+    ]);
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const logFile = resolveModuleLogFile("tb-proxyd");
+    const logs = fs.existsSync(logFile) ? fs.readFileSync(logFile, "utf8") : "";
+    const requestLogs = logs
+      .split("\n")
+      .filter((line) => line.includes(`requestId=${requestId}`))
+      .join("\n");
+    expect(requestLogs).toContain("event=route.failover.retry_scheduled");
+    expect(requestLogs).toContain("event=route.failover.triggered");
+    expect(requestLogs).toContain("event=purchase.create.started");
+    expect(requestLogs).toContain("event=purchase.ledger.recorded");
+    expect(requestLogs).toContain("event=inference.ledger.recorded");
+    expect(requestLogs).toContain("bodySummary=");
+    expect(requestLogs).not.toContain("upstreamBody=");
+    expect(logs).not.toContain(rawPrompt);
+  });
+
+  test("fullAuto routing logs purchase failure failover before trying the backup seller", async () => {
+    daemon.stop();
+    events.length = 0;
+    primaryPurchaseSucceeds = false;
+    daemon = new TokenbuddyDaemon({
+      controlPort: 0,
+      proxyPort: 0,
+      dbPath,
+      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
+      sellerRouting: {
+        mode: "fullAuto",
+        scorer: "balanced"
+      }
+    });
+    daemon.start();
+    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
+    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
+
+    const requestId = "auto_purchase_failover_log_detail";
+    const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-manual",
+        messages: [{ role: "user", content: "purchase failure should fail over" }],
+        requestId
+      })
+    });
+
+    expect(response.ok).toBe(true);
+    expect((await response.json() as any).id).toBe("backup-chat");
+    expect(events).toEqual([
+      { seller: "primary-seller", url: "/primary/purchase/create" },
+      { seller: "backup-seller", url: "/backup/purchase/create" },
+      { seller: "backup-seller", url: "/backup/purchase/complete" },
+      { seller: "backup-seller", url: "/backup/v1/chat/completions" }
+    ]);
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const logFile = resolveModuleLogFile("tb-proxyd");
+    const logs = fs.existsSync(logFile) ? fs.readFileSync(logFile, "utf8") : "";
+    const requestLogs = logs
+      .split("\n")
+      .filter((line) => line.includes(`requestId=${requestId}`))
+      .join("\n");
+    expect(requestLogs).toContain("event=route.failover.triggered");
+    expect(requestLogs).toContain("reason=purchase_failed");
+    expect(requestLogs).toContain("controllerAction=retry_same_seller");
+    expect(requestLogs).not.toContain("event=route.failover.retry_scheduled");
+  });
 });