@tokenbuddy/tokenbuddy 1.0.26 → 1.0.28

package/tests/seller-route-planner.test.ts

@@ -64,6 +64,40 @@ describe("seller route planner", () => {
     expect(result.source).toBe("registry_fallback");
     expect(result.sourceReason).toBe("prewarm_no_compatible_candidates");
     expect(result.routes.map((route) => route.seller.id)).toEqual(["s1", "s2"]);
+    expect(result.diagnostics).toMatchObject({
+      prewarmCandidateCount: 2,
+      prewarmUsableCount: 0,
+      prewarmMissingSellerIds: ["missing"],
+      prewarmBlockedSellerIds: [],
+      prewarmIncompatibleSellerIds: ["s3"]
+    });
+  });
+
+  test("diagnostics explain prewarm fallback caused by blocked warm candidates", () => {
+    const now = 10_000;
+    const result = plan({
+      now,
+      prewarmCandidates: [
+        { sellerId: "s1", url: "https://s1.example.com", healthScore: 100 },
+        { sellerId: "s2", url: "https://s2.example.com", healthScore: 90 }
+      ],
+      sellerMetrics: [
+        { sellerId: "s1", circuit: "open" },
+        { sellerId: "s2", capacityBlockedUntil: now + 1000 }
+      ]
+    });
+
+    expect(result.source).toBe("registry_fallback");
+    expect(result.sourceReason).toBe("prewarm_no_compatible_candidates");
+    expect(result.routes).toEqual([]);
+    expect(result.diagnostics).toMatchObject({
+      prewarmCandidateCount: 2,
+      prewarmUsableCount: 0,
+      prewarmBlockedSellerIds: ["s1", "s2"],
+      blockedOpenCircuitCount: 1,
+      blockedCapacityCount: 1,
+      blockedSellerIds: ["s1", "s2"]
+    });
   });
 
   test("filters registry fallback by requested model, protocol, and payment method", () => {
@@ -79,6 +113,21 @@ describe("seller route planner", () => {
     expect(result.source).toBe("registry_fallback");
     expect(result.routes.map((route) => route.seller.id)).toEqual(["ok"]);
     expect(result.reason).toBe("fullAuto:balanced:routes_1");
+    expect(result.diagnostics).toEqual({
+      registryVisibleCount: 4,
+      prewarmCandidateCount: 0,
+      prewarmUsableCount: 0,
+      prewarmMissingSellerIds: [],
+      prewarmBlockedSellerIds: [],
+      prewarmIncompatibleSellerIds: [],
+      sourceCandidateCount: 1,
+      blockedOpenCircuitCount: 0,
+      blockedCapacityCount: 0,
+      blockedLocalConcurrencyCount: 0,
+      blockedSellerIds: [],
+      incompatibleCount: 3,
+      incompatibleSellerIds: ["wrong-model", "wrong-payment", "wrong-protocol"]
+    });
   });
 
   test("only active registry sellers are visible to buyer routing", () => {
@@ -161,6 +210,8 @@ describe("seller route planner", () => {
     });
 
     expect(result.routes.map((route) => route.seller.id)).toEqual(["s2"]);
+    expect(result.diagnostics.blockedOpenCircuitCount).toBe(1);
+    expect(result.diagnostics.blockedSellerIds).toEqual(["s1"]);
   });
 
   test("active capacity blocks are excluded before strategy selection", () => {
@@ -175,6 +226,8 @@ describe("seller route planner", () => {
     });
 
     expect(blocked.routes.map((route) => route.seller.id)).toEqual(["s2"]);
+    expect(blocked.diagnostics.blockedCapacityCount).toBe(1);
+    expect(blocked.diagnostics.blockedSellerIds).toEqual(["s1"]);
 
     const expired = plan({
       now: now + 1001,
@@ -186,5 +239,30 @@ describe("seller route planner", () => {
     });
 
     expect(expired.routes.map((route) => route.seller.id)).toEqual(["s1", "s2"]);
+    expect(expired.diagnostics.blockedCapacityCount).toBe(0);
+    expect(expired.diagnostics.blockedSellerIds).toEqual([]);
+  });
+
+  test("local concurrency blocks are excluded before choosing prewarm or registry candidates", () => {
+    const result = plan({
+      prewarmCandidates: [
+        { sellerId: "s1", url: "https://s1.example.com", healthScore: 100 }
+      ],
+      sellerMetrics: [
+        { sellerId: "s1", localConcurrencyActive: 1, localConcurrencyLimit: 1 },
+        { sellerId: "s2", localConcurrencyActive: 0, localConcurrencyLimit: 1 }
+      ]
+    });
+
+    expect(result.source).toBe("registry_fallback");
+    expect(result.sourceReason).toBe("prewarm_no_compatible_candidates");
+    expect(result.routes.map((route) => route.seller.id)).toEqual(["s2"]);
+    expect(result.diagnostics).toMatchObject({
+      prewarmCandidateCount: 1,
+      prewarmUsableCount: 0,
+      prewarmBlockedSellerIds: ["s1"],
+      blockedLocalConcurrencyCount: 1,
+      blockedSellerIds: ["s1"]
+    });
   });
 });

package/tests/tokenbuddy.test.ts

@@ -5,6 +5,7 @@ import {
   buildLaunchdPlistContent,
   buildCli,
   fetchClawtipBootstrap,
+  installLaunchAgentWithRunner,
   normalizeClawtipBootstrapResourceUrl,
   restartLaunchAgent,
   runWebInitLauncher,
@@ -15,6 +16,7 @@ import {
   readClawtipPayCredential,
   resolveNpxCommand,
   resolveClawtipQrMediaPath,
+  createClawtipPaymentProof,
   startClawtipWalletBootstrap,
   waitForClawtipActivationConfirmation,
   writeClawtipOrderFile,
@@ -74,7 +76,7 @@ describe("TokenBuddy CLI command surface", () => {
       .filter(command => command !== "help")
       .sort();
 
-    expect(commandNames).toEqual(["daemon", "doctor", "init", "models", "payment", "routing", "ui"]);
+    expect(commandNames).toEqual(["daemon", "doctor", "init", "models", "payment", "routing", "ui", "update"]);
   });
 
   test("tb daemon help exposes restart", () => {
@@ -116,7 +118,8 @@ describe("TokenBuddy CLI command surface", () => {
 
     expect(packageJson.bin).toEqual({
       tb: "bin/tb.js",
-      "tb-proxyd": "bin/tb-proxyd.js"
+      "tb-proxyd": "bin/tb-proxyd.js",
+      "tb-clawtip-proof": "bin/tb-clawtip-proof.js"
     });
   });
 
@@ -136,7 +139,7 @@ describe("TokenBuddy CLI command surface", () => {
       stderrPath: "/Users/example/.tokenbuddy-store/tb-proxyd.stderr.log",
       controlPort: 17820,
       proxyPort: 17821,
-      sellerRegistryUrl: "https://tb-wallet-bootstrap.fly.dev/registry/sellers",
+      sellerRegistryUrl: "https://registry.tokenbuddy.ai/v1/registry.json",
       pathEnv: "/usr/bin:/bin",
     });
 
@@ -146,7 +149,7 @@ describe("TokenBuddy CLI command surface", () => {
     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>");
+    expect(plist).toContain("<string>https://registry.tokenbuddy.ai/v1/registry.json</string>");
     expect(plist).toContain("<key>PATH</key>");
     expect(plist).toContain("<string>/opt/homebrew/bin:/usr/bin:/bin</string>");
   });
@@ -160,7 +163,7 @@ describe("TokenBuddy CLI command surface", () => {
       stderrPath: "/Users/example/.tokenbuddy-store/tb-proxyd.stderr.log",
       controlPort: 17820,
       proxyPort: 17821,
-      sellerRegistryUrl: "https://tb-wallet-bootstrap.fly.dev/registry/sellers",
+      sellerRegistryUrl: "https://registry.tokenbuddy.ai/v1/registry.json",
       clawtipProofCommand: "/Users/example/bin/tokenbuddy-clawtip-proof-openclaw.sh",
       clawtipProofTimeoutMs: 180000,
     });
@@ -173,6 +176,63 @@ describe("TokenBuddy CLI command surface", () => {
     expect(plist).not.toContain("PAYMENT_PROOF");
   });
 
+  test("web init launcher installs the default ClawTip proof provider into launchd", async () => {
+    const writtenFiles: Array<{ filePath: string; content: string }> = [];
+    const result = await runWebInitLauncher({
+      platform: "darwin",
+      controlPort: 3210,
+      proxyPort: 3211,
+      sellerRegistryUrl: "https://registry.example.test/sellers",
+      homeDir: "/Users/example",
+      nodePath: "/opt/node",
+      scriptPath: "/opt/tokenbuddy/dist/src/tb-proxyd.js",
+      pathEnv: "/usr/bin:/bin",
+      mkdirSync: () => undefined,
+      writeFileSync: (filePath, content) => {
+        writtenFiles.push({ filePath, content });
+      },
+      installLaunchAgent: () => undefined,
+      waitForDaemonStatus: async () => ({
+        running: true,
+        status: { pid: 42, controlPort: 3210, proxyPort: 3211 }
+      }),
+      fetchInitState: async () => ({
+        freshMachine: true,
+        setup: { status: "not_started", version: 1, completedSteps: [] }
+      }),
+      launchControlUi: () => "http://127.0.0.1:3210/init"
+    });
+
+    expect(result.serviceInstalled).toBe(true);
+    expect(writtenFiles[0].content).toContain("<key>TB_PROXYD_CLAWTIP_PROOF_COMMAND</key>");
+    expect(writtenFiles[0].content).toContain("tb-clawtip-proof.js");
+  });
+
+  test("installLaunchAgent reloads an existing LaunchAgent so new plist env takes effect", () => {
+    const calls: Array<{ args: string[]; ignoreFailure?: boolean }> = [];
+    let bootstrapAttempts = 0;
+    installLaunchAgentWithRunner("/Users/example/Library/LaunchAgents/com.tokenbuddy.proxyd.plist", "com.tokenbuddy.proxyd", (args, ignoreFailure) => {
+      calls.push({ args, ignoreFailure });
+      if (args[0] === "bootstrap") {
+        bootstrapAttempts += 1;
+        if (bootstrapAttempts === 1) {
+          throw new Error("launchctl bootstrap transient failure");
+        }
+      }
+    });
+
+    expect(calls).toEqual([
+      { args: ["bootout", expect.stringMatching(/^gui\/\d+\/com\.tokenbuddy\.tb-proxyd$/)], ignoreFailure: true },
+      { args: ["bootout", expect.stringMatching(/^gui\/\d+\/homebrew\.mxcl\.tokenbuddy$/)], ignoreFailure: true },
+      { args: ["print", expect.stringMatching(/^gui\/\d+\/com\.tokenbuddy\.proxyd$/)], ignoreFailure: undefined },
+      { args: ["bootout", expect.stringMatching(/^gui\/\d+\/com\.tokenbuddy\.proxyd$/)], ignoreFailure: true },
+      { args: ["bootstrap", expect.stringMatching(/^gui\/\d+$/), "/Users/example/Library/LaunchAgents/com.tokenbuddy.proxyd.plist"], ignoreFailure: undefined },
+      { args: ["bootstrap", expect.stringMatching(/^gui\/\d+$/), "/Users/example/Library/LaunchAgents/com.tokenbuddy.proxyd.plist"], ignoreFailure: undefined },
+      { args: ["kickstart", "-k", expect.stringMatching(/^gui\/\d+\/com\.tokenbuddy\.proxyd$/)], ignoreFailure: undefined },
+    ]);
+    expect(bootstrapAttempts).toBe(2);
+  });
+
   test("restartLaunchAgent kickstarts the installed LaunchAgent and waits for readiness", async () => {
     const launchctlCalls: string[][] = [];
     const result = await restartLaunchAgent(17820, {
@@ -1145,16 +1205,47 @@ describe("TokenBuddy init payment options", () => {
       payTo: "pay-to-test",
       encryptedData: "ciphertext",
       indicator: "indicator_error",
-      slug: "tb-wallet-bootstrap",
-      skillId: "si-tb-wallet-bootstrap",
+      slug: "tb-registry",
+      skillId: "si-tb-registry",
       description: "TokenBuddy ClawTip wallet activation",
-      resourceUrl: "https://tb-wallet-bootstrap.fly.dev"
+      resourceUrl: "https://tb-registry.fly.dev"
     }, {
       home: path.join(TEMP_STORE_ROOT, "clawtip-error-home"),
       runClawtipCommand: async () => "ClawTip 返回错误：商家信息有误",
     })).rejects.toThrow("ClawTip pay failed: ClawTip 返回错误：商家信息有误");
   });
 
+  test("treats ClawTip returned payment failure messages as failed proofs", async () => {
+    const parsed = parseClawtipCliOutput("返回消息: 收付款方账户不能相同\n已获取到支付凭证");
+
+    expect(parsed.failureMessage).toContain("收付款方账户不能相同");
+    await expect(createClawtipPaymentProof({
+      paymentInstructions: {
+        method: "clawtip",
+        clawtip: {
+          orderNo: "order_same_account",
+          amountFen: 2,
+          payTo: "pay-to-test",
+          encryptedData: "ciphertext",
+          indicator: "indicator_same_account",
+          slug: "tb-seller",
+          skillId: "si-tb-seller",
+          description: "TokenBuddy inference purchase",
+          resourceUrl: "https://seller.example.test"
+        }
+      }
+    }, {
+      home: path.join(TEMP_STORE_ROOT, "clawtip-same-account-home"),
+      runClawtipCommand: async () => "返回消息: 收付款方账户不能相同\n已获取到支付凭证",
+    })).rejects.toThrow("ClawTip pay failed: 返回消息: 收付款方账户不能相同");
+  });
+
+  test("accepts ClawTip returned success messages with payment details", () => {
+    const parsed = parseClawtipCliOutput("返回消息: 本次交易在授权范围内，ClawTip付费成功。支付0.02元，余额0.50元\n已获取到支付凭证");
+
+    expect(parsed.failureMessage).toBeUndefined();
+  });
+
   test("uses only ClawTip CLI media paths for QR resolution", () => {
     expect(resolveClawtipQrMediaPath({
       authUrl: "https://clawtip.jd.com/qrcode?clawtipId=device-789",
@@ -1192,17 +1283,17 @@ describe("TokenBuddy init payment options", () => {
 
   test("normalizes the bootstrap resource URL away from the public registry endpoint", () => {
     expect(normalizeClawtipBootstrapResourceUrl(
-      "https://tb-wallet-bootstrap.fly.dev",
-      "https://tb-wallet-bootstrap.fly.dev/registry/sellers"
-    )).toBe("https://tb-wallet-bootstrap.fly.dev");
+      "https://tb-registry.fly.dev",
+      "https://tb-registry.fly.dev/registry/sellers"
+    )).toBe("https://tb-registry.fly.dev");
 
     expect(normalizeClawtipBootstrapResourceUrl(
-      "https://tb-wallet-bootstrap.fly.dev/base",
-      "https://tb-wallet-bootstrap.fly.dev/registry/sellers"
-    )).toBe("https://tb-wallet-bootstrap.fly.dev/base");
+      "https://tb-registry.fly.dev/base",
+      "https://tb-registry.fly.dev/registry/sellers"
+    )).toBe("https://tb-registry.fly.dev/base");
 
     expect(normalizeClawtipBootstrapResourceUrl(
-      "https://tb-wallet-bootstrap.fly.dev",
+      "https://tb-registry.fly.dev",
       "https://example.test/pay"
     )).toBe("https://example.test/pay");
   });
@@ -1215,7 +1306,7 @@ describe("TokenBuddy init payment options", () => {
         orderNo: "order_placeholder",
         indicator: "indicator_placeholder",
         payTo: "bootstrap-pay-to",
-        resourceUrl: "https://tb-wallet-bootstrap.fly.dev/registry/sellers",
+        resourceUrl: "https://registry.tokenbuddy.ai/v1/registry.json",
       }
     }), {
       status: 200,
@@ -1223,7 +1314,7 @@ describe("TokenBuddy init payment options", () => {
     })) as typeof fetch;
 
     try {
-      await expect(fetchClawtipBootstrap("https://tb-wallet-bootstrap.fly.dev")).rejects.toThrow(
+      await expect(fetchClawtipBootstrap("https://tb-registry.fly.dev")).rejects.toThrow(
         "ClawTip bootstrap service is misconfigured: payTo is still the placeholder"
       );
     } finally {
@@ -1241,10 +1332,10 @@ describe("TokenBuddy init payment options", () => {
       payTo: "pay-to-test",
       encryptedData: "ciphertext",
       indicator: "indicator_123",
-      slug: "tb-wallet-bootstrap",
-      skillId: "si-tb-wallet-bootstrap",
+      slug: "tb-registry",
+      skillId: "si-tb-registry",
       description: "TokenBuddy ClawTip wallet activation",
-      resourceUrl: "https://tb-wallet-bootstrap.fly.dev"
+      resourceUrl: "https://tb-registry.fly.dev"
     }, home);
 
     expect(orderFile).toBe(path.join(
@@ -1258,13 +1349,13 @@ describe("TokenBuddy init payment options", () => {
 
     const saved = JSON.parse(fs.readFileSync(orderFile, "utf8"));
     expect(saved).toEqual(expect.objectContaining({
-      "skill-id": "si-tb-wallet-bootstrap",
+      "skill-id": "si-tb-registry",
       order_no: "order_123",
       amount: 1,
       encrypted_data: "ciphertext",
       pay_to: "pay-to-test",
-      slug: "tb-wallet-bootstrap",
-      resource_url: "https://tb-wallet-bootstrap.fly.dev"
+      slug: "tb-registry",
+      resource_url: "https://tb-registry.fly.dev"
     }));
   });
 
@@ -1278,10 +1369,10 @@ describe("TokenBuddy init payment options", () => {
       payTo: "pay-to-test",
       encryptedData: "ciphertext",
       indicator: "indicator_456",
-      slug: "tb-wallet-bootstrap",
-      skillId: "si-tb-wallet-bootstrap",
+      slug: "tb-registry",
+      skillId: "si-tb-registry",
       description: "TokenBuddy ClawTip wallet activation",
-      resourceUrl: "https://tb-wallet-bootstrap.fly.dev"
+      resourceUrl: "https://tb-registry.fly.dev"
     }, {
       home,
       runClawtipCommand: async () => {
@@ -1312,6 +1403,65 @@ describe("TokenBuddy init payment options", () => {
     expect(readClawtipPayCredential(activation.orderFile)).toBe("credential_456");
   });
 
+  test("creates a ClawTip payment proof from seller payment instructions", async () => {
+    const home = path.join(TEMP_STORE_ROOT, "clawtip-proof-home");
+    rmDir(home);
+
+    const proof = await createClawtipPaymentProof({
+      paymentInstructions: {
+        method: "clawtip",
+        clawtip: {
+          orderNo: "order_789",
+          amountFen: 2,
+          payTo: "pay-to-test",
+          encryptedData: "ciphertext",
+          indicator: "indicator_789",
+          slug: "tb-seller",
+          skillId: "si-tb-seller",
+          description: "TokenBuddy inference purchase",
+          resourceUrl: "https://seller.example.test"
+        }
+      }
+    }, {
+      home,
+      runClawtipCommand: async (args) => {
+        expect(args).toEqual([
+          "--yes",
+          "@clawtip/clawtip-cli@1.0.4",
+          "pay",
+          "-o",
+          "order_789",
+          "-i",
+          "indicator_789",
+          "-v",
+          "1.0.12"
+        ]);
+        const orderFile = path.join(
+          home,
+          ".openclaw",
+          "skills",
+          "orders",
+          "indicator_789",
+          "order_789.json"
+        );
+        const order = JSON.parse(fs.readFileSync(orderFile, "utf8"));
+        expect(order).toEqual(expect.objectContaining({
+          order_no: "order_789",
+          amount: 2,
+          encrypted_data: "ciphertext",
+          pay_to: "pay-to-test",
+          slug: "tb-seller",
+          resource_url: "https://seller.example.test"
+        }));
+        order.payCredential = "credential_789";
+        fs.writeFileSync(orderFile, JSON.stringify(order, null, 2), "utf8");
+        return "已获取到支付凭证";
+      }
+    });
+
+    expect(proof).toBe("credential_789");
+  });
+
   test("recovers the latest generated ClawTip QR media path when pay output omits MEDIA", async () => {
     const home = path.join(TEMP_STORE_ROOT, "clawtip-bootstrap-qr-home");
     rmDir(home);
@@ -1322,10 +1472,10 @@ describe("TokenBuddy init payment options", () => {
       payTo: "pay-to-test",
       encryptedData: "ciphertext",
       indicator: "indicator_789",
-      slug: "tb-wallet-bootstrap",
-      skillId: "si-tb-wallet-bootstrap",
+      slug: "tb-registry",
+      skillId: "si-tb-registry",
       description: "TokenBuddy ClawTip wallet activation",
-      resourceUrl: "https://tb-wallet-bootstrap.fly.dev"
+      resourceUrl: "https://tb-registry.fly.dev"
     }, {
       home,
       runClawtipCommand: async () => {
@@ -1358,10 +1508,10 @@ describe("TokenBuddy init payment options", () => {
       payTo: "pay-to-test",
       encryptedData: "ciphertext",
       indicator: "indicator_credential_qr",
-      slug: "tb-wallet-bootstrap",
-      skillId: "si-tb-wallet-bootstrap",
+      slug: "tb-registry",
+      skillId: "si-tb-registry",
       description: "TokenBuddy ClawTip wallet activation",
-      resourceUrl: "https://tb-wallet-bootstrap.fly.dev"
+      resourceUrl: "https://tb-registry.fly.dev"
     }, {
       home,
       runClawtipCommand: async () => {
@@ -2803,17 +2953,31 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
   });
 
   test("fails closed when no compatible seller can serve the requested model", async () => {
+    const requestId = "missing_model_route_diagnostics";
     const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
         model: "missing-model",
-        messages: [{ role: "user", content: "hello" }]
+        messages: [{ role: "user", content: "hello" }],
+        requestId
       })
     });
     expect(response.status).toBe(502);
     const data = await response.json() as any;
     expect(data.error.message).toContain("no compatible seller");
+
+    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.candidates.prewarmed");
+    expect(requestLogs).toContain("routeReason=no_compatible_seller");
+    expect(requestLogs).toContain("sellerCount=0");
+    expect(requestLogs).toContain("candidateDiagnostics=");
   });
 });
 
@@ -2827,6 +2991,7 @@ describe("TokenBuddy seller routing strategies", () => {
   let primaryPurchaseSucceeds = false;
   let primaryInferenceFails = false;
   let primaryInferenceBusy = false;
+  let primaryInferenceDelayMs = 0;
   const dbPath = path.resolve(__dirname, "../../data-test/manual-routing-test.db");
   const routeEvents = (): Array<{ seller: string; url?: string }> => events
     .filter((event) => event.url !== "/primary/health" && event.url !== "/backup/health");
@@ -2926,6 +3091,9 @@ describe("TokenBuddy seller routing strategies", () => {
 
       if (req.url === "/primary/v1/chat/completions") {
         events.push({ seller: "primary-seller", url: req.url });
+        if (primaryInferenceDelayMs > 0) {
+          await new Promise((resolve) => setTimeout(resolve, primaryInferenceDelayMs));
+        }
         if (primaryInferenceBusy) {
           res.statusCode = 429;
           res.end(JSON.stringify({ error: { code: "busy_capacity", message: "primary seller capacity is full" } }));
@@ -3003,6 +3171,7 @@ describe("TokenBuddy seller routing strategies", () => {
     primaryPurchaseSucceeds = false;
     primaryInferenceFails = false;
     primaryInferenceBusy = false;
+    primaryInferenceDelayMs = 0;
     rmSqliteFiles(dbPath);
     const store = new BuyerStore({ dbPath });
     store.savePayment({
@@ -3309,6 +3478,13 @@ describe("TokenBuddy seller routing strategies", () => {
       .join("\n");
     expect(requestLogs).toContain("event=route.failover.retry_scheduled");
     expect(requestLogs).toContain("event=route.failover.triggered");
+    expect(requestLogs).toContain("event=route.candidates.prewarmed");
+    expect(requestLogs).toContain("event=route.selected");
+    expect(requestLogs).toContain("routePlanSource=registry_fallback");
+    expect(requestLogs).toContain("routePlanReason=fullAuto:balanced:routes_2");
+    expect(requestLogs).toContain("candidateDiagnostics=");
+    expect(requestLogs).toContain("hasNextRoute=true");
+    expect(requestLogs).toContain("attemptNumber=");
     expect(requestLogs).toContain("event=purchase.create.started");
     expect(requestLogs).toContain("event=purchase.ledger.recorded");
     expect(requestLogs).toContain("event=inference.ledger.recorded");
@@ -3373,6 +3549,112 @@ describe("TokenBuddy seller routing strategies", () => {
     ]);
   });
 
+  test("fullAuto routing skips locally saturated sellers for concurrent requests", async () => {
+    daemon.stop();
+    events.length = 0;
+    primaryPurchaseSucceeds = true;
+    primaryInferenceDelayMs = 250;
+    daemon = new TokenbuddyDaemon({
+      controlPort: 0,
+      proxyPort: 0,
+      dbPath,
+      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
+      sellerRouting: {
+        mode: "fullAuto",
+        scorer: "balanced"
+      },
+      sellerConcurrency: {
+        enabled: true,
+        maxInFlightPerSeller: 1,
+        leaseTtlMs: 5000
+      }
+    });
+    daemon.start();
+    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
+    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
+    (daemon as any).prewarmCache.commitWarm({
+      modelId: "gpt-manual",
+      protocol: "chat_completions",
+      paymentMethod: "mock",
+      ttlMs: 600000,
+      candidates: [
+        {
+          sellerId: "primary-seller",
+          url: `http://127.0.0.1:${sellerPort}/primary`,
+          healthScore: 100,
+          avgLatencyMs: 10
+        },
+        {
+          sellerId: "backup-seller",
+          url: `http://127.0.0.1:${sellerPort}/backup`,
+          healthScore: 90,
+          avgLatencyMs: 20
+        }
+      ]
+    });
+    (daemon as any).sellerPool.sync();
+
+    const first = 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: "hold primary local capacity" }],
+        requestId: "local_capacity_primary"
+      })
+    });
+
+    for (let i = 0; i < 30; i += 1) {
+      if (events.some((event) => event.url === "/primary/v1/chat/completions")) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    expect(events.some((event) => event.url === "/primary/v1/chat/completions")).toBe(true);
+
+    const second = 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: "use backup while primary is locally full" }],
+        requestId: "local_capacity_backup"
+      })
+    });
+
+    expect(second.ok).toBe(true);
+    expect((await second.json() as any).id).toBe("backup-chat");
+
+    const firstResponse = await first;
+    expect(firstResponse.ok).toBe(true);
+    expect((await firstResponse.json() as any).id).toBe("primary-chat");
+
+    const primaryInferenceCalls = routeEvents().filter((event) => event.url === "/primary/v1/chat/completions");
+    const backupInferenceCalls = routeEvents().filter((event) => event.url === "/backup/v1/chat/completions");
+    expect(primaryInferenceCalls).toHaveLength(1);
+    expect(backupInferenceCalls).toHaveLength(1);
+
+    const status = await (await fetch(`http://127.0.0.1:${daemonControlPort}/status`)).json() as any;
+    expect(status.sellerConcurrency.enabled).toBe(true);
+    expect(status.sellerConcurrency.active).toEqual([]);
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const logFile = resolveModuleLogFile("tb-proxyd");
+    const logs = fs.existsSync(logFile) ? fs.readFileSync(logFile, "utf8") : "";
+    const backupRequestLogs = logs
+      .split("\n")
+      .filter((line) => line.includes("requestId=local_capacity_backup"))
+      .join("\n");
+    expect(backupRequestLogs).toContain("event=route.candidates.prewarmed");
+    expect(backupRequestLogs).toContain("event=route.selected");
+    expect(backupRequestLogs).toContain("primary-seller");
+    expect(backupRequestLogs).toContain("sellerKey=backup-seller");
+    expect(backupRequestLogs).toContain("\"blockedLocalConcurrencyCount\":1");
+    expect(backupRequestLogs).toContain("\"prewarmBlockedSellerIds\":[\"primary-seller\"]");
+    expect(backupRequestLogs).toContain("routePlanSellerCount=1");
+    expect(backupRequestLogs).toContain("localConcurrencyEnabled=true");
+  });
+
   test("fullAuto routing logs purchase failure failover before trying the backup seller", async () => {
     daemon.stop();
     events.length = 0;
@@ -3420,7 +3702,7 @@ describe("TokenBuddy seller routing strategies", () => {
       .join("\n");
     expect(requestLogs).toContain("event=route.failover.triggered");
     expect(requestLogs).toContain("reason=purchase_failed");
-    expect(requestLogs).toContain("controllerAction=retry_same_seller");
+    expect(requestLogs).toContain("controllerAction=failover_next");
     expect(requestLogs).not.toContain("event=route.failover.retry_scheduled");
   });
 });