@tokenbuddy/tokenbuddy 1.0.36 → 1.0.38

package/tests/tokenbuddy.test.ts

@@ -1,4043 +0,0 @@
-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,
-  installLaunchAgentWithRunner,
-  normalizeClawtipBootstrapResourceUrl,
-  restartLaunchAgent,
-  runWebInitLauncher,
-} from "../src/cli.js";
-import {
-  checkOpenClawRuntime,
-  parseClawtipCliOutput,
-  readClawtipPayCredential,
-  resolveNpxCommand,
-  resolveClawtipQrMediaPath,
-  createClawtipPaymentProof,
-  startClawtipWalletBootstrap,
-  waitForClawtipActivationConfirmation,
-  writeClawtipOrderFile,
-} from "../src/init-clawtip-activation.js";
-import {
-  applyProviderInstall,
-  detectProviders,
-  previewProviderInstall,
-  rollbackProviderInstall
-} from "../src/provider-install.js";
-import { PROVIDER_MODE_CONFIG_KEY } from "../src/provider-routing-config.js";
-import {
-  detectTerminals,
-  rewriteHermes,
-  rewriteOpenclaw,
-} from "../src/terminal-detect.js";
-import {
-  buildInitSuccessMessage,
-  buildInitTerminalSelectionState,
-  detectExistingClawtipBinding,
-  inspectClawtipWalletReadiness,
-  inspectOpenClawWalletConfig,
-  INIT_COMING_SOON_PAYMENT_OPTIONS,
-  INIT_PAYMENT_OPTIONS,
-  noteInitComingSoonPayments,
-  OTHER_TERMINAL_OPTION,
-  validateInitTerminalSelection,
-} from "../src/init-payment-options.js";
-import { printDoctorClawtipWallet } from "../src/doctor-clawtip-wallet.js";
-import {
-  detectTerminalImageDisplay,
-  displayTerminalImage,
-} from "../src/terminal-image.js";
-import * as path from "path";
-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");
-const INSPECTION_STORE_ROOT = path.resolve(__dirname, "../../data-test/json-inspection-store");
-const INSPECTION_HOME = path.resolve(__dirname, "../../data-test/json-inspection-home");
-const PACKAGE_JSON = path.resolve(__dirname, "../package.json");
-
-function rmSqliteFiles(dbPath: string): void {
-  for (const fileName of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
-    fs.rmSync(fileName, { force: true });
-  }
-}
-
-function rmDir(dirPath: string): void {
-  fs.rmSync(dirPath, { recursive: true, force: true });
-}
-
-describe("TokenBuddy CLI command surface", () => {
-  test("tb root help only exposes the approved user commands", () => {
-    const program = buildCli();
-    const commandNames = program.commands
-      .map(command => command.name())
-      .filter(command => command !== "help")
-      .sort();
-
-    expect(commandNames).toEqual(["daemon", "doctor", "init", "models", "payment", "routing", "ui", "update"]);
-  });
-
-  test("tb daemon help exposes restart", () => {
-    const program = buildCli();
-    const daemon = program.commands.find(command => command.name() === "daemon");
-
-    expect(daemon).toBeDefined();
-    expect(daemon!.commands.map(command => command.name()).sort()).toEqual(["restart"]);
-  });
-
-  test("tb payment help only exposes list, add, and remove", () => {
-    const program = buildCli();
-    const payment = program.commands.find(command => command.name() === "payment");
-
-    expect(payment).toBeDefined();
-    const help = payment!.helpInformation();
-
-    for (const command of ["list", "add", "remove"]) {
-      expect(help).toContain(command);
-    }
-
-    for (const removedCommand of ["enable", "disable", "doctor", "default"]) {
-      expect(help).not.toContain(` ${removedCommand}`);
-    }
-  });
-
-  test("removed top-level commands are unreachable", () => {
-    for (const command of ["proxy", "seller", "admin", "config", "ledger"]) {
-      const program = buildCli();
-      program.exitOverride();
-      program.configureOutput({ writeErr: () => undefined });
-
-      expect(() => program.parse(["node", "tb", command])).toThrow(/unknown command/i);
-    }
-  });
-
-  test("package exposes tb and tb-proxyd bins", () => {
-    const packageJson = JSON.parse(fs.readFileSync(PACKAGE_JSON, "utf8"));
-
-    expect(packageJson.bin).toEqual({
-      tb: "bin/tb.js",
-      "tb-proxyd": "bin/tb-proxyd.js",
-      "tb-clawtip-proof": "bin/tb-clawtip-proof.js"
-    });
-  });
-
-  test("tb version follows package version", () => {
-    const packageJson = JSON.parse(fs.readFileSync(PACKAGE_JSON, "utf8"));
-    const program = buildCli();
-
-    expect(program.version()).toBe(packageJson.version);
-  });
-
-  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://registry.tokenbuddy.ai/v1/registry.json",
-      pathEnv: "/usr/bin:/bin",
-    });
-
-    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://registry.tokenbuddy.ai/v1/registry.json</string>");
-    expect(plist).toContain("<key>PATH</key>");
-    expect(plist).toContain("<string>/opt/homebrew/bin:/usr/bin:/bin</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://registry.tokenbuddy.ai/v1/registry.json",
-      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");
-  });
-
-  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, {
-      platform: "darwin",
-      plistPath: "/Users/example/Library/LaunchAgents/com.tokenbuddy.proxyd.plist",
-      existsSync: () => true,
-      runLaunchctl: (args) => {
-        launchctlCalls.push(args);
-      },
-      probeDaemonStatus: async () => ({
-        running: true,
-        status: { pid: 100, controlPort: 17820, proxyPort: 17821 }
-      }),
-      waitForDaemonStatus: async () => ({
-        running: true,
-        status: { pid: 200, controlPort: 17820, proxyPort: 17821 }
-      })
-    });
-
-    expect(result).toMatchObject({
-      attempted: true,
-      restarted: true,
-      method: "launchd",
-      plistPath: "/Users/example/Library/LaunchAgents/com.tokenbuddy.proxyd.plist",
-      after: {
-        running: true,
-        status: { pid: 200 }
-      }
-    });
-    expect(launchctlCalls).toEqual([[
-      "kickstart",
-      "-k",
-      expect.stringMatching(/^gui\/\d+\/com\.tokenbuddy\.proxyd$/)
-    ]]);
-  });
-
-  test("restartLaunchAgent reports missing LaunchAgent plist without calling launchctl", async () => {
-    const launchctlCalls: string[][] = [];
-    const result = await restartLaunchAgent(17820, {
-      platform: "darwin",
-      plistPath: "/Users/example/Library/LaunchAgents/com.tokenbuddy.proxyd.plist",
-      existsSync: () => false,
-      runLaunchctl: (args) => {
-        launchctlCalls.push(args);
-      },
-      probeDaemonStatus: async () => ({ running: false, error: "offline" }),
-      waitForDaemonStatus: async () => ({ running: false, error: "not called" })
-    });
-
-    expect(result).toMatchObject({
-      attempted: false,
-      restarted: false,
-      method: "launchd",
-      error: expect.stringContaining("tb init")
-    });
-    expect(launchctlCalls).toEqual([]);
-  });
-
-  test("web init launcher installs the macOS LaunchAgent and opens /init", async () => {
-    const writtenFiles: Array<{ filePath: string; content: string }> = [];
-    const installed: Array<{ plistPath: string; label: string }> = [];
-    const createdDirs: string[] = [];
-    const opened: Array<{ controlPort: number; pathname?: 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/tb-proxyd.js",
-      pathEnv: "/usr/bin:/bin",
-      mkdirSync: (dirPath) => {
-        createdDirs.push(dirPath);
-      },
-      writeFileSync: (filePath, content) => {
-        writtenFiles.push({ filePath, content });
-      },
-      installLaunchAgent: (plistPath, label) => {
-        installed.push({ plistPath, label });
-      },
-      waitForDaemonStatus: async () => ({
-        running: true,
-        status: { pid: 42, controlPort: 3210, proxyPort: 3211 }
-      }),
-      fetchInitState: async () => ({ freshMachine: true, setup: { status: "not_started" } }),
-      launchControlUi: (controlPort, pathname) => {
-        opened.push({ controlPort, pathname });
-        return `http://127.0.0.1:${controlPort}${pathname}`;
-      }
-    });
-
-    expect(result).toMatchObject({
-      method: "launchd",
-      controlPort: 3210,
-      proxyPort: 3211,
-      serviceInstalled: true,
-      url: "http://127.0.0.1:3210/init",
-      probe: { running: true }
-    });
-    expect(result.plistPath).toBe("/Users/example/Library/LaunchAgents/com.tokenbuddy.proxyd.plist");
-    expect(installed).toEqual([{
-      plistPath: "/Users/example/Library/LaunchAgents/com.tokenbuddy.proxyd.plist",
-      label: "com.tokenbuddy.proxyd"
-    }]);
-    expect(createdDirs).toEqual(expect.arrayContaining([
-      "/Users/example/Library/LaunchAgents",
-      "/Users/example/.tokenbuddy-store"
-    ]));
-    expect(writtenFiles[0].content).toContain("<string>3210</string>");
-    expect(writtenFiles[0].content).toContain("<string>3211</string>");
-    expect(writtenFiles[0].content).toContain("https://registry.example.test/sellers");
-    expect(writtenFiles[0].content).toContain("<key>PATH</key>");
-    expect(writtenFiles[0].content).toContain("<string>/opt:/usr/bin:/bin</string>");
-    expect(opened).toEqual([{ controlPort: 3210, pathname: "/init" }]);
-  });
-
-  test("web init launcher recovers when launchctl fails after the service becomes ready", async () => {
-    const opened: Array<{ controlPort: number; pathname?: string }> = [];
-    const result = await runWebInitLauncher({
-      platform: "darwin",
-      controlPort: 3220,
-      proxyPort: 3221,
-      homeDir: "/Users/example",
-      nodePath: "/opt/node",
-      scriptPath: "/opt/tb-proxyd.js",
-      mkdirSync: () => undefined,
-      writeFileSync: () => undefined,
-      installLaunchAgent: () => {
-        throw new Error("launchctl bootstrap failed");
-      },
-      waitForDaemonStatus: async () => ({
-        running: true,
-        status: { pid: 43, controlPort: 3220, proxyPort: 3221 }
-      }),
-      fetchInitState: async () => ({ freshMachine: false, repairMode: false, setup: { status: "completed" } }),
-      launchControlUi: (controlPort, pathname) => {
-        opened.push({ controlPort, pathname });
-        return `http://127.0.0.1:${controlPort}${pathname}`;
-      }
-    });
-
-    expect(result).toMatchObject({
-      method: "launchd",
-      controlPort: 3220,
-      proxyPort: 3221,
-      serviceInstalled: true,
-      url: "http://127.0.0.1:3220/overview",
-      probe: { running: true }
-    });
-    expect(result.error).toBeUndefined();
-    expect(opened).toEqual([{ controlPort: 3220, pathname: "/overview" }]);
-  });
-
-  test("web init launcher opens overview after setup is completed", async () => {
-    const opened: Array<{ controlPort: number; pathname?: string }> = [];
-    const result = await runWebInitLauncher({
-      platform: "linux",
-      controlPort: 4340,
-      proxyPort: 4341,
-      repairDaemon: async () => ({
-        repair: { attempted: false, fixed: false },
-        probe: { running: true, status: { pid: 101 } }
-      }),
-      fetchInitState: async () => ({ freshMachine: false, repairMode: false, setup: { status: "completed" } }),
-      launchControlUi: (controlPort, pathname) => {
-        opened.push({ controlPort, pathname });
-        return `http://127.0.0.1:${controlPort}${pathname}`;
-      }
-    });
-
-    expect(result).toMatchObject({
-      method: "detached",
-      controlPort: 4340,
-      proxyPort: 4341,
-      serviceInstalled: true,
-      url: "http://127.0.0.1:4340/overview",
-      probe: { running: true }
-    });
-    expect(opened).toEqual([{ controlPort: 4340, pathname: "/overview" }]);
-  });
-
-  test("web init launcher reopens /init when completed setup needs repair", async () => {
-    const opened: Array<{ controlPort: number; pathname?: string }> = [];
-    const result = await runWebInitLauncher({
-      platform: "linux",
-      controlPort: 4350,
-      proxyPort: 4351,
-      repairDaemon: async () => ({
-        repair: { attempted: false, fixed: false },
-        probe: { running: true, status: { pid: 102 } }
-      }),
-      fetchInitState: async () => ({
-        freshMachine: false,
-        repairMode: true,
-        setup: { status: "completed" }
-      }),
-      launchControlUi: (controlPort, pathname) => {
-        opened.push({ controlPort, pathname });
-        return `http://127.0.0.1:${controlPort}${pathname}`;
-      }
-    });
-
-    expect(result).toMatchObject({
-      method: "detached",
-      controlPort: 4350,
-      proxyPort: 4351,
-      serviceInstalled: true,
-      url: "http://127.0.0.1:4350/init",
-      probe: { running: true }
-    });
-    expect(opened).toEqual([{ controlPort: 4350, pathname: "/init" }]);
-  });
-
-  test("web init launcher uses detached startup on non-macOS and reports failures without opening a browser", async () => {
-    const opened: Array<{ controlPort: number; pathname?: string }> = [];
-    const failed = await runWebInitLauncher({
-      platform: "linux",
-      controlPort: 4320,
-      proxyPort: 4321,
-      repairDaemon: async () => ({
-        repair: { attempted: true, fixed: false, error: "spawn failed" },
-        probe: { running: false, error: "offline" }
-      }),
-      launchControlUi: (controlPort, pathname) => {
-        opened.push({ controlPort, pathname });
-        return `http://127.0.0.1:${controlPort}${pathname}`;
-      }
-    });
-
-    expect(failed).toMatchObject({
-      method: "detached",
-      controlPort: 4320,
-      proxyPort: 4321,
-      serviceInstalled: false,
-      url: "http://127.0.0.1:4320/init",
-      probe: { running: false },
-      error: "spawn failed"
-    });
-    expect(opened).toEqual([]);
-
-    const openedAfterSuccess: Array<{ controlPort: number; pathname?: string }> = [];
-    const succeeded = await runWebInitLauncher({
-      platform: "linux",
-      controlPort: 4330,
-      proxyPort: 4331,
-      repairDaemon: async () => ({
-        repair: { attempted: true, fixed: true, pid: 99 },
-        probe: { running: true, status: { pid: 99 } }
-      }),
-      fetchInitState: async () => ({ freshMachine: true, setup: { status: "not_started" } }),
-      launchControlUi: (controlPort, pathname) => {
-        openedAfterSuccess.push({ controlPort, pathname });
-        return `http://127.0.0.1:${controlPort}${pathname}`;
-      }
-    });
-
-    expect(succeeded).toMatchObject({
-      method: "detached",
-      controlPort: 4330,
-      proxyPort: 4331,
-      serviceInstalled: true,
-      url: "http://127.0.0.1:4330/init",
-      probe: { running: true },
-      repair: { attempted: true, fixed: true, pid: 99 }
-    });
-    expect(openedAfterSuccess).toEqual([{ controlPort: 4330, pathname: "/init" }]);
-  });
-});
-
-describe("BuyerStore safe SQLite persistence", () => {
-  let store: BuyerStore;
-
-  beforeEach(() => {
-    rmDir(TEMP_STORE_ROOT);
-    store = new BuyerStore({ root: TEMP_STORE_ROOT });
-  });
-
-  afterEach(() => {
-    store.close();
-    rmDir(TEMP_STORE_ROOT);
-  });
-
-  test("resolves TOKENBUDDY_BUYER_STORE and enables WAL", () => {
-    const previousStoreRoot = process.env.TOKENBUDDY_BUYER_STORE;
-    process.env.TOKENBUDDY_BUYER_STORE = TEMP_STORE_ROOT;
-    try {
-      expect(resolveBuyerStorePath()).toBe(path.join(TEMP_STORE_ROOT, "buyer-store.db"));
-    } finally {
-      if (previousStoreRoot === undefined) {
-        delete process.env.TOKENBUDDY_BUYER_STORE;
-      } else {
-        process.env.TOKENBUDDY_BUYER_STORE = previousStoreRoot;
-      }
-    }
-
-    expect(store.journalMode()).toBe("wal");
-    expect(fs.existsSync(path.join(TEMP_STORE_ROOT, "buyer-store.db"))).toBe(true);
-  });
-
-  test("keeps token cache behavior behind the buyer store boundary", () => {
-    expect(store.getToken("seller-a")).toBeUndefined();
-
-    store.saveToken("seller-a", "raw-token-secret", "model:gpt-4", 500000, "2030-01-01T00:00:00.000Z");
-    expect(store.getToken("seller-a")).toMatchObject({
-      token: "raw-token-secret",
-      balanceMicros: 500000,
-      reservedMicros: 0,
-      spentMicros: 0,
-      balanceSource: "purchase_complete"
-    });
-
-    store.reconcileTokenBalance({
-      sellerKey: "seller-a",
-      balanceMicros: 499890,
-      reservedMicros: 0,
-      spentMicros: 110,
-      balanceSource: "seller_settlement_summary"
-    });
-    expect(store.getToken("seller-a")).toMatchObject({
-      token: "raw-token-secret",
-      balanceMicros: 499890,
-      reservedMicros: 0,
-      spentMicros: 110,
-      balanceSource: "seller_settlement_summary"
-    });
-  });
-
-  test("getToken surfaces expiresAt so the daemon can reject stale tokens", () => {
-    const futureIso = "2030-01-01T00:00:00.000Z";
-    store.saveToken("seller-exp", "raw-token-secret", "model:gpt-4", 1_000_000, futureIso);
-    expect(store.getToken("seller-exp")?.expiresAt).toBe(futureIso);
-
-    // v1.2 PR-fix: when `saveToken` is invoked, `expiresAt` is
-    // persisted; the daemon reads it via `getToken().expiresAt` to
-    // refuse cached tokens inside the safety margin. This test pins
-    // the field name so a future rename can't silently drop the
-    // buyer-side expiry check.
-    expect(store.getToken("seller-exp")).toMatchObject({
-      token: "raw-token-secret",
-      expiresAt: futureIso
-    });
-  });
-
-  test("returns stable empty state for payments, pending purchases, and ledgers", () => {
-    expect(store.listPayments()).toEqual([]);
-    expect(store.listPendingPurchases()).toEqual([]);
-    expect(store.listPurchaseLedger()).toEqual([]);
-    expect(store.listInferenceLedger()).toEqual([]);
-    expect(store.summary()).toMatchObject({
-      providerRuntimeConfigCount: 0,
-      daemonRuntimeConfigCount: 0,
-    });
-  });
-
-  test("stores provider runtime config and daemon routing config in the buyer store", () => {
-    store.saveProviderRuntimeConfig("opencode", {
-      selectionKind: "single-model",
-      protocolPreference: "responses",
-      defaultModel: "gpt-5.5",
-    });
-    store.saveDaemonRuntimeConfig("routing", {
-      mode: "fixed",
-      sellerId: "seller-a",
-    });
-
-    expect(store.getProviderRuntimeConfig("opencode")).toMatchObject({
-      providerId: "opencode",
-      config: expect.objectContaining({
-        defaultModel: "gpt-5.5",
-      }),
-    });
-    expect(store.getDaemonRuntimeConfig("routing")).toMatchObject({
-      configKey: "routing",
-      config: expect.objectContaining({
-        mode: "fixed",
-        sellerId: "seller-a",
-      }),
-    });
-    expect(store.summary()).toMatchObject({
-      providerRuntimeConfigCount: 1,
-      daemonRuntimeConfigCount: 1,
-    });
-
-    expect(store.removeProviderRuntimeConfig("opencode")).toBe(true);
-    expect(store.removeDaemonRuntimeConfig("routing")).toBe(true);
-    expect(store.getProviderRuntimeConfig("opencode")).toBeUndefined();
-    expect(store.getDaemonRuntimeConfig("routing")).toBeUndefined();
-  });
-
-  test("stores payment config and pending purchases with safe references", () => {
-    store.savePayment({
-      method: "mock",
-      enabled: true,
-      isDefault: true,
-      config: { channel: "developer" }
-    });
-    store.upsertPendingPurchase({
-      purchaseId: "pur_pending_1",
-      sellerKey: "seller-a",
-      modelId: "gpt-4",
-      paymentMethod: "mock",
-      amountUsdMicros: 1000000,
-      status: "pending",
-      paymentReference: "payCredential-secret",
-      expiresAt: "2030-01-01T00:00:00.000Z"
-    });
-
-    expect(store.listPayments()).toMatchObject([
-      { method: "mock", enabled: true, isDefault: true, config: { channel: "developer" } }
-    ]);
-    const pendingPurchases = store.listPendingPurchases();
-    expect(pendingPurchases).toMatchObject([
-      {
-        purchaseId: "pur_pending_1",
-        sellerKey: "seller-a"
-      }
-    ]);
-    expect(pendingPurchases[0]).not.toHaveProperty("paymentReference");
-    const serialized = JSON.stringify(pendingPurchases);
-    expect(serialized).not.toContain("payCredential-secret");
-    expect(serialized).toContain("paymentReferenceHash");
-  });
-
-  test("fetches and removes payment config by method", () => {
-    store.savePayment({
-      method: "mock",
-      enabled: true,
-      isDefault: true,
-      config: { channel: "developer" }
-    });
-
-    expect(store.getPayment("mock")).toMatchObject({
-      method: "mock",
-      enabled: true,
-      isDefault: true,
-      config: { channel: "developer" }
-    });
-    expect(store.removePayment("mock")).toBe(true);
-    expect(store.getPayment("mock")).toBeUndefined();
-    expect(store.removePayment("mock")).toBe(false);
-  });
-
-  test("redacts raw proof, prompt, and response from safe ledger output", () => {
-    store.recordPurchaseLedger({
-      purchaseId: "pur_done_1",
-      sellerKey: "seller-a",
-      modelId: "gpt-4",
-      paymentMethod: "mock",
-      status: "funded",
-      creditMicros: 1000000,
-      currency: "USD",
-      paymentReference: "raw-payment-proof-secret"
-    });
-    store.recordInferenceLedger({
-      requestId: "req_1",
-      sellerKey: "seller-a",
-      modelId: "gpt-4",
-      endpoint: "/v1/chat/completions",
-      status: "settled",
-      promptTokens: 10,
-      completionTokens: 20,
-      cacheReadTokens: 4,
-      billedMicros: 70,
-      settledUsdMicros: 35,
-      inputPriceMicrosPer1m: 5_000_000,
-      outputPriceMicrosPer1m: 30_000_000,
-      cacheReadPriceMicrosPer1m: 500_000,
-      inputCostMicros: 50,
-      outputCostMicros: 600,
-      cacheReadCostMicros: 2,
-      originalUsdMicros: 652,
-      billingMultiplier: 0.1,
-      serviceTier: "Standard",
-      prompt: "raw prompt secret",
-      response: "raw model response secret"
-    });
-
-    const publicOutput = JSON.stringify({
-      purchases: store.listPurchaseLedger(),
-      inferences: store.listInferenceLedger()
-    });
-
-    for (const secret of [
-      "raw-payment-proof-secret",
-      "raw prompt secret",
-      "raw model response secret",
-      "payCredential"
-    ]) {
-      expect(publicOutput).not.toContain(secret);
-    }
-    expect(publicOutput).toContain("paymentReferenceHash");
-    expect(publicOutput).toContain("promptHash");
-    expect(publicOutput).toContain("responseHash");
-    expect(publicOutput).toContain("\"cacheReadTokens\":4");
-    expect(publicOutput).toContain("\"inputPriceMicrosPer1m\":5000000");
-    expect(publicOutput).toContain("\"outputCostMicros\":600");
-    expect(publicOutput).toContain("\"originalUsdMicros\":652");
-    expect(publicOutput).toContain("\"billingMultiplier\":0.1");
-    expect(publicOutput).toContain("\"serviceTier\":\"Standard\"");
-  });
-});
-
-describe("TokenBuddy payment CLI", () => {
-  const CLI_STORE_ROOT = path.resolve(__dirname, "../../data-test/payment-cli-store");
-  let previousBuyerStore: string | undefined;
-  let previousExitCode: string | number | undefined;
-  let previousControlPort: string | undefined;
-  let previousProxyPort: string | undefined;
-  let controlServer: http.Server;
-  let controlServerOpen = false;
-  let controlPort: number;
-
-  beforeEach((done) => {
-    rmDir(CLI_STORE_ROOT);
-    previousBuyerStore = process.env.TOKENBUDDY_BUYER_STORE;
-    previousExitCode = process.exitCode;
-    previousControlPort = process.env.TB_PROXYD_CONTROL_PORT;
-    previousProxyPort = process.env.TB_PROXYD_PROXY_PORT;
-    process.env.TOKENBUDDY_BUYER_STORE = CLI_STORE_ROOT;
-    process.exitCode = undefined;
-    controlServer = http.createServer((req, res) => {
-      res.setHeader("Content-Type", "application/json");
-      if (req.url === "/status") {
-        res.end(JSON.stringify({
-          status: "running",
-          pid: 12345,
-          controlPort,
-          proxyPort: 45678
-        }));
-        return;
-      }
-      res.statusCode = 404;
-      res.end(JSON.stringify({ error: "not_found" }));
-    });
-    controlServer.listen(0, "127.0.0.1", () => {
-      controlServerOpen = true;
-      controlPort = (controlServer.address() as AddressInfo).port;
-      process.env.TB_PROXYD_CONTROL_PORT = String(controlPort);
-      process.env.TB_PROXYD_PROXY_PORT = "45678";
-      done();
-    });
-  });
-
-  afterEach((done) => {
-    if (previousBuyerStore === undefined) {
-      delete process.env.TOKENBUDDY_BUYER_STORE;
-    } else {
-      process.env.TOKENBUDDY_BUYER_STORE = previousBuyerStore;
-    }
-    if (previousControlPort === undefined) {
-      delete process.env.TB_PROXYD_CONTROL_PORT;
-    } else {
-      process.env.TB_PROXYD_CONTROL_PORT = previousControlPort;
-    }
-    if (previousProxyPort === undefined) {
-      delete process.env.TB_PROXYD_PROXY_PORT;
-    } else {
-      process.env.TB_PROXYD_PROXY_PORT = previousProxyPort;
-    }
-    process.exitCode = previousExitCode;
-    rmDir(CLI_STORE_ROOT);
-    jest.restoreAllMocks();
-    if (controlServerOpen) {
-      controlServer.close(() => {
-        controlServerOpen = false;
-        done();
-      });
-    } else {
-      done();
-    }
-  });
-
-  test("ordinary commands fail closed when tb-proxyd is not running", async () => {
-    await new Promise<void>((resolve) => controlServer.close(() => {
-      controlServerOpen = false;
-      resolve();
-    }));
-    const errors: string[] = [];
-    const program = buildCli();
-    program.exitOverride();
-    program.configureOutput({ writeErr: () => undefined });
-    jest.spyOn(console, "error").mockImplementation((message?: unknown) => {
-      errors.push(String(message));
-    });
-
-    await expect(program.parseAsync(["node", "tb", "payment", "list", "--json"])).rejects.toThrow("tb-proxyd is not running");
-    expect(errors.join("\n")).toContain("tb doctor --fix");
-    expect(errors.join("\n")).toContain("tb init");
-  });
-
-  test("payment list --json emits pure JSON with supported methods", async () => {
-    const store = new BuyerStore({ root: CLI_STORE_ROOT });
-    store.savePayment({
-      method: "mock",
-      enabled: true,
-      isDefault: true,
-      config: { channel: "developer", explicitOptIn: true }
-    });
-    store.close();
-
-    const output: string[] = [];
-    jest.spyOn(console, "log").mockImplementation((message?: unknown) => {
-      output.push(String(message));
-    });
-
-    const program = buildCli();
-    await program.parseAsync(["node", "tb", "payment", "list", "--json"]);
-
-    expect(output).toHaveLength(1);
-    const parsed = JSON.parse(output[0]) as any;
-    expect(parsed.payments).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        method: "mock",
-        supported: true,
-        configured: true,
-        enabled: true,
-        isDefault: true
-      }),
-      expect.objectContaining({
-        method: "clawtip",
-        supported: true,
-        configured: false
-      })
-    ]));
-    expect(output[0]).not.toContain("payCredential");
-    expect(output[0]).not.toContain("encryptedData");
-  });
-
-  test("payment add/remove mock updates the buyer store", async () => {
-    const logs: string[] = [];
-    jest.spyOn(console, "log").mockImplementation((message?: unknown) => {
-      logs.push(String(message));
-    });
-
-    await buildCli().parseAsync(["node", "tb", "payment", "add", "mock"]);
-    let store = new BuyerStore({ root: CLI_STORE_ROOT });
-    expect(store.getPayment("mock")).toMatchObject({
-      method: "mock",
-      enabled: true,
-      isDefault: true,
-      config: { channel: "developer", explicitOptIn: true }
-    });
-    store.close();
-
-    await buildCli().parseAsync(["node", "tb", "payment", "remove", "mock"]);
-    store = new BuyerStore({ root: CLI_STORE_ROOT });
-    expect(store.getPayment("mock")).toBeUndefined();
-    store.close();
-    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", () => {
-  test("init hides mock payment and shows coming-soon agent wallets as unavailable", () => {
-    const noteMessages: string[] = [];
-    noteInitComingSoonPayments((message?: string) => {
-      noteMessages.push(String(message || ""));
-    });
-
-    expect(INIT_PAYMENT_OPTIONS).toEqual([
-      expect.objectContaining({ value: "clawtip" })
-    ]);
-    expect(INIT_PAYMENT_OPTIONS.map((option) => option.value)).not.toContain("mock");
-
-    const notes = noteMessages.join("\n");
-    expect(INIT_COMING_SOON_PAYMENT_OPTIONS).toEqual(expect.arrayContaining([
-      expect.objectContaining({ id: "wechat-pay", label: "WeChat Pay" }),
-      expect.objectContaining({ id: "alipay-agent-payment", label: "Alipay Agent Payment" }),
-      expect.objectContaining({ id: "coinbase-smart-wallet", label: "Coinbase Smart Wallet" })
-    ]));
-    expect(notes).toContain("WeChat Pay（接入中）");
-    expect(notes).toContain("Alipay Agent Payment（接入中）");
-    expect(notes).toContain("Coinbase Smart Wallet（接入中）");
-  });
-
-  test("detects an existing local clawtip binding from saved payment config", () => {
-    const binding = detectExistingClawtipBinding({
-      method: "clawtip",
-      enabled: false,
-      isDefault: false,
-      updatedAt: "2026-05-30T00:00:00.000Z",
-      config: {
-        orderNo: "order_123",
-        resourceUrl: "https://example.test/pay"
-      }
-    });
-
-    expect(binding).toEqual(expect.objectContaining({
-      orderNo: "order_123",
-      resourceUrl: "https://example.test/pay",
-      config: expect.objectContaining({
-        orderNo: "order_123",
-        resourceUrl: "https://example.test/pay"
-      })
-    }));
-  });
-
-  test("requires the OpenClaw wallet config before reusing ClawTip metadata", () => {
-    const payment: PaymentConfig = {
-      method: "clawtip",
-      enabled: true,
-      isDefault: true,
-      updatedAt: "2026-05-30T00:00:00.000Z",
-      config: {
-        orderNo: "order_123",
-        resourceUrl: "https://example.test/pay"
-      }
-    };
-
-    const missingWallet = inspectClawtipWalletReadiness(payment, {
-      expectedPath: "/tmp/home/.openclaw/configs/config.json",
-      configsDirExists: true,
-      exists: false,
-      alternatePaths: ["/tmp/home/.openclaw/configs/config.json.bak"]
-    });
-    expect(missingWallet.status).toBe("metadata_missing_wallet");
-    expect(missingWallet.savedBinding?.orderNo).toBe("order_123");
-    expect(missingWallet.reusableBinding).toBeUndefined();
-
-    const readyWallet = inspectClawtipWalletReadiness(payment, {
-      expectedPath: "/tmp/home/.openclaw/configs/config.json",
-      configsDirExists: true,
-      exists: true,
-      alternatePaths: []
-    });
-    expect(readyWallet.status).toBe("ready");
-    expect(readyWallet.reusableBinding?.orderNo).toBe("order_123");
-  });
-
-  test("detects renamed OpenClaw wallet config files as nearby files", () => {
-    const home = path.join(TEMP_STORE_ROOT, "openclaw-home");
-    const configsDir = path.join(home, ".openclaw", "configs");
-    rmDir(home);
-    fs.mkdirSync(configsDir, { recursive: true });
-    fs.writeFileSync(path.join(configsDir, "config.json.bak"), "{}", "utf8");
-
-    const wallet = inspectOpenClawWalletConfig(home);
-
-    expect(wallet.exists).toBe(false);
-    expect(wallet.configsDirExists).toBe(true);
-    expect(wallet.expectedPath).toBe(path.join(configsDir, "config.json"));
-    expect(wallet.alternatePaths).toEqual([
-      path.join(configsDir, "config.json.bak")
-    ]);
-  });
-
-  test("builds a clear init success message with summary lines", () => {
-    const message = buildInitSuccessMessage([
-      "2 programming terminals configured for TokenBuddy.",
-      "ClawTip wallet already bound locally; activation skipped."
-    ]);
-
-    expect(message).toContain("✅ TokenBuddy setup completed successfully.");
-    expect(message).toContain("- 2 programming terminals configured for TokenBuddy.");
-    expect(message).toContain("- ClawTip wallet already bound locally; activation skipped.");
-    expect(message).toContain("Run `tb doctor` to audit status anytime.");
-  });
-
-  test("builds terminal selection with configured entries separated from selectable options", () => {
-    const selection = buildInitTerminalSelectionState([
-      {
-        id: "codex",
-        name: "Codex CLI",
-        detected: true,
-        configured: true,
-        status: "configured",
-        configPath: "/tmp/codex.toml",
-        reason: "Configured at ~/.codex/config.toml"
-      },
-      {
-        id: "hermes",
-        name: "Hermes Terminal",
-        detected: true,
-        configured: false,
-        status: "installed",
-        configPath: "/tmp/hermes.json",
-        reason: "Installed, TokenBuddy config missing"
-      }
-    ]);
-
-    expect(selection.installed).toEqual([
-      expect.objectContaining({
-        value: "codex",
-        label: "Codex CLI（已安装）"
-      })
-    ]);
-    expect(selection.options).toEqual([
-      expect.objectContaining({
-        value: "hermes",
-        label: "Hermes Terminal"
-      }),
-      expect.objectContaining({
-        value: OTHER_TERMINAL_OPTION.value,
-        label: OTHER_TERMINAL_OPTION.label
-      })
-    ]);
-  });
-
-  test("requires at least one terminal choice", () => {
-    expect(validateInitTerminalSelection([])).toBe("Select at least one terminal or choose Other.");
-    expect(validateInitTerminalSelection(["other"])).toBeUndefined();
-    expect(validateInitTerminalSelection(["hermes"])).toBeUndefined();
-  });
-
-  test("waits for ClawTip scan confirmation until the wallet config appears", async () => {
-    let attempts = 0;
-    const inspectWalletConfig = jest.fn(() => {
-      attempts += 1;
-      return {
-        expectedPath: "/tmp/home/.openclaw/configs/config.json",
-        configsDirExists: true,
-        exists: attempts >= 3,
-        alternatePaths: []
-      };
-    });
-    const sleep = jest.fn(async () => undefined);
-
-    await expect(waitForClawtipActivationConfirmation({
-      inspectWalletConfig,
-      pollIntervalMs: 10,
-      sleep,
-    })).resolves.toBe(true);
-
-    expect(inspectWalletConfig).toHaveBeenCalledTimes(3);
-    expect(sleep).toHaveBeenCalledTimes(2);
-  });
-
-  test("cancels ClawTip scan confirmation on Ctrl+C", async () => {
-    const cancelled = jest.fn();
-    await expect(
-      waitForClawtipActivationConfirmation({
-        inspectWalletConfig: () => ({
-          expectedPath: "/tmp/home/.openclaw/configs/config.json",
-          configsDirExists: true,
-          exists: false,
-          alternatePaths: []
-        }),
-        isCancelled: () => true,
-        cancel: cancelled,
-        pollIntervalMs: 10,
-        sleep: async () => undefined,
-      })
-    ).resolves.toBe(false);
-
-    expect(cancelled).toHaveBeenCalledWith("ClawTip activation cancelled.");
-  });
-
-  test("parses ClawTip auth URL and clawtipId from pay CLI output", () => {
-    const parsed = parseClawtipCliOutput(
-      "请扫码 https://clawtip.jd.com/qrcode?foo=1&clawtipId=device-789 完成授权"
-    );
-
-    expect(parsed.requiresWalletAuth).toBe(true);
-    expect(parsed.authUrl).toBe("https://clawtip.jd.com/qrcode?foo=1&clawtipId=device-789");
-    expect(parsed.clawtipId).toBe("device-789");
-  });
-
-  test("ignores bootstrap env endpoint noise when parsing the real ClawTip auth URL", () => {
-    const parsed = parseClawtipCliOutput([
-      "process.env.CLAWTIP_PAY https://ms.jr.jd.com/gw2/generic/hyqy/h5/m/clawtipPay",
-      "请扫码 https://idt.jd.com/unifiedAuthM/plat/safeMonitor/?authFlowUid=abc 完成授权",
-    ].join("\n"));
-
-    expect(parsed.authUrl).toBe(
-      "https://idt.jd.com/unifiedAuthM/plat/safeMonitor/?authFlowUid=abc"
-    );
-  });
-
-  test("parses the official ClawTip wallet QR image path", () => {
-    const parsed = parseClawtipCliOutput([
-      "从 .env.prod 加载环境变量",
-      "/Users/test/.openclaw/workspace/clawtip/qrcode/clawtip-index-code.png",
-    ].join("\n"));
-
-    expect(parsed.mediaPath).toBe("/Users/test/.openclaw/workspace/clawtip/qrcode/clawtip-index-code.png");
-    expect(parsed.requiresWalletAuth).toBe(true);
-  });
-
-  test("resolves npx next to the Node executable when PATH is sparse", () => {
-    const resolved = resolveNpxCommand({
-      execPath: "/opt/homebrew/Cellar/node/26.0.0/bin/node",
-      envPath: "/usr/bin:/bin",
-      exists: (filePath) => filePath === "/opt/homebrew/Cellar/node/26.0.0/bin/npx",
-    });
-
-    expect(resolved).toBe("/opt/homebrew/Cellar/node/26.0.0/bin/npx");
-  });
-
-  test("falls back to npx command name when no absolute candidate exists", () => {
-    expect(resolveNpxCommand({
-      execPath: "/missing/bin/node",
-      envPath: "/usr/bin:/bin",
-      exists: () => false,
-    })).toBe("npx");
-  });
-
-  test("surfaces ClawTip upstream payment errors directly", async () => {
-    const parsed = parseClawtipCliOutput("ClawTip 返回错误：商家信息有误");
-
-    expect(parsed.failureMessage).toContain("商家信息有误");
-    await expect(startClawtipWalletBootstrap({
-      orderNo: "order_error",
-      amountFen: 1,
-      payTo: "pay-to-test",
-      encryptedData: "ciphertext",
-      indicator: "indicator_error",
-      slug: "tb-registry",
-      skillId: "si-tb-registry",
-      description: "TokenBuddy ClawTip wallet activation",
-      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",
-      clawtipId: "device-789",
-      mediaPath: "/tmp/clawtip/qrcode-1.png",
-      requiresWalletAuth: true,
-      walletReady: false,
-    }, "/tmp/orders/order-1.json")).toBe("/tmp/clawtip/qrcode-1.png");
-  });
-
-  test("fails ClawTip QR resolution when pay CLI emits no QR source", () => {
-    expect(() => resolveClawtipQrMediaPath({
-      authUrl: undefined,
-      clawtipId: undefined,
-      mediaPath: undefined,
-      requiresWalletAuth: false,
-      walletReady: false,
-    }, "/tmp/orders/order-1.json")).toThrow("ClawTip pay did not return a QR media file.");
-  });
-
-  test("checks OpenClaw before ClawTip wallet bootstrap", async () => {
-    const calls: string[][] = [];
-    const openClawVersion = await checkOpenClawRuntime({
-      runOpenClawCommand: async (args) => {
-        calls.push(["openclaw", ...args]);
-        return "OpenClaw 2026.5.18";
-      },
-    });
-
-    expect(openClawVersion).toBe("OpenClaw 2026.5.18");
-    expect(calls).toEqual([
-      ["openclaw", "--version"],
-    ]);
-  });
-
-  test("normalizes the bootstrap resource URL away from the public registry endpoint", () => {
-    expect(normalizeClawtipBootstrapResourceUrl(
-      "https://tb-registry.fly.dev",
-      "https://tb-registry.fly.dev/registry/sellers"
-    )).toBe("https://tb-registry.fly.dev");
-
-    expect(normalizeClawtipBootstrapResourceUrl(
-      "https://tb-registry.fly.dev/base",
-      "https://tb-registry.fly.dev/registry/sellers"
-    )).toBe("https://tb-registry.fly.dev/base");
-
-    expect(normalizeClawtipBootstrapResourceUrl(
-      "https://tb-registry.fly.dev",
-      "https://example.test/pay"
-    )).toBe("https://example.test/pay");
-  });
-
-  test("rejects a bootstrap response that still uses the placeholder ClawTip payTo", async () => {
-    const originalFetch = global.fetch;
-    global.fetch = jest.fn(async () => new Response(JSON.stringify({
-      activationFeeFen: 1,
-      payment: {
-        orderNo: "order_placeholder",
-        indicator: "indicator_placeholder",
-        payTo: "bootstrap-pay-to",
-        resourceUrl: "https://registry.tokenbuddy.ai/v1/registry.json",
-      }
-    }), {
-      status: 200,
-      headers: { "Content-Type": "application/json" }
-    })) as typeof fetch;
-
-    try {
-      await expect(fetchClawtipBootstrap("https://tb-registry.fly.dev")).rejects.toThrow(
-        "ClawTip bootstrap service is misconfigured: payTo is still the placeholder"
-      );
-    } finally {
-      global.fetch = originalFetch;
-    }
-  });
-
-  test("writes the Rust-compatible ClawTip order file shape", () => {
-    const home = path.join(TEMP_STORE_ROOT, "clawtip-order-home");
-    rmDir(home);
-
-    const orderFile = writeClawtipOrderFile({
-      orderNo: "order_123",
-      amountFen: 1,
-      payTo: "pay-to-test",
-      encryptedData: "ciphertext",
-      indicator: "indicator_123",
-      slug: "tb-registry",
-      skillId: "si-tb-registry",
-      description: "TokenBuddy ClawTip wallet activation",
-      resourceUrl: "https://tb-registry.fly.dev"
-    }, home);
-
-    expect(orderFile).toBe(path.join(
-      home,
-      ".openclaw",
-      "skills",
-      "orders",
-      "indicator_123",
-      "order_123.json"
-    ));
-
-    const saved = JSON.parse(fs.readFileSync(orderFile, "utf8"));
-    expect(saved).toEqual(expect.objectContaining({
-      "skill-id": "si-tb-registry",
-      order_no: "order_123",
-      amount: 1,
-      encrypted_data: "ciphertext",
-      pay_to: "pay-to-test",
-      slug: "tb-registry",
-      resource_url: "https://tb-registry.fly.dev"
-    }));
-  });
-
-  test("starts ClawTip payment activation and reads payCredential from the order file", async () => {
-    const home = path.join(TEMP_STORE_ROOT, "clawtip-bootstrap-home");
-    rmDir(home);
-
-    const activation = await startClawtipWalletBootstrap({
-      orderNo: "order_456",
-      amountFen: 1,
-      payTo: "pay-to-test",
-      encryptedData: "ciphertext",
-      indicator: "indicator_456",
-      slug: "tb-registry",
-      skillId: "si-tb-registry",
-      description: "TokenBuddy ClawTip wallet activation",
-      resourceUrl: "https://tb-registry.fly.dev"
-    }, {
-      home,
-      runClawtipCommand: async () => {
-        const orderFile = path.join(
-          home,
-          ".openclaw",
-          "skills",
-          "orders",
-          "indicator_456",
-          "order_456.json"
-        );
-        const order = JSON.parse(fs.readFileSync(orderFile, "utf8"));
-        order.payCredential = "credential_456";
-        fs.writeFileSync(orderFile, JSON.stringify(order, null, 2), "utf8");
-        return "已获取到支付凭证";
-      }
-    });
-
-    expect(activation.orderFile).toBe(path.join(
-      home,
-      ".openclaw",
-      "skills",
-      "orders",
-      "indicator_456",
-      "order_456.json"
-    ));
-    expect(activation.payCredential).toBe("credential_456");
-    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);
-
-    const activation = await startClawtipWalletBootstrap({
-      orderNo: "order_789",
-      amountFen: 1,
-      payTo: "pay-to-test",
-      encryptedData: "ciphertext",
-      indicator: "indicator_789",
-      slug: "tb-registry",
-      skillId: "si-tb-registry",
-      description: "TokenBuddy ClawTip wallet activation",
-      resourceUrl: "https://tb-registry.fly.dev"
-    }, {
-      home,
-      runClawtipCommand: async () => {
-        const qrDir = path.join(home, ".openclaw", "workspace", "clawtip", "qrcode");
-        fs.mkdirSync(qrDir, { recursive: true });
-        const qrPath = path.join(qrDir, "qrcode-generated.png");
-        fs.writeFileSync(qrPath, "png", "utf8");
-        return [
-          "process.env.CLAWTIP_PAY https://ms.jr.jd.com/gw2/generic/hyqy/h5/m/clawtipPay",
-          "请扫码 https://idt.jd.com/unifiedAuthM/plat/safeMonitor/?authFlowUid=abc 完成授权",
-        ].join("\n");
-      }
-    });
-
-    expect(activation.parsedOutput.authUrl).toBe(
-      "https://idt.jd.com/unifiedAuthM/plat/safeMonitor/?authFlowUid=abc"
-    );
-    expect(activation.parsedOutput.mediaPath).toBe(
-      path.join(home, ".openclaw", "workspace", "clawtip", "qrcode", "qrcode-generated.png")
-    );
-  });
-
-  test("recovers ClawTip QR media even when pay output only writes payCredential", async () => {
-    const home = path.join(TEMP_STORE_ROOT, "clawtip-bootstrap-credential-and-qr-home");
-    rmDir(home);
-
-    const activation = await startClawtipWalletBootstrap({
-      orderNo: "order_credential_qr",
-      amountFen: 1,
-      payTo: "pay-to-test",
-      encryptedData: "ciphertext",
-      indicator: "indicator_credential_qr",
-      slug: "tb-registry",
-      skillId: "si-tb-registry",
-      description: "TokenBuddy ClawTip wallet activation",
-      resourceUrl: "https://tb-registry.fly.dev"
-    }, {
-      home,
-      runClawtipCommand: async () => {
-        const orderFile = path.join(
-          home,
-          ".openclaw",
-          "skills",
-          "orders",
-          "indicator_credential_qr",
-          "order_credential_qr.json"
-        );
-        const order = JSON.parse(fs.readFileSync(orderFile, "utf8"));
-        order.payCredential = "credential_without_wallet_config";
-        fs.writeFileSync(orderFile, JSON.stringify(order, null, 2), "utf8");
-
-        const qrDir = path.join(home, ".openclaw", "workspace", "clawtip", "qrcode");
-        fs.mkdirSync(qrDir, { recursive: true });
-        const qrPath = path.join(qrDir, "qrcode-credential.png");
-        fs.writeFileSync(qrPath, "png", "utf8");
-        return "已获取到支付凭证";
-      }
-    });
-
-    expect(activation.payCredential).toBe("credential_without_wallet_config");
-    expect(activation.parsedOutput.requiresWalletAuth).toBe(true);
-    expect(activation.parsedOutput.mediaPath).toBe(
-      path.join(home, ".openclaw", "workspace", "clawtip", "qrcode", "qrcode-credential.png")
-    );
-  });
-
-  test("doctor prompts tb init when no ClawTip wallet is available", () => {
-    const lines: string[] = [];
-
-    printDoctorClawtipWallet({
-      status: "missing",
-      ready: false,
-      paymentMetadataPresent: false,
-      walletConfigPresent: false,
-      configsDirExists: false,
-      expectedPath: "/tmp/home/.openclaw/configs/config.json",
-      alternatePaths: [],
-      message: "ClawTip payment metadata and local OpenClaw wallet config are not configured.",
-    }, (line) => {
-      lines.push(line);
-    });
-
-    expect(lines.join("\n")).toContain(
-      "Action: Run `tb init` and choose ClawTip to bind a wallet before using ClawTip-backed purchases."
-    );
-  });
-});
-
-describe("TokenBuddy terminal image display", () => {
-  const imagePath = "/Users/test/.openclaw/workspace/clawtip/qrcode/clawtip-index-code.png";
-
-  test("detects inline image capable terminals only when stdout is a TTY", () => {
-    expect(detectTerminalImageDisplay({
-      env: { TERM_PROGRAM: "iTerm.app" },
-      stdoutIsTTY: true,
-    })).toBe("iterm");
-    expect(detectTerminalImageDisplay({
-      env: { WEZTERM_EXECUTABLE: "/Applications/WezTerm.app/wezterm" },
-      stdoutIsTTY: true,
-    })).toBe("iterm");
-    expect(detectTerminalImageDisplay({
-      env: { KITTY_WINDOW_ID: "1" },
-      stdoutIsTTY: true,
-    })).toBe("kitty");
-    expect(detectTerminalImageDisplay({
-      env: { TERM_PROGRAM: "iTerm.app" },
-      stdoutIsTTY: false,
-    })).toBeUndefined();
-  });
-
-  test("renders the ClawTip QR image inline for iTerm2-compatible terminals", async () => {
-    const writes: string[] = [];
-    const runCommand = jest.fn(async () => undefined);
-
-    const result = await displayTerminalImage(imagePath, {
-      env: { TERM_PROGRAM: "iTerm.app" },
-      stdoutIsTTY: true,
-      fileExists: () => true,
-      readFile: () => Buffer.from("png-bytes"),
-      write: (chunk) => {
-        writes.push(chunk);
-      },
-      runCommand,
-    });
-
-    expect(result).toEqual(expect.objectContaining({
-      method: "inline-iterm",
-      displayed: true,
-    }));
-    expect(writes.join("")).toContain("\u001B]1337;File=");
-    expect(writes.join("")).toContain("inline=1");
-    expect(runCommand).not.toHaveBeenCalled();
-  });
-
-  test("renders the ClawTip QR image inline for Kitty terminals", async () => {
-    const writes: string[] = [];
-
-    const result = await displayTerminalImage(imagePath, {
-      env: { TERM: "xterm-kitty" },
-      stdoutIsTTY: true,
-      fileExists: () => true,
-      write: (chunk) => {
-        writes.push(chunk);
-      },
-    });
-
-    expect(result).toEqual(expect.objectContaining({
-      method: "inline-kitty",
-      displayed: true,
-    }));
-    expect(writes.join("")).toContain("\u001B_Ga=T,t=f,f=100,c=60;");
-  });
-
-  test("opens the ClawTip QR image with the system viewer when inline images are unsupported", async () => {
-    const runCommand = jest.fn(async () => undefined);
-
-    const result = await displayTerminalImage(imagePath, {
-      env: { TERM_PROGRAM: "Apple_Terminal" },
-      platform: "darwin",
-      stdoutIsTTY: true,
-      fileExists: () => true,
-      runCommand,
-    });
-
-    expect(result).toEqual(expect.objectContaining({
-      method: "system-open",
-      displayed: true,
-      fallbackCommand: `open ${imagePath}`,
-    }));
-    expect(runCommand).toHaveBeenCalledWith("open", [imagePath]);
-  });
-
-  test("falls back to a manual open command when the system viewer fails", async () => {
-    const result = await displayTerminalImage(imagePath, {
-      env: {},
-      platform: "darwin",
-      stdoutIsTTY: true,
-      fileExists: () => true,
-      runCommand: async () => {
-        throw new Error("no gui session");
-      },
-    });
-
-    expect(result).toEqual(expect.objectContaining({
-      method: "manual",
-      displayed: false,
-      fallbackCommand: `open ${imagePath}`,
-    }));
-    expect(result.message).toContain("no gui session");
-  });
-});
-
-describe("TokenBuddy JSON inspection commands", () => {
-  let controlServer: http.Server;
-  let proxyServer: http.Server;
-  let controlPort: number;
-  let proxyPort: number;
-  let previousControlPort: string | undefined;
-  let previousProxyPort: string | undefined;
-  let previousBuyerStoreRoot: string | undefined;
-  let previousHome: string | undefined;
-
-  beforeEach((done) => {
-    previousControlPort = process.env.TB_PROXYD_CONTROL_PORT;
-    previousProxyPort = process.env.TB_PROXYD_PROXY_PORT;
-    previousBuyerStoreRoot = process.env.TOKENBUDDY_BUYER_STORE;
-    previousHome = process.env.HOME;
-    rmDir(INSPECTION_STORE_ROOT);
-    rmDir(INSPECTION_HOME);
-    process.env.TOKENBUDDY_BUYER_STORE = INSPECTION_STORE_ROOT;
-    process.env.HOME = INSPECTION_HOME;
-    fs.mkdirSync(path.join(INSPECTION_HOME, ".openclaw", "configs"), { recursive: true });
-    fs.writeFileSync(path.join(INSPECTION_HOME, ".openclaw", "configs", "config.json.bak"), "{}", "utf8");
-    const store = new BuyerStore();
-    store.savePayment({
-      method: "clawtip",
-      enabled: true,
-      isDefault: true,
-      config: {
-        orderNo: "order_json",
-        resourceUrl: "https://example.test/pay"
-      }
-    });
-    store.close();
-    proxyServer = http.createServer((req, res) => {
-      res.setHeader("Content-Type", "application/json");
-      if (req.url === "/v1/models") {
-        res.end(JSON.stringify({
-          object: "list",
-          data: [
-            { id: "gpt-4", sellerId: "json-test-seller" }
-          ]
-        }));
-        return;
-      }
-      res.statusCode = 404;
-      res.end(JSON.stringify({ error: "not_found" }));
-    });
-    controlServer = http.createServer((req, res) => {
-      res.setHeader("Content-Type", "application/json");
-      if (req.url === "/health") {
-        res.end(JSON.stringify({
-          status: "ok",
-          controlPort,
-          proxyPort
-        }));
-        return;
-      }
-      if (req.url === "/status") {
-        res.end(JSON.stringify({
-          status: "running",
-          pid: 12345,
-          controlPort,
-          proxyPort
-        }));
-        return;
-      }
-      if (req.url === "/sellers") {
-        res.end(JSON.stringify({
-          registryUrl: "https://example.test/registry/sellers",
-          version: 7,
-          defaultSeller: "json-test-seller",
-          sellers: [
-            {
-              id: "json-test-seller",
-              name: "JSON Seller",
-              url: "https://seller.example.test",
-              supportedProtocols: ["responses"],
-              paymentMethods: ["mock"],
-              discountRatio: 0.25,
-              status: "configured"
-            }
-          ]
-        }));
-        return;
-      }
-      if (req.url === "/models") {
-        res.end(JSON.stringify({
-          object: "list",
-          registryUrl: "https://example.test/registry/sellers",
-          data: [
-            {
-              id: "gpt-4",
-              sellerId: "json-test-seller",
-              sellerName: "JSON Seller",
-              sellerUrl: "https://seller.example.test",
-              supportedProtocols: ["responses"],
-              paymentMethods: ["mock"],
-              inputPriceMicrosPer1m: 1000000,
-              outputPriceMicrosPer1m: 3000000
-            }
-          ],
-          sellers: [
-            {
-              id: "json-test-seller",
-              name: "JSON Seller",
-              url: "https://seller.example.test",
-              supportedProtocols: ["responses"],
-              paymentMethods: ["mock"],
-              discountRatio: 0.25,
-              status: "ok",
-              modelCount: 1
-            }
-          ]
-        }));
-        return;
-      }
-      res.statusCode = 404;
-      res.end(JSON.stringify({ error: "not_found" }));
-    });
-    proxyServer.listen(0, "127.0.0.1", () => {
-      proxyPort = (proxyServer.address() as AddressInfo).port;
-      controlServer.listen(0, "127.0.0.1", () => {
-        controlPort = (controlServer.address() as AddressInfo).port;
-        process.env.TB_PROXYD_CONTROL_PORT = String(controlPort);
-        process.env.TB_PROXYD_PROXY_PORT = String(proxyPort);
-        done();
-      });
-    });
-  });
-
-  afterEach((done) => {
-    if (previousControlPort === undefined) {
-      delete process.env.TB_PROXYD_CONTROL_PORT;
-    } else {
-      process.env.TB_PROXYD_CONTROL_PORT = previousControlPort;
-    }
-    if (previousProxyPort === undefined) {
-      delete process.env.TB_PROXYD_PROXY_PORT;
-    } else {
-      process.env.TB_PROXYD_PROXY_PORT = previousProxyPort;
-    }
-    if (previousBuyerStoreRoot === undefined) {
-      delete process.env.TOKENBUDDY_BUYER_STORE;
-    } else {
-      process.env.TOKENBUDDY_BUYER_STORE = previousBuyerStoreRoot;
-    }
-    if (previousHome === undefined) {
-      delete process.env.HOME;
-    } else {
-      process.env.HOME = previousHome;
-    }
-    jest.restoreAllMocks();
-    controlServer.close(() => proxyServer.close(() => {
-      rmDir(INSPECTION_STORE_ROOT);
-      rmDir(INSPECTION_HOME);
-      done();
-    }));
-  });
-
-  test("doctor --json reports daemon and provider state", async () => {
-    const output: string[] = [];
-    jest.spyOn(console, "log").mockImplementation((message?: unknown) => {
-      output.push(String(message));
-    });
-
-    await buildCli().parseAsync(["node", "tb", "doctor", "--json"]);
-
-    expect(output).toHaveLength(1);
-    const parsed = JSON.parse(output[0]) as any;
-    expect(parsed.daemon).toMatchObject({
-      running: true,
-      controlPort,
-      proxyPort,
-      fixAvailable: true
-    });
-    expect(parsed.repair).toMatchObject({
-      requested: false,
-      attempted: false,
-      fixed: false
-    });
-    expect(parsed.access).toMatchObject({
-      token: "TOKENBUDDY_PROXY",
-      controlBaseUrl: `http://127.0.0.1:${controlPort}`,
-      proxyBaseUrl: `http://127.0.0.1:${proxyPort}`,
-    });
-    expect(parsed.access.endpoints).toEqual(expect.arrayContaining([
-      expect.objectContaining({ id: "control.health", available: true }),
-      expect.objectContaining({ id: "proxy.openai", available: true, token: "TOKENBUDDY_PROXY" })
-    ]));
-    expect(parsed.sellers).toMatchObject({
-      available: true,
-      registryUrl: "https://example.test/registry/sellers",
-      defaultSeller: "json-test-seller",
-    });
-    expect(parsed.models).toMatchObject({
-      available: true,
-      count: 1,
-      registryUrl: "https://example.test/registry/sellers",
-    });
-    expect(parsed.clawtipWallet).toMatchObject({
-      status: "metadata_missing_wallet",
-      ready: false,
-      paymentMetadataPresent: true,
-      walletConfigPresent: false,
-      expectedPath: path.join(INSPECTION_HOME, ".openclaw", "configs", "config.json"),
-      alternatePaths: [
-        path.join(INSPECTION_HOME, ".openclaw", "configs", "config.json.bak")
-      ]
-    });
-    expect(parsed.providers).toEqual(expect.arrayContaining([
-      expect.objectContaining({ id: "codex" }),
-      expect.objectContaining({ id: "claude-code" })
-    ]));
-  });
-
-  test("doctor prints progress messages without repeating the model list", async () => {
-    const output: string[] = [];
-    jest.spyOn(console, "log").mockImplementation((message?: unknown) => {
-      output.push(String(message));
-    });
-
-    await buildCli().parseAsync(["node", "tb", "doctor"]);
-
-    const joined = output.join("\n");
-    expect(joined).toContain("--- ClawTip Wallet ---");
-    expect(joined).toContain("❌ ClawTip Wallet [metadata_missing_wallet]");
-    expect(joined).toContain("Payment metadata: present");
-    expect(joined).toContain("Wallet config: missing");
-    expect(joined).toContain("Checking local control plane and proxy endpoints...");
-    expect(joined).toContain("Refreshing seller registry...");
-    expect(joined).toContain("Model catalog hidden in `tb doctor`. Run `tb models` for the current model summary.");
-    expect(joined).not.toContain("Unique models:");
-  });
-
-  test("models --json returns daemon model data", async () => {
-    const output: string[] = [];
-    jest.spyOn(console, "log").mockImplementation((message?: unknown) => {
-      output.push(String(message));
-    });
-
-    await buildCli().parseAsync(["node", "tb", "models", "--json"]);
-
-    expect(output).toHaveLength(1);
-    const parsed = JSON.parse(output[0]) as any;
-    expect(parsed.grouped).toEqual([
-      expect.objectContaining({
-        id: "gpt-4",
-        sellerCount: 1,
-        discountRange: "2.5折",
-        priceRange: "in $1 / out $3"
-      })
-    ]);
-  });
-
-  test("models prints the doctor-style grouped model summary", async () => {
-    const output: string[] = [];
-    jest.spyOn(console, "log").mockImplementation((message?: unknown) => {
-      output.push(String(message));
-    });
-
-    await buildCli().parseAsync(["node", "tb", "models"]);
-
-    const joined = output.join("\n");
-    expect(joined).toContain("Model catalog refresh complete.");
-    expect(joined).toContain("Unique models: 1");
-    expect(joined).toContain("Seller offers: 1");
-    expect(joined).toContain("Model ID");
-    expect(joined).toContain("Seller Count");
-    expect(joined).toContain("Discount Range");
-    expect(joined).toContain("Price Range");
-    expect(joined).toContain("gpt-4");
-    expect(joined).toContain("2.5折");
-    expect(joined).toContain("$1");
-    expect(joined).toContain("$3");
-  });
-});
-
-describe("Provider install planning", () => {
-  const PROVIDER_HOME = path.resolve(__dirname, "../../data-test/provider-home");
-  const PROVIDER_STORE_ROOT = path.resolve(__dirname, "../../data-test/provider-store");
-  const PROVIDER_BIN_ROOT = path.resolve(__dirname, "../../data-test/provider-bin");
-  const proxyUrl = "http://127.0.0.1:17821";
-  let previousPath: string | undefined;
-
-  function writeExecutable(name: string): void {
-    const executablePath = path.join(PROVIDER_BIN_ROOT, name);
-    fs.writeFileSync(executablePath, "#!/bin/sh\nexit 0\n", "utf8");
-    fs.chmodSync(executablePath, 0o755);
-  }
-
-  beforeEach(() => {
-    rmDir(PROVIDER_HOME);
-    rmDir(PROVIDER_STORE_ROOT);
-    rmDir(PROVIDER_BIN_ROOT);
-    fs.mkdirSync(path.join(PROVIDER_HOME, ".codex"), { recursive: true });
-    fs.mkdirSync(path.join(PROVIDER_HOME, ".claude"), { recursive: true });
-    fs.mkdirSync(path.join(PROVIDER_HOME, ".openclaw"), { recursive: true });
-    fs.mkdirSync(path.join(PROVIDER_HOME, ".config", "opencode"), { recursive: true });
-    fs.mkdirSync(PROVIDER_BIN_ROOT, { recursive: true });
-    writeExecutable("codex");
-    writeExecutable("claude");
-    writeExecutable("openclaw");
-    writeExecutable("opencode");
-    writeExecutable("hermes");
-    previousPath = process.env.PATH;
-    process.env.PATH = `${PROVIDER_BIN_ROOT}${path.delimiter}${previousPath || ""}`;
-    fs.writeFileSync(path.join(PROVIDER_HOME, ".codex", "config.toml"), "approval_policy = \"never\"\n", "utf8");
-    fs.writeFileSync(path.join(PROVIDER_HOME, ".claude", "settings.json"), JSON.stringify({ theme: "dark" }, null, 2), "utf8");
-    fs.writeFileSync(path.join(PROVIDER_HOME, ".openclaw", "openclaw.json"), JSON.stringify({
-      keep: "field",
-      models: {
-        providers: {
-          existing: {
-            baseUrl: "https://example.invalid/v1",
-            models: [{ id: "existing-model", name: "existing-model" }],
-          },
-        },
-      },
-      agents: {
-        defaults: {
-          model: "existing/existing-model",
-        },
-      },
-    }, null, 2), "utf8");
-    fs.writeFileSync(path.join(PROVIDER_HOME, ".config", "opencode", "opencode.json"), JSON.stringify({ share: "disabled" }, null, 2), "utf8");
-  });
-
-  afterEach(() => {
-    rmDir(PROVIDER_HOME);
-    rmDir(PROVIDER_STORE_ROOT);
-    rmDir(PROVIDER_BIN_ROOT);
-    if (previousPath === undefined) {
-      delete process.env.PATH;
-    } else {
-      process.env.PATH = previousPath;
-    }
-  });
-
-  test("detects providers and previews without mutating files", () => {
-    const codexBefore = fs.readFileSync(path.join(PROVIDER_HOME, ".codex", "config.toml"), "utf8");
-    const providers = detectProviders({ home: PROVIDER_HOME });
-    expect(providers).toEqual(expect.arrayContaining([
-      expect.objectContaining({ id: "codex", status: "configured", configured: true }),
-      expect.objectContaining({ id: "claude-code", status: "configured", configured: true }),
-      expect.objectContaining({ id: "openclaw", status: "installed", configured: false }),
-      expect.objectContaining({ id: "hermes", status: "installed", configured: false })
-    ]));
-
-    const changes = previewProviderInstall({
-      providers: ["codex", "claude-code", "openclaw", "hermes"],
-      proxyUrl,
-      providerSelections: {
-        codex: {
-          selectionKind: "single-model",
-          protocolPreference: "responses",
-          defaultModel: "gpt-4",
-        },
-        "claude-code": {
-          selectionKind: "claude-role-mapping",
-          protocolPreference: "messages",
-          fallbackModel: "MiniMax-M2.7-highspeed",
-          roles: {
-            sonnet: {
-              upstreamModel: "MiniMax-M2.7-highspeed",
-              displayName: "MiniMax-M2.7-highspeed",
-              declareOneM: true,
-            },
-          },
-        },
-        openclaw: {
-          selectionKind: "single-model",
-          protocolPreference: "chat_completions",
-          defaultModel: "gpt-4",
-        },
-        hermes: {
-          selectionKind: "single-model",
-          protocolPreference: "chat_completions",
-          defaultModel: "gpt-4",
-        },
-      },
-      home: PROVIDER_HOME
-    });
-
-    expect(changes).toEqual(expect.arrayContaining([
-      expect.objectContaining({ providerId: "codex", action: "update" }),
-      expect.objectContaining({ providerId: "hermes", action: "create" })
-    ]));
-    expect(fs.readFileSync(path.join(PROVIDER_HOME, ".codex", "config.toml"), "utf8")).toBe(codexBefore);
-  });
-
-  test("reports installed-only providers when executable or native config hints exist", () => {
-    fs.rmSync(path.join(PROVIDER_HOME, ".openclaw", "openclaw.json"), { force: true });
-    fs.writeFileSync(path.join(PROVIDER_HOME, ".openclaw", "config.json"), JSON.stringify({ profile: "default" }, null, 2), "utf8");
-    fs.mkdirSync(path.join(PROVIDER_HOME, ".hermes"), { recursive: true });
-    fs.writeFileSync(path.join(PROVIDER_HOME, ".hermes", "settings.json"), JSON.stringify({ openai: { model: "gpt-4" } }, null, 2), "utf8");
-
-    const providers = detectProviders({ home: PROVIDER_HOME });
-    expect(providers).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        id: "openclaw",
-        status: "installed",
-        configured: false,
-        executablePath: expect.stringContaining(path.join("provider-bin", "openclaw")),
-        observedPaths: expect.arrayContaining([path.join(PROVIDER_HOME, ".openclaw", "config.json")]),
-      }),
-      expect.objectContaining({
-        id: "hermes",
-        status: "installed",
-        configured: false,
-        executablePath: expect.stringContaining(path.join("provider-bin", "hermes")),
-        observedPaths: expect.arrayContaining([path.join(PROVIDER_HOME, ".hermes", "settings.json")]),
-      }),
-    ]));
-  });
-
-  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 {
-      const applied = applyProviderInstall({
-        providers: ["codex", "claude-code", "openclaw", "opencode", "hermes"],
-        proxyUrl,
-        providerSelections: {
-          codex: {
-            selectionKind: "single-model",
-            protocolPreference: "responses",
-            defaultModel: "gpt-4",
-          },
-          "claude-code": {
-            selectionKind: "claude-role-mapping",
-            protocolPreference: "messages",
-            fallbackModel: "MiniMax-M2.7-highspeed",
-            roles: {
-              sonnet: {
-                upstreamModel: "MiniMax-M2.7-highspeed",
-                displayName: "MiniMax-M2.7-highspeed",
-                declareOneM: true,
-              },
-              opus: {
-                upstreamModel: "MiniMax-M2.7-highspeed",
-                displayName: "MiniMax-M2.7-highspeed",
-                declareOneM: true,
-              },
-              haiku: {
-                upstreamModel: "MiniMax-M2.7-highspeed",
-                displayName: "MiniMax-M2.7-highspeed",
-                declareOneM: false,
-              },
-            },
-          },
-          openclaw: {
-            selectionKind: "single-model",
-            protocolPreference: "chat_completions",
-            defaultModel: "gpt-4",
-          },
-          opencode: {
-            selectionKind: "single-model",
-            protocolPreference: "responses",
-            defaultModel: "gpt-4",
-          },
-          hermes: {
-            selectionKind: "single-model",
-            protocolPreference: "chat_completions",
-            defaultModel: "gpt-4",
-          },
-        },
-        home: PROVIDER_HOME
-      }, store);
-      expect(applied).toEqual(expect.arrayContaining([
-        expect.objectContaining({ providerId: "codex", action: "updated" }),
-        expect.objectContaining({ providerId: "hermes", action: "created" })
-      ]));
-
-      const codex = fs.readFileSync(path.join(PROVIDER_HOME, ".codex", "config.toml"), "utf8");
-      expect(codex).toContain("approval_policy = \"never\"");
-      expect(codex).toContain("[tokenbuddy]");
-      expect(codex).toContain(`proxy_url = "${proxyUrl}"`);
-
-      const claude = JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".claude", "settings.json"), "utf8"));
-      expect(claude.theme).toBe("dark");
-      expect(claude.env.ANTHROPIC_BASE_URL).toBe(proxyUrl);
-      expect(claude.env.ANTHROPIC_DEFAULT_SONNET_MODEL).toBe("claude-sonnet-4-6[1M]");
-      expect(claude.env.ANTHROPIC_DEFAULT_OPUS_MODEL).toBe("claude-opus-4-7[1M]");
-      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")).toBeUndefined();
-      expect(store.getProviderRuntimeConfig("opencode")?.config).not.toHaveProperty("sellerId");
-
-      const openclaw = JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".openclaw", "openclaw.json"), "utf8"));
-      expect(openclaw.keep).toBe("field");
-      expect(openclaw.models.providers.existing.baseUrl).toBe("https://example.invalid/v1");
-      expect(openclaw.models.providers.tokenbuddy.baseUrl).toBe(`${proxyUrl}/v1`);
-      expect(openclaw.models.providers.tokenbuddy.apiKey).toBe("TOKENBUDDY_PROXY");
-      expect(openclaw.models.providers.tokenbuddy.models).toEqual(expect.arrayContaining([
-        expect.objectContaining({ id: "gpt-4", name: "gpt-4", api: "openai-completions" }),
-      ]));
-      expect(openclaw.agents.defaults.model).toBe("tokenbuddy/gpt-4");
-      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,
-        }),
-      ]));
-      const hermesConfig = fs.readFileSync(path.join(PROVIDER_HOME, ".hermes", "config.yaml"), "utf8");
-      expect(hermesConfig).toContain("model:");
-      expect(hermesConfig).toContain("default: gpt-4");
-      expect(hermesConfig).toContain("provider: custom");
-      expect(hermesConfig).toContain(`base_url: "${proxyUrl}/v1"`);
-      expect(hermesConfig).toContain("api_key: TOKENBUDDY_PROXY");
-      expect(hermesConfig).toContain("api_mode: chat_completions");
-      expect(store.getProviderInstallSnapshot("codex")).toBeDefined();
-
-      const rolledBack = rollbackProviderInstall({
-        providers: ["codex", "claude-code", "openclaw", "opencode", "hermes"],
-        home: PROVIDER_HOME
-      }, store);
-
-      expect(rolledBack).toEqual(expect.arrayContaining([
-        expect.objectContaining({ providerId: "codex", action: "restored" }),
-        expect.objectContaining({ providerId: "hermes", action: "removed" })
-      ]));
-      expect(fs.readFileSync(path.join(PROVIDER_HOME, ".codex", "config.toml"), "utf8")).toBe("approval_policy = \"never\"\n");
-      expect(JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".openclaw", "openclaw.json"), "utf8"))).toMatchObject({
-        keep: "field",
-        agents: {
-          defaults: {
-            model: "existing/existing-model",
-          },
-        },
-      });
-      expect(JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".config", "opencode", "opencode.json"), "utf8"))).toEqual({ share: "disabled" });
-      expect(fs.existsSync(path.join(PROVIDER_HOME, ".hermes", "config.yaml"))).toBe(false);
-      expect(store.getProviderInstallSnapshot("codex")).toBeUndefined();
-      expect(store.getProviderRuntimeConfig("claude-code")).toBeUndefined();
-    } finally {
-      store.close();
-    }
-  });
-
-  test("opencode provider install uses @ai-sdk/openai-compatible for chat completions", () => {
-    const config: ProviderRuntimeConfig = {
-      selectionKind: "single-model",
-      protocolPreference: "chat_completions",
-      defaultModel: "gpt-5.4",
-    };
-    const changes = previewProviderInstall({
-      providers: ["opencode"],
-      proxyUrl: "http://127.0.0.1:17821",
-      providerSelections: { opencode: config },
-      home: PROVIDER_HOME,
-    });
-    const change = changes.find((c) => c.providerId === "opencode");
-    expect(change).toBeDefined();
-    expect(change?.content).toBeDefined();
-    const parsed = JSON.parse(change!.content!);
-    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");
-  });
-
-  test("hermes install preserves existing config and writes active config.yaml model section", () => {
-    fs.mkdirSync(path.join(PROVIDER_HOME, ".hermes"), { recursive: true });
-    fs.writeFileSync(path.join(PROVIDER_HOME, ".hermes", "config.yaml"), [
-      "display:",
-      "  compact: false",
-      "model:",
-      "  default: existing-model",
-      "  provider: existing-provider",
-      "  base_url: https://existing.invalid/v1",
-      "fallback_providers: []",
-      "",
-    ].join("\n"), "utf8");
-
-    const changes = previewProviderInstall({
-      providers: ["hermes"],
-      proxyUrl,
-      providerSelections: {
-        hermes: {
-          selectionKind: "single-model",
-          protocolPreference: "chat_completions",
-          defaultModel: "gpt-5.4",
-        },
-      },
-      home: PROVIDER_HOME,
-    });
-
-    const parsed = changes.find((change) => change.providerId === "hermes")?.content || "";
-    expect(parsed).toContain("display:");
-    expect(parsed).toContain("compact: false");
-    expect(parsed).toContain("fallback_providers:");
-    expect(parsed).toContain("default: gpt-5.4");
-    expect(parsed).toContain("provider: custom");
-    expect(parsed).toContain(`base_url: "${proxyUrl}/v1"`);
-    expect(parsed).toContain("api_key: TOKENBUDDY_PROXY");
-    expect(parsed).toContain("api_mode: chat_completions");
-  });
-
-  test("legacy terminal rewrite helpers use active OpenClaw and Hermes config files", () => {
-    const helperHome = path.join(PROVIDER_HOME, "terminal-helper-home");
-    const openclawPath = path.join(helperHome, ".openclaw", "openclaw.json");
-    const hermesPath = path.join(helperHome, ".hermes", "config.yaml");
-    fs.mkdirSync(path.dirname(openclawPath), { recursive: true });
-    fs.mkdirSync(path.dirname(hermesPath), { recursive: true });
-    fs.writeFileSync(openclawPath, JSON.stringify({
-      models: {
-        providers: {
-          existing: {
-            baseUrl: "https://example.invalid/v1",
-            models: [{ id: "existing-model", name: "existing-model" }],
-          },
-        },
-      },
-      agents: {
-        defaults: {
-          model: "existing/existing-model",
-        },
-      },
-    }, null, 2), "utf8");
-    fs.writeFileSync(hermesPath, [
-      "display:",
-      "  compact: false",
-      "model:",
-      "  default: existing-model",
-      "  provider: existing-provider",
-      "fallback_providers: []",
-      "",
-    ].join("\n"), "utf8");
-
-    rewriteOpenclaw(openclawPath, proxyUrl, "gpt-5.4");
-    rewriteHermes(hermesPath, proxyUrl, "gpt-5.4");
-
-    const openclaw = JSON.parse(fs.readFileSync(openclawPath, "utf8"));
-    expect(openclaw.models.providers.existing.baseUrl).toBe("https://example.invalid/v1");
-    expect(openclaw.models.providers.tokenbuddy.baseUrl).toBe(`${proxyUrl}/v1`);
-    expect(openclaw.models.providers.tokenbuddy.apiKey).toBe("TOKENBUDDY_PROXY");
-    expect(openclaw.models.providers.tokenbuddy.models).toEqual(expect.arrayContaining([
-      expect.objectContaining({ id: "gpt-5.4", name: "gpt-5.4", api: "openai-completions" }),
-    ]));
-    expect(openclaw.agents.defaults.model).toBe("tokenbuddy/gpt-5.4");
-
-    const hermes = fs.readFileSync(hermesPath, "utf8");
-    expect(hermes).toContain("display:");
-    expect(hermes).toContain("compact: false");
-    expect(hermes).toContain("fallback_providers:");
-    expect(hermes).toContain("default: gpt-5.4");
-    expect(hermes).toContain("provider: custom");
-    expect(hermes).toContain(`base_url: "${proxyUrl}/v1"`);
-    expect(hermes).toContain("api_key: TOKENBUDDY_PROXY");
-    expect(hermes).toContain("api_mode: chat_completions");
-  });
-});
-
-describe("TokenBuddy CLI and Daemon Integration Tests", () => {
-  let daemon: TokenbuddyDaemon;
-  let mockSellerServer: http.Server;
-  let sellerReqCount = 0;
-  let completeReqCount = 0;
-  let balanceReqCount = 0;
-  let mockSellerPort: number;
-  let daemonControlPort: number;
-  let daemonProxyPort: number;
-  const insufficientFundsAttempts = new Map<string, number>();
-  const sellerRequests: Array<{
-    url?: string;
-    authorization?: string;
-    idempotencyKey?: string;
-    paymentMethod?: string;
-    body?: any;
-  }> = [];
-
-  const readJsonBody = (req: http.IncomingMessage): Promise<any> => new Promise((resolve) => {
-    let body = "";
-    req.on("data", (chunk) => {
-      body += chunk.toString();
-    });
-    req.on("end", () => {
-      resolve(body ? JSON.parse(body) : {});
-    });
-  });
-
-  function setSettlementHeader(res: http.ServerResponse, requestId: string, settledMicros: number, remainingCreditMicros: number): void {
-    res.setHeader("X-TokenBuddy-Settlement", JSON.stringify({
-      requestId,
-      request_id: requestId,
-      settledMicros,
-      settled_micros: settledMicros,
-      settledUsdMicros: settledMicros,
-      settled_usd_micros: settledMicros,
-      remainingCreditMicros,
-      remaining_credit_micros: remainingCreditMicros,
-      reservedBalanceMicros: 0,
-      reserved_balance_micros: 0,
-      spentMicros: settledMicros,
-      spent_micros: settledMicros,
-      priceVersion: "openrouter_usd.v1",
-      price_version: "openrouter_usd.v1"
-    }));
-  }
-
-  beforeAll((done) => {
-    mockSellerServer = http.createServer(async (req, res) => {
-      res.setHeader("Content-Type", "application/json");
-
-      if (req.url === "/registry/sellers") {
-        res.end(JSON.stringify({
-          version: 1,
-          defaultSeller: "mock-seller",
-          sellers: [
-            {
-              id: "incompatible-seller",
-              name: "Incompatible Seller",
-              url: `http://127.0.0.1:${mockSellerPort}/incompatible`,
-              supportedProtocols: ["chat_completions"],
-              paymentMethods: ["mock"],
-              models: ["incompatible-only"]
-            },
-            {
-              id: "mock-seller",
-              name: "Mock Seller",
-              url: `http://127.0.0.1:${mockSellerPort}`,
-              supportedProtocols: ["chat_completions", "responses", "messages"],
-              paymentMethods: ["mock"],
-              models: ["gpt-4", "gpt-4.1-mini", "claude-3-5-sonnet"]
-            }
-          ]
-        }));
-        return;
-      }
-
-      if (req.url === "/incompatible/manifest") {
-        res.end(JSON.stringify({
-          sellerId: "incompatible-seller",
-          supportedProtocols: ["chat_completions"],
-          paymentMethods: ["mock"],
-          models: [
-            { id: "other-model" }
-          ]
-        }));
-        return;
-      }
-
-      if (req.url === "/manifest") {
-        res.end(JSON.stringify({
-          sellerId: "mock-seller",
-          supportedProtocols: ["chat_completions", "responses", "messages"],
-          paymentMethods: ["mock"],
-          models: [
-            { id: "gpt-4" },
-            { id: "gpt-4.1-mini" },
-            { id: "claude-3-5-sonnet" }
-          ]
-        }));
-        return;
-      }
-
-      if (req.url === "/purchase/create") {
-        const body = await readJsonBody(req);
-        sellerRequests.push({ url: req.url, paymentMethod: body.paymentMethod, body });
-        sellerReqCount++;
-        res.end(JSON.stringify({
-          purchaseId: "pur_mock_123",
-          status: "pending",
-          creditMicros: 2000000,
-          currency: "USD",
-          expiresAt: new Date(Date.now() + 86400 * 1000).toISOString()
-        }));
-        return;
-      }
-
-      if (req.url === "/purchase/complete") {
-        const body = await readJsonBody(req);
-        sellerRequests.push({ url: req.url, paymentMethod: body.paymentMethod, body });
-        completeReqCount++;
-        res.end(JSON.stringify({
-          purchaseId: "pur_mock_123",
-          status: "active",
-          accessToken: "tok_mock_token_abc",
-          tokenClass: "model:gpt-4",
-          creditMicros: 2000000,
-          currency: "USD"
-        }));
-        return;
-      }
-
-      if (req.url === "/v1/balance") {
-        balanceReqCount++;
-        sellerRequests.push({
-          url: req.url,
-          authorization: req.headers.authorization
-        });
-        res.end(JSON.stringify({
-          tokenId: "cred_mock",
-          creditMicros: 1000,
-          reservedMicros: 0,
-          spentMicros: 1999000,
-          currency: "Micros"
-        }));
-        return;
-      }
-
-      if (req.url === "/v1/chat/completions") {
-        const body = await readJsonBody(req);
-        sellerRequests.push({
-          url: req.url,
-          authorization: req.headers.authorization,
-          idempotencyKey: req.headers["idempotency-key"] as string | undefined,
-          body
-        });
-        if (body.requestId === "chat_req_402_retry") {
-          const attempts = insufficientFundsAttempts.get(body.requestId) || 0;
-          insufficientFundsAttempts.set(body.requestId, attempts + 1);
-          if (attempts === 0) {
-            res.statusCode = 402;
-            res.end(JSON.stringify({
-              error: {
-                code: "insufficient_funds",
-                message: "Insufficient funds"
-              }
-            }));
-            return;
-          }
-        }
-        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",
-            settledMicros: 110,
-            settledUsdMicros: 110,
-            remainingCreditMicros: 1999890,
-            reservedBalanceMicros: 0,
-            spentMicros: 110,
-            priceVersion: "openrouter_usd.v1"
-          })}\n\n`);
-          res.end("data: [DONE]\n\n");
-          return;
-        }
-        setSettlementHeader(res, body.requestId || "chat_req_mock", 110, 1999890);
-        res.end(JSON.stringify({
-          id: "chatcmpl-mock",
-          usage: { prompt_tokens: 10, completion_tokens: 10 }
-        }));
-        return;
-      }
-
-      if (req.url === "/v1/responses") {
-        const body = await readJsonBody(req);
-        sellerRequests.push({
-          url: req.url,
-          authorization: req.headers.authorization,
-          idempotencyKey: req.headers["idempotency-key"] as string | undefined,
-          body
-        });
-        if (body.requestId === "responses_req_stream_shape") {
-          res.writeHead(200, { "Content-Type": "text/event-stream" });
-          res.write('event: response.created\ndata: {"type":"response.created","response":{"id":"resp_stream_shape","object":"response","model":"gpt-4.1-mini","status":"in_progress","output":[]}}\n\n');
-          res.write('event: response.output_item.added\ndata: {"type":"response.output_item.added","item":{"type":"message","id":"item_stream_shape","role":"assistant","status":"in_progress"},"sequence_number":1}\n\n');
-          res.write('event: response.output_text.delta\ndata: {"type":"response.output_text.delta","delta":"hello","item_id":"item_stream_shape","sequence_number":2}\n\n');
-          res.write('event: response.output_text.done\ndata: {"type":"response.output_text.done","item_id":"item_stream_shape","sequence_number":3}\n\n');
-          res.write('event: response.output_item.done\ndata: {"type":"response.output_item.done","item":{"type":"message","id":"item_stream_shape","status":"completed"},"sequence_number":4}\n\n');
-          res.end('event: response.completed\ndata: {"type":"response.completed","response":{"id":"resp_stream_shape","object":"response","model":"gpt-4.1-mini","status":"completed","output":[],"usage":{"input_tokens":10,"output_tokens":1,"total_tokens":11}},"sequence_number":5}\n\n');
-          return;
-        }
-        if (body.requestId === "responses_req_br") {
-          const compressed = zlib.brotliCompressSync(Buffer.from(JSON.stringify({
-            id: "resp-br",
-            usage: { input_tokens: 7, output_tokens: 9 }
-          })));
-          res.writeHead(200, {
-            "Content-Type": "application/json",
-            "Content-Encoding": "br",
-            "Content-Length": compressed.byteLength
-          });
-          res.end(compressed);
-          return;
-        }
-        setSettlementHeader(res, body.requestId || "responses_req_mock", 64, 1999936);
-        res.end(JSON.stringify({
-          id: "resp-mock",
-          usage: { input_tokens: 7, output_tokens: 9 }
-        }));
-        return;
-      }
-
-      if (req.url === "/v1/messages" || req.url === "/messages") {
-        const body = await readJsonBody(req);
-        sellerRequests.push({
-          url: req.url,
-          authorization: req.headers.authorization,
-          idempotencyKey: req.headers["idempotency-key"] as string | undefined,
-          body
-        });
-        setSettlementHeader(res, body.requestId || "messages_req_mock", 44, 1999956);
-        res.end(JSON.stringify({
-          id: "msg-mock",
-          usage: { input_tokens: 5, output_tokens: 6 }
-        }));
-        return;
-      }
-
-      res.end("{}");
-    });
-
-    mockSellerServer.listen(0, "127.0.0.1", () => {
-      mockSellerPort = (mockSellerServer.address() as AddressInfo).port;
-      done();
-    });
-  });
-
-  afterAll((done) => {
-    mockSellerServer.close(done);
-  });
-
-  beforeEach(() => {
-    rmSqliteFiles(TEMP_BUYER_DB);
-    sellerReqCount = 0;
-    completeReqCount = 0;
-    balanceReqCount = 0;
-    insufficientFundsAttempts.clear();
-    sellerRequests.length = 0;
-    const seedStore = new BuyerStore({ dbPath: TEMP_BUYER_DB });
-    seedStore.savePayment({
-      method: "mock",
-      enabled: true,
-      isDefault: true,
-      config: { channel: "control-plane-test" }
-    });
-    seedStore.saveDaemonRuntimeConfig(PROVIDER_MODE_CONFIG_KEY, {
-      mode: "auto",
-      updatedAt: new Date().toISOString()
-    });
-    seedStore.recordPurchaseLedger({
-      purchaseId: "pur_control_1",
-      sellerKey: "mock-seller",
-      modelId: "gpt-4",
-      paymentMethod: "mock",
-      status: "funded",
-      creditMicros: 1000000,
-      currency: "USD",
-      paymentReference: "raw-control-payment-proof"
-    });
-    seedStore.recordInferenceLedger({
-      requestId: "req_control_1",
-      sellerKey: "mock-seller",
-      modelId: "gpt-4",
-      endpoint: "/v1/chat/completions",
-      status: "settled",
-      promptTokens: 10,
-      completionTokens: 20,
-      cacheReadTokens: 4,
-      billedMicros: 70,
-      prompt: "raw control prompt",
-      response: "raw control response"
-    });
-    seedStore.saveProviderRuntimeConfig("claude-code", {
-      selectionKind: "claude-role-mapping",
-      protocolPreference: "messages",
-      fallbackModel: "claude-3-5-sonnet",
-      roles: {
-        sonnet: {
-          upstreamModel: "claude-3-5-sonnet",
-          displayName: "Claude Sonnet Mock",
-          declareOneM: true
-        },
-        opus: {
-          upstreamModel: "claude-3-5-sonnet",
-          displayName: "Claude Opus Mock",
-          declareOneM: true
-        },
-        haiku: {
-          upstreamModel: "claude-3-5-sonnet",
-          displayName: "Claude Haiku Mock",
-          declareOneM: false
-        }
-      }
-    });
-    seedStore.close();
-
-    daemon = new TokenbuddyDaemon({
-      controlPort: 0,
-      proxyPort: 0,
-      dbPath: TEMP_BUYER_DB,
-      sellerRegistryUrl: `http://127.0.0.1:${mockSellerPort}/registry/sellers`
-    });
-    daemon.start();
-    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
-    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
-  });
-
-  afterEach(() => {
-    daemon.stop();
-    rmSqliteFiles(TEMP_BUYER_DB);
-  });
-
-  test("Terminal detection Candidates works without errors", () => {
-    const list = detectTerminals();
-    expect(list.length).toBeGreaterThan(0);
-    expect(list.some(c => c.id === "claude-code")).toBe(true);
-  });
-
-  test("control plane exposes health, registry-backed models, payments, and safe ledgers", async () => {
-    const controlUrl = `http://127.0.0.1:${daemonControlPort}`;
-
-    const health = await (await fetch(`${controlUrl}/health`)).json() as any;
-    expect(health).toMatchObject({
-      status: "ok",
-      controlPort: daemonControlPort,
-      proxyPort: daemonProxyPort,
-      store: { journalMode: "wal" }
-    });
-
-    const status = await (await fetch(`${controlUrl}/status`)).json() as any;
-    expect(status).toMatchObject({
-      status: "running",
-      controlPort: daemonControlPort,
-      proxyPort: daemonProxyPort,
-      sellerRegistryUrl: `http://127.0.0.1:${mockSellerPort}/registry/sellers`,
-      store: {
-        paymentsCount: 1,
-        purchaseLedgerCount: 1,
-        inferenceLedgerCount: 1
-      }
-    });
-
-    const sellers = await (await fetch(`${controlUrl}/sellers`)).json() as any;
-    expect(sellers.sellers).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        id: "mock-seller",
-        status: "configured",
-        paymentMethods: ["mock"]
-      })
-    ]));
-
-    const models = await (await fetch(`${controlUrl}/models`)).json() as any;
-    expect(models.data).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        id: "gpt-4",
-        sellerId: "mock-seller",
-        paymentMethods: ["mock"]
-      })
-    ]));
-    expect(models.sellers).toEqual(expect.arrayContaining([
-      expect.objectContaining({ id: "mock-seller", status: "ok" })
-    ]));
-
-    const payments = await (await fetch(`${controlUrl}/payments`)).json() as any;
-    expect(payments.payments).toMatchObject([
-      { method: "mock", enabled: true, isDefault: true }
-    ]);
-
-    const purchases = await (await fetch(`${controlUrl}/ledger/purchases`)).json() as any;
-    const inferences = await (await fetch(`${controlUrl}/ledger/inferences`)).json() as any;
-    const publicOutput = JSON.stringify({ purchases, inferences, payments, models, sellers, status, health });
-
-    expect(purchases.purchases).toHaveLength(1);
-    expect(inferences.inferences).toHaveLength(1);
-    expect(publicOutput).toContain("paymentReferenceHash");
-    expect(publicOutput).toContain("promptHash");
-    expect(publicOutput).toContain("responseHash");
-    for (const secret of [
-      "raw-control-payment-proof",
-      "raw control prompt",
-      "raw control response",
-      "payCredential"
-    ]) {
-      expect(publicOutput).not.toContain(secret);
-    }
-  });
-
-  test("coalesces concurrent chat requests and preserves purchase/proxy headers", async () => {
-    const chatReq = {
-      model: "gpt-4",
-      messages: [{ role: "user", content: "raw concurrent prompt secret" }],
-      requestId: "chat_req_parallel"
-    };
-
-    const sendRequest = () => fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Idempotency-Key": "idem-chat-preserved"
-      },
-      body: JSON.stringify(chatReq)
-    });
-
-    const responses = await Promise.all([
-      sendRequest(), sendRequest(), sendRequest(), sendRequest(), sendRequest(),
-      sendRequest(), sendRequest(), sendRequest(), sendRequest(), sendRequest()
-    ]);
-
-    for (const r of responses) {
-      expect(r.ok).toBe(true);
-      const data: any = await r.json();
-      expect(data.id).toBe("chatcmpl-mock");
-    }
-
-    expect(sellerReqCount).toBe(1);
-    expect(completeReqCount).toBe(1);
-    expect(sellerRequests.find((request) => request.url === "/purchase/create")).toMatchObject({
-      paymentMethod: "mock"
-    });
-    const chatForwards = sellerRequests.filter((request) => request.url === "/v1/chat/completions");
-    expect(chatForwards).toHaveLength(10);
-    expect(chatForwards.every((request) => request.authorization === "Bearer tok_mock_token_abc")).toBe(true);
-    expect(chatForwards.every((request) => request.idempotencyKey === "idem-chat-preserved")).toBe(true);
-
-    const controlUrl = `http://127.0.0.1:${daemonControlPort}`;
-    const purchases = await (await fetch(`${controlUrl}/ledger/purchases`)).json() as any;
-    const inferences = await (await fetch(`${controlUrl}/ledger/inferences`)).json() as any;
-    expect(purchases.purchases.some((entry: any) => entry.purchaseId === "pur_mock_123" && entry.paymentMethod === "mock")).toBe(true);
-    expect(inferences.inferences.filter((entry: any) => entry.endpoint === "/v1/chat/completions")).toHaveLength(11);
-    const chatLedgers = inferences.inferences.filter((entry: any) => entry.requestId === "chat_req_parallel");
-    expect(chatLedgers).toHaveLength(10);
-    expect(chatLedgers).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        billedMicros: 110,
-        estimatedMicros: 80,
-        settledMicros: 110,
-        settledUsdMicros: 110,
-        priceVersion: "openrouter_usd.v1",
-        balanceSnapshotMicros: 1999890,
-        balanceSource: "seller_authoritative"
-      })
-    ]));
-    expect(balanceReqCount).toBe(0);
-    const store = new BuyerStore({ dbPath: TEMP_BUYER_DB });
-    try {
-      expect(store.getToken("mock-seller")).toMatchObject({
-        balanceMicros: 1999890,
-        reservedMicros: 0,
-        spentMicros: 110,
-        balanceSource: "seller_settlement_summary"
-      });
-    } finally {
-      store.close();
-    }
-    const publicOutput = JSON.stringify({ purchases, inferences });
-    expect(publicOutput).not.toContain("raw concurrent prompt secret");
-    expect(publicOutput).not.toContain("tok_mock_token_abc");
-  });
-
-  test("refreshes balance, auto-purchases, and retries once after seller 402 insufficient funds", async () => {
-    const store = new BuyerStore({ dbPath: TEMP_BUYER_DB });
-    store.saveToken("mock-seller", "tok_existing_high_cache", "model:gpt-4", 900000, "2030-01-01T00:00:00.000Z");
-    store.close();
-
-    const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Idempotency-Key": "idem-402-retry"
-      },
-      body: JSON.stringify({
-        model: "gpt-4",
-        messages: [{ role: "user", content: "trigger 402" }],
-        requestId: "chat_req_402_retry"
-      })
-    });
-
-    expect(response.ok).toBe(true);
-    expect((await response.json() as any).id).toBe("chatcmpl-mock");
-    expect(balanceReqCount).toBe(1);
-    expect(sellerRequests.filter((request) => request.url === "/v1/chat/completions" && request.body?.requestId === "chat_req_402_retry")).toHaveLength(2);
-    expect(sellerRequests.filter((request) => request.url === "/purchase/create")).toHaveLength(1);
-    expect(sellerRequests.filter((request) => request.url === "/purchase/complete")).toHaveLength(1);
-    expect(sellerRequests.filter((request) => request.url === "/v1/chat/completions" && request.body?.requestId === "chat_req_402_retry")
-      .every((request) => request.idempotencyKey === "idem-402-retry")).toBe(true);
-
-    const inferences = await (await fetch(`http://127.0.0.1:${daemonControlPort}/ledger/inferences`)).json() as any;
-    expect(inferences.inferences).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        requestId: "chat_req_402_retry",
-        billedMicros: 110,
-        estimatedMicros: 80,
-        settledMicros: 110,
-        balanceSource: "seller_authoritative"
-      })
-    ]));
-  });
-
-  test("proxies models, responses, and anthropic message endpoints through compatible seller manifests", async () => {
-    const proxyUrl = `http://127.0.0.1:${daemonProxyPort}`;
-
-    const models = await (await fetch(`${proxyUrl}/v1/models`)).json() as any;
-    expect(models.data).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        id: "gpt-4",
-        sellerId: "mock-seller"
-      })
-    ]));
-
-    const responses = await fetch(`${proxyUrl}/v1/responses`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Idempotency-Key": "idem-responses-preserved"
-      },
-      body: JSON.stringify({
-        model: "gpt-4.1-mini",
-        input: "raw responses prompt secret",
-        requestId: "responses_req_1"
-      })
-    });
-    expect(responses.ok).toBe(true);
-    expect((await responses.json() as any).id).toBe("resp-mock");
-
-    const largeInput = `raw large responses prompt secret ${"x".repeat(160 * 1024)}`;
-    const largeResponses = await fetch(`${proxyUrl}/v1/responses`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Idempotency-Key": "idem-large-responses-preserved"
-      },
-      body: JSON.stringify({
-        model: "gpt-4.1-mini",
-        input: largeInput,
-        requestId: "responses_req_large"
-      })
-    });
-    expect(largeResponses.ok).toBe(true);
-    expect((await largeResponses.json() as any).id).toBe("resp-mock");
-
-    const compressedResponses = await fetch(`${proxyUrl}/v1/responses`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: "gpt-4.1-mini",
-        input: "raw compressed responses prompt secret",
-        requestId: "responses_req_br"
-      })
-    });
-    expect(compressedResponses.ok).toBe(true);
-    expect(compressedResponses.headers.get("content-encoding")).toBeNull();
-    expect((await compressedResponses.json() as any).id).toBe("resp-br");
-
-    for (const endpoint of ["/v1/messages", "/messages"]) {
-      const message = await fetch(`${proxyUrl}${endpoint}`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          model: "claude-3-5-sonnet",
-          messages: [{ role: "user", content: "raw anthropic prompt secret" }]
-        })
-      });
-      expect(message.ok).toBe(true);
-      expect((await message.json() as any).id).toBe("msg-mock");
-    }
-
-    expect(sellerRequests.find((request) => request.url === "/v1/responses")?.idempotencyKey).toBe("idem-responses-preserved");
-    expect(sellerRequests.find((request) => request.idempotencyKey === "idem-large-responses-preserved")?.body.input).toHaveLength(largeInput.length);
-    expect(sellerRequests.some((request) => request.url === "/v1/messages")).toBe(true);
-    expect(sellerRequests.some((request) => request.url === "/messages")).toBe(true);
-
-    const inferences = await (await fetch(`http://127.0.0.1:${daemonControlPort}/ledger/inferences`)).json() as any;
-    expect(inferences.inferences).toEqual(expect.arrayContaining([
-      expect.objectContaining({ endpoint: "/v1/responses", promptTokens: 7, completionTokens: 9 }),
-      expect.objectContaining({ endpoint: "/v1/responses", requestId: "responses_req_large" }),
-      expect.objectContaining({ endpoint: "/v1/messages", promptTokens: 5, completionTokens: 6 }),
-      expect.objectContaining({ endpoint: "/messages", promptTokens: 5, completionTokens: 6 })
-    ]));
-    const publicOutput = JSON.stringify(inferences);
-    expect(publicOutput).not.toContain("raw responses prompt secret");
-    expect(publicOutput).not.toContain("raw large responses prompt secret");
-    expect(publicOutput).not.toContain("raw anthropic prompt secret");
-  });
-
-  test("maps Claude role aliases to upstream models before message routing", async () => {
-    for (const model of ["sonnet", "claude-sonnet-4-6[1M]"]) {
-      const message = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/messages`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          model,
-          messages: [{ role: "user", content: "role mapping request" }]
-        })
-      });
-      expect(message.ok).toBe(true);
-      expect((await message.json() as any).id).toBe("msg-mock");
-    }
-
-    const messageRequests = sellerRequests.filter((request) => request.url === "/v1/messages");
-    expect(messageRequests).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        body: expect.objectContaining({
-          model: "claude-3-5-sonnet"
-        })
-      })
-    ]));
-  });
-
-  test("passes through streaming chat responses and records safe ledger metadata", async () => {
-    const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Idempotency-Key": "idem-stream-preserved"
-      },
-      body: JSON.stringify({
-        model: "gpt-4",
-        stream: true,
-        messages: [{ role: "user", content: "raw stream prompt secret" }],
-        requestId: "stream_req_1"
-      })
-    });
-
-    expect(response.ok).toBe(true);
-    expect(response.headers.get("content-type")).toContain("text/event-stream");
-    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");
-
-    const inferences = await (await fetch(`http://127.0.0.1:${daemonControlPort}/ledger/inferences`)).json() as any;
-    expect(inferences.inferences).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        endpoint: "/v1/chat/completions",
-        requestId: "stream_req_1",
-        status: "settled",
-        billedMicros: 110,
-        settledMicros: 110,
-        settledUsdMicros: 110,
-        balanceSource: "seller_authoritative"
-      })
-    ]));
-    const publicOutput = JSON.stringify(inferences);
-    expect(publicOutput).not.toContain("raw stream prompt secret");
-    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",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: "gpt-4.1-mini",
-        input: "shape normalization",
-        requestId: "responses_req_stream_shape",
-        stream: true
-      })
-    });
-
-    expect(response.ok).toBe(true);
-    expect(response.headers.get("content-type")).toContain("text/event-stream");
-    const body = await response.text();
-    // 卖方原始 events 直转——不再注入 content_part.added / content_part.done
-    expect(body).toContain("event: response.created");
-    expect(body).toContain("event: response.output_item.added");
-    expect(body).toContain("event: response.output_text.delta");
-    expect(body).toContain("event: response.output_text.done");
-    expect(body).toContain("event: response.output_item.done");
-    expect(body).toContain("event: response.completed");
-    expect(body).toContain("\"item_id\":\"item_stream_shape\"");
-    expect(body).toContain("\"delta\":\"hello\"");
-    // 内部记账事件不泄露给客户端
-    expect(body).not.toContain("tokenbuddy.settlement");
-  });
-
-  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" }],
-        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=");
-  });
-});
-
-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; body?: any; idempotencyKey?: string }> = [];
-  let primaryPurchaseSucceeds = false;
-  let primaryInferenceFails = false;
-  let primaryInferenceFailsOnceWithIdempotencyConflict = false;
-  const primaryInferenceSeenRequestIds = new Set<string>();
-  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")
-    .filter((event) => event.url !== "/primary/manifest" && event.url !== "/backup/manifest")
-    .map((event) => ({ seller: event.seller, url: event.url }));
-
-  const readJsonBody = (req: http.IncomingMessage): Promise<any> => new Promise((resolve) => {
-    let body = "";
-    req.on("data", (chunk) => {
-      body += chunk.toString();
-    });
-    req.on("end", () => {
-      resolve(body ? JSON.parse(body) : {});
-    });
-  });
-
-  beforeAll((done) => {
-    server = http.createServer(async (req, res) => {
-      res.setHeader("Content-Type", "application/json");
-      if (req.url === "/registry/sellers") {
-        res.end(JSON.stringify({
-          version: 1,
-          defaultSeller: "primary-seller",
-          sellers: [
-            {
-              id: "primary-seller",
-              name: "Primary Seller",
-              url: `http://127.0.0.1:${sellerPort}/primary`,
-              supportedProtocols: ["chat_completions", "responses"],
-              paymentMethods: ["mock"],
-              models: ["gpt-manual"]
-            },
-            {
-              id: "backup-seller",
-              name: "Backup Seller",
-              url: `http://127.0.0.1:${sellerPort}/backup`,
-              supportedProtocols: ["chat_completions", "responses"],
-              paymentMethods: ["mock"],
-              models: ["gpt-manual"]
-            }
-          ]
-        }));
-        return;
-      }
-
-      if (req.url === "/primary/manifest") {
-        events.push({ seller: "primary-seller", url: req.url });
-        res.end(JSON.stringify({
-          sellerId: "primary-seller",
-          supportedProtocols: ["chat_completions", "responses"],
-          paymentMethods: ["mock"],
-          selection: { discountRatio: 1 },
-          models: [{ id: "gpt-manual" }]
-        }));
-        return;
-      }
-
-      if (req.url === "/backup/manifest") {
-        events.push({ seller: "backup-seller", url: req.url });
-        res.end(JSON.stringify({
-          sellerId: "backup-seller",
-          supportedProtocols: ["chat_completions", "responses"],
-          paymentMethods: ["mock"],
-          selection: { discountRatio: 0.01 },
-          models: [{ id: "gpt-manual" }]
-        }));
-        return;
-      }
-
-      const body = await readJsonBody(req);
-      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" || req.url === "/primary/v1/responses") {
-        events.push({
-          seller: "primary-seller",
-          url: req.url,
-          body,
-          idempotencyKey: req.headers["idempotency-key"] as string | undefined
-        });
-        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" } }));
-          return;
-        }
-        if (primaryInferenceFails) {
-          res.statusCode = 500;
-          res.end(JSON.stringify({ error: { code: "upstream_failed", message: "primary seller failed" } }));
-          return;
-        }
-        if (primaryInferenceFailsOnceWithIdempotencyConflict) {
-          if (primaryInferenceSeenRequestIds.has(body.requestId)) {
-            res.statusCode = 409;
-            res.end(JSON.stringify({
-              error: {
-                code: "idempotency_conflict",
-                message: "Idempotency key already belongs to an existing request."
-              }
-            }));
-            return;
-          }
-          primaryInferenceSeenRequestIds.add(body.requestId);
-          if (primaryInferenceSeenRequestIds.size === 1) {
-            res.statusCode = 502;
-            res.end(JSON.stringify({ error: { code: "upstream_failed", message: "primary seller failed once" } }));
-            return;
-          }
-        }
-        if (req.url === "/primary/v1/responses") {
-          res.end(JSON.stringify({
-            id: "primary-response",
-            usage: { input_tokens: 4, output_tokens: 5 }
-          }));
-        } else {
-          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 });
-        res.end(JSON.stringify({
-          purchaseId: "pur_backup_123",
-          status: "pending",
-          creditMicros: 2000000,
-          currency: "USD",
-          expiresAt: new Date(Date.now() + 86400 * 1000).toISOString()
-        }));
-        return;
-      }
-
-      if (req.url === "/backup/purchase/complete") {
-        events.push({ seller: "backup-seller", url: req.url });
-        res.end(JSON.stringify({
-          purchaseId: "pur_backup_123",
-          status: "active",
-          accessToken: "tok_backup_token_abc",
-          tokenClass: "model:gpt-manual",
-          creditMicros: 2000000,
-          currency: "USD"
-        }));
-        return;
-      }
-
-      if (req.url === "/backup/v1/chat/completions" || req.url === "/backup/v1/responses") {
-        events.push({ seller: "backup-seller", url: req.url });
-        if (req.url === "/backup/v1/responses") {
-          res.end(JSON.stringify({
-            id: "backup-response",
-            usage: { input_tokens: 4, output_tokens: 5 }
-          }));
-        } else {
-          res.end(JSON.stringify({
-            id: "backup-chat",
-            usage: { prompt_tokens: 4, completion_tokens: 5 }
-          }));
-        }
-        return;
-      }
-
-      if (req.url?.startsWith("/backup/")) {
-        events.push({ seller: "backup-seller", url: req.url });
-        res.end(JSON.stringify({ id: "backup-should-not-run" }));
-        return;
-      }
-
-      res.statusCode = 404;
-      res.end(JSON.stringify({ error: "not_found" }));
-    });
-
-    server.listen(0, "127.0.0.1", () => {
-      sellerPort = (server.address() as AddressInfo).port;
-      done();
-    });
-  });
-
-  afterAll((done) => {
-    server.close(done);
-  });
-
-  beforeEach(() => {
-    events.length = 0;
-    primaryPurchaseSucceeds = false;
-    primaryInferenceFails = false;
-    primaryInferenceFailsOnceWithIdempotencyConflict = false;
-    primaryInferenceSeenRequestIds.clear();
-    primaryInferenceBusy = false;
-    primaryInferenceDelayMs = 0;
-    rmSqliteFiles(dbPath);
-    const store = new BuyerStore({ dbPath });
-    store.savePayment({
-      method: "mock",
-      enabled: true,
-      isDefault: true,
-      config: { channel: "manual-routing-test" }
-    });
-    store.saveDaemonRuntimeConfig(PROVIDER_MODE_CONFIG_KEY, {
-      mode: "auto",
-      updatedAt: new Date().toISOString()
-    });
-    store.close();
-
-    daemon = new TokenbuddyDaemon({
-      controlPort: 0,
-      proxyPort: 0,
-      dbPath,
-      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
-      sellerRouting: {
-        mode: "fixed",
-        sellerId: "primary-seller",
-        scorer: "balanced"
-      }
-    });
-    daemon.start();
-    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
-    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
-  });
-
-  afterEach(() => {
-    daemon.stop();
-    rmSqliteFiles(dbPath);
-  });
-
-  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",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: "gpt-manual",
-        messages: [{ role: "user", content: "manual mode should not fail over" }]
-      })
-    });
-
-    expect(response.status).toBe(502);
-    const output = await response.json() as any;
-    expect(output.error.message).toContain("purchase/create failed");
-    // v1.2: the buyer no longer fetches the seller manifest per request.
-    // The registry's `models` field is the source of truth. Auto-purchase
-    // is still attempted once before failing over.
-    expect(routeEvents()).toEqual([
-      { seller: "primary-seller", url: "/primary/purchase/create" }
-    ]);
-
-    const purchases = await (await fetch(`http://127.0.0.1:${daemonControlPort}/ledger/purchases`)).json() as any;
-    const inferences = await (await fetch(`http://127.0.0.1:${daemonControlPort}/ledger/inferences`)).json() as any;
-    expect(purchases.purchases.some((entry: any) => entry.sellerKey === "backup-seller")).toBe(false);
-    expect(inferences.inferences.some((entry: any) => entry.sellerKey === "backup-seller")).toBe(false);
-  });
-
-  test("fixed routing pins to the configured seller id", 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: "fixed",
-        sellerId: "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("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: "manual selected seller should stay pinned" }]
-      })
-    });
-
-    expect(response.ok).toBe(true);
-    // v1.2: the buyer no longer fetches the seller manifest per request.
-    // The backup-seller is selected via the fixed seller routing config; the manifest
-    // is sourced from the registry's `models` field.
-    expect(routeEvents()).toEqual([
-      { seller: "backup-seller", url: "/backup/purchase/create" },
-      { seller: "backup-seller", url: "/backup/purchase/complete" },
-      { 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(routeEvents()).toEqual([
-      { seller: "backup-seller", url: "/backup/purchase/create" },
-      { seller: "backup-seller", url: "/backup/purchase/complete" },
-      { seller: "backup-seller", url: "/backup/v1/chat/completions" }
-    ]);
-  });
-
-  test("daemon applies tb routing set fullAuto without restart", async () => {
-    daemon.stop();
-    events.length = 0;
-    const store = new BuyerStore({ dbPath });
-    store.saveDaemonRuntimeConfig("routing", {
-      mode: "fixed",
-      sellerId: "primary-seller",
-      scorer: "discount"
-    });
-    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 initialStatus = await (await fetch(`http://127.0.0.1:${daemonControlPort}/status`)).json() as any;
-    expect(initialStatus.sellerRoutingMode).toBe("fixed");
-    expect(initialStatus.sellerRoutingScorer).toBe("discount");
-    expect(initialStatus.selectedSellerId).toBe("primary-seller");
-
-    const refreshedStore = new BuyerStore({ dbPath });
-    refreshedStore.saveDaemonRuntimeConfig("routing", {
-      mode: "fullAuto",
-      scorer: "balanced"
-    });
-    refreshedStore.close();
-
-    const reloadedStatus = await (await fetch(`http://127.0.0.1:${daemonControlPort}/status`)).json() as any;
-    expect(reloadedStatus.sellerRoutingMode).toBe("fullAuto");
-    expect(reloadedStatus.sellerRoutingScorer).toBe("balanced");
-    expect(reloadedStatus.selectedSellerId).toBeUndefined();
-    const prewarmBeforeRequest = await (await fetch(`http://127.0.0.1:${daemonControlPort}/v1.2/prewarm`)).json() as any;
-    const scheduledBeforeRequest = prewarmBeforeRequest.scheduler.totalScheduled;
-
-    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: "fullAuto should reload without restart" }]
-      })
-    });
-
-    expect(response.ok).toBe(true);
-    expect((await response.json() as any).id).toBe("backup-chat");
-    expect(routeEvents()).toEqual([
-      { seller: "backup-seller", url: "/backup/purchase/create" },
-      { seller: "backup-seller", url: "/backup/purchase/complete" },
-      { seller: "backup-seller", url: "/backup/v1/chat/completions" }
-    ]);
-    const prewarmAfterRequest = await (await fetch(`http://127.0.0.1:${daemonControlPort}/v1.2/prewarm`)).json() as any;
-    expect(prewarmAfterRequest.scheduler.totalScheduled).toBeGreaterThan(scheduledBeforeRequest);
-  });
-
-  test("routing preview uses seller manifest discount metadata", async () => {
-    const response = await fetch(
-      `http://127.0.0.1:${daemonControlPort}/routing/preview?modelId=gpt-manual&protocol=chat_completions&paymentMethod=mock&mode=fullAuto&scorer=discount`
-    );
-
-    expect(response.ok).toBe(true);
-    const preview = await response.json() as any;
-    expect(preview.plan.reason).toBe("fullAuto:discount:routes_2");
-    expect(preview.plan.routes.map((route: any) => route.seller.id)).toEqual(["backup-seller", "primary-seller"]);
-    expect(preview.plan.routes[0].metrics.discountRatio).toBe(0.01);
-    expect(preview.plan.routes[1].metrics.discountRatio).toBe(1);
-    expect(events).toEqual(expect.arrayContaining([
-      { seller: "primary-seller", url: "/primary/manifest" },
-      { seller: "backup-seller", url: "/backup/manifest" }
-    ]));
-  });
-
-  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(routeEvents()).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: "speed"
-      }
-    });
-    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(routeEvents()).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=route.candidates.prewarmed");
-    expect(requestLogs).toContain("event=route.selected");
-    expect(requestLogs).toContain("routePlanSource=registry_fallback");
-    expect(requestLogs).toContain("routePlanReason=fullAuto:speed: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");
-    expect(requestLogs).toContain("bodySummary=");
-    expect(requestLogs).not.toContain("upstreamBody=");
-    expect(logs).not.toContain(rawPrompt);
-  });
-
-  test("soft failure retry uses a fresh seller attempt id after upstream failure", async () => {
-    daemon.stop();
-    events.length = 0;
-    primaryPurchaseSucceeds = true;
-    primaryInferenceFailsOnceWithIdempotencyConflict = true;
-    const requestId = "auto_retry_fresh_seller_attempt_id";
-    daemon = new TokenbuddyDaemon({
-      controlPort: 0,
-      proxyPort: 0,
-      dbPath,
-      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
-      sellerRouting: {
-        mode: "fixed",
-        sellerId: "primary-seller",
-        scorer: "balanced"
-      }
-    });
-    daemon.start();
-    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
-    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
-
-    const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Idempotency-Key": "idem-fresh-seller-attempt"
-      },
-      body: JSON.stringify({
-        model: "gpt-manual",
-        messages: [{ role: "user", content: "retry should not reuse seller request id" }],
-        requestId
-      })
-    });
-
-    expect(response.ok).toBe(true);
-    expect((await response.json() as any).id).toBe("primary-chat");
-    const primaryInferenceCalls = events.filter((event) => event.url === "/primary/v1/chat/completions");
-    expect(primaryInferenceCalls).toHaveLength(2);
-    expect(primaryInferenceCalls.map((event) => event.body?.requestId)).toEqual([
-      requestId,
-      `${requestId}_r0_a1_n0`
-    ]);
-    expect(primaryInferenceCalls.map((event) => event.idempotencyKey)).toEqual([
-      "idem-fresh-seller-attempt",
-      "idem-fresh-seller-attempt_r0_a1_n0"
-    ]);
-
-    const inferences = await (await fetch(`http://127.0.0.1:${daemonControlPort}/ledger/inferences`)).json() as any;
-    expect(inferences.inferences).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        requestId,
-        sellerKey: "primary-seller",
-        endpoint: "/v1/chat/completions",
-        status: "estimated"
-      })
-    ]));
-    expect(JSON.stringify(inferences)).not.toContain(`${requestId}_r0_a1_n0`);
-  });
-
-  test("responses retry uses a fresh seller attempt id after upstream failure", async () => {
-    daemon.stop();
-    events.length = 0;
-    primaryPurchaseSucceeds = true;
-    primaryInferenceFailsOnceWithIdempotencyConflict = true;
-    const requestId = "responses_retry_fresh_seller_attempt_id";
-    daemon = new TokenbuddyDaemon({
-      controlPort: 0,
-      proxyPort: 0,
-      dbPath,
-      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
-      sellerRouting: {
-        mode: "fixed",
-        sellerId: "primary-seller",
-        scorer: "balanced"
-      }
-    });
-    daemon.start();
-    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
-    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
-
-    const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/responses`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Idempotency-Key": "idem-responses-fresh-seller-attempt"
-      },
-      body: JSON.stringify({
-        model: "gpt-manual",
-        input: "retry should not reuse seller request id",
-        requestId
-      })
-    });
-
-    expect(response.ok).toBe(true);
-    expect((await response.json() as any).id).toBe("primary-response");
-    const primaryInferenceCalls = events.filter((event) => event.url === "/primary/v1/responses");
-    expect(primaryInferenceCalls).toHaveLength(2);
-    expect(primaryInferenceCalls.map((event) => event.body?.requestId)).toEqual([
-      requestId,
-      `${requestId}_r0_a1_n0`
-    ]);
-    expect(primaryInferenceCalls.map((event) => event.idempotencyKey)).toEqual([
-      "idem-responses-fresh-seller-attempt",
-      "idem-responses-fresh-seller-attempt_r0_a1_n0"
-    ]);
-
-    const inferences = await (await fetch(`http://127.0.0.1:${daemonControlPort}/ledger/inferences`)).json() as any;
-    expect(inferences.inferences).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        requestId,
-        sellerKey: "primary-seller",
-        endpoint: "/v1/responses",
-        status: "estimated"
-      })
-    ]));
-    expect(JSON.stringify(inferences)).not.toContain(`${requestId}_r0_a1_n0`);
-  });
-
-  test("fullAuto routing treats busy_capacity as a capacity block and starts the next request on backup", async () => {
-    daemon.stop();
-    events.length = 0;
-    primaryPurchaseSucceeds = true;
-    primaryInferenceBusy = true;
-    daemon = new TokenbuddyDaemon({
-      controlPort: 0,
-      proxyPort: 0,
-      dbPath,
-      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
-      sellerRouting: {
-        mode: "fullAuto",
-        scorer: "speed"
-      }
-    });
-    daemon.start();
-    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
-    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
-
-    const first = 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: "primary is at capacity" }]
-      })
-    });
-
-    expect(first.ok).toBe(true);
-    expect((await first.json() as any).id).toBe("backup-chat");
-    expect(routeEvents()).toEqual([
-      { seller: "primary-seller", url: "/primary/purchase/create" },
-      { seller: "primary-seller", url: "/primary/purchase/complete" },
-      { 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" }
-    ]);
-
-    events.length = 0;
-    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: "capacity block should still be active" }]
-      })
-    });
-
-    expect(second.ok).toBe(true);
-    expect((await second.json() as any).id).toBe("backup-chat");
-    expect(routeEvents()).toEqual([
-      { seller: "backup-seller", url: "/backup/v1/chat/completions" }
-    ]);
-  });
-
-  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: "speed"
-      },
-      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;
-    primaryPurchaseSucceeds = false;
-    daemon = new TokenbuddyDaemon({
-      controlPort: 0,
-      proxyPort: 0,
-      dbPath,
-      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
-      sellerRouting: {
-        mode: "fullAuto",
-        scorer: "speed"
-      }
-    });
-    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(routeEvents()).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=failover_next");
-    expect(requestLogs).not.toContain("event=route.failover.retry_scheduled");
-  });
-});