@tokenbuddy/tokenbuddy 1.0.5 → 1.0.7

package/tests/tokenbuddy.test.ts

@@ -1,6 +1,19 @@
 import { TokenbuddyDaemon } from "../src/daemon.js";
-import { BuyerStore, resolveBuyerStorePath } from "../src/buyer-store.js";
-import { buildCli } from "../src/cli.js";
+import { BuyerStore, resolveBuyerStorePath, type PaymentConfig } from "../src/buyer-store.js";
+import {
+  buildCli,
+  fetchClawtipBootstrap,
+  normalizeClawtipBootstrapResourceUrl,
+} from "../src/cli.js";
+import {
+  checkOpenClawRuntime,
+  parseClawtipCliOutput,
+  readClawtipPayCredential,
+  resolveClawtipQrMediaPath,
+  startClawtipWalletBootstrap,
+  waitForClawtipActivationConfirmation,
+  writeClawtipOrderFile,
+} from "../src/init-clawtip-activation.js";
 import {
   applyProviderInstall,
   detectProviders,
@@ -8,13 +21,33 @@ import {
   rollbackProviderInstall
 } from "../src/provider-install.js";
 import { detectTerminals } 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";
 
 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 {
@@ -108,15 +141,27 @@ describe("BuyerStore safe SQLite persistence", () => {
     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")).toEqual({
+    expect(store.getToken("seller-a")).toMatchObject({
       token: "raw-token-secret",
-      balanceMicros: 500000
+      balanceMicros: 500000,
+      reservedMicros: 0,
+      spentMicros: 0,
+      balanceSource: "purchase_complete"
     });
 
-    store.deductBalance("seller-a", 120000);
-    expect(store.getToken("seller-a")).toEqual({
+    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: 380000
+      balanceMicros: 499890,
+      reservedMicros: 0,
+      spentMicros: 110,
+      balanceSource: "seller_settlement_summary"
     });
   });
 
@@ -125,6 +170,47 @@ describe("BuyerStore safe SQLite persistence", () => {
     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",
+      sellerId: "seller-a",
+    });
+    store.saveDaemonRuntimeConfig("routing", {
+      mode: "fixed",
+      sellerId: "seller-a",
+    });
+
+    expect(store.getProviderRuntimeConfig("opencode")).toMatchObject({
+      providerId: "opencode",
+      config: expect.objectContaining({
+        defaultModel: "gpt-5.5",
+        sellerId: "seller-a",
+      }),
+    });
+    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", () => {
@@ -374,31 +460,726 @@ describe("TokenBuddy payment CLI", () => {
   });
 });
 
+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("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-wallet-bootstrap",
+      skillId: "si-tb-wallet-bootstrap",
+      description: "TokenBuddy ClawTip wallet activation",
+      resourceUrl: "https://tb-wallet-bootstrap.fly.dev"
+    }, {
+      home: path.join(TEMP_STORE_ROOT, "clawtip-error-home"),
+      runClawtipCommand: async () => "ClawTip 返回错误：商家信息有误",
+    })).rejects.toThrow("ClawTip pay failed: ClawTip 返回错误：商家信息有误");
+  });
+
+  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-wallet-bootstrap.fly.dev",
+      "https://tb-wallet-bootstrap.fly.dev/registry/sellers"
+    )).toBe("https://tb-wallet-bootstrap.fly.dev");
+
+    expect(normalizeClawtipBootstrapResourceUrl(
+      "https://tb-wallet-bootstrap.fly.dev/base",
+      "https://tb-wallet-bootstrap.fly.dev/registry/sellers"
+    )).toBe("https://tb-wallet-bootstrap.fly.dev/base");
+
+    expect(normalizeClawtipBootstrapResourceUrl(
+      "https://tb-wallet-bootstrap.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://tb-wallet-bootstrap.fly.dev/registry/sellers",
+      }
+    }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    })) as typeof fetch;
+
+    try {
+      await expect(fetchClawtipBootstrap("https://tb-wallet-bootstrap.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-wallet-bootstrap",
+      skillId: "si-tb-wallet-bootstrap",
+      description: "TokenBuddy ClawTip wallet activation",
+      resourceUrl: "https://tb-wallet-bootstrap.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-wallet-bootstrap",
+      order_no: "order_123",
+      amount: 1,
+      encrypted_data: "ciphertext",
+      pay_to: "pay-to-test",
+      slug: "tb-wallet-bootstrap",
+      resource_url: "https://tb-wallet-bootstrap.fly.dev"
+    }));
+  });
+
+  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-wallet-bootstrap",
+      skillId: "si-tb-wallet-bootstrap",
+      description: "TokenBuddy ClawTip wallet activation",
+      resourceUrl: "https://tb-wallet-bootstrap.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("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-wallet-bootstrap",
+      skillId: "si-tb-wallet-bootstrap",
+      description: "TokenBuddy ClawTip wallet activation",
+      resourceUrl: "https://tb-wallet-bootstrap.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-wallet-bootstrap",
+      skillId: "si-tb-wallet-bootstrap",
+      description: "TokenBuddy ClawTip wallet activation",
+      resourceUrl: "https://tb-wallet-bootstrap.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: 45678
+          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" }
+            {
+              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;
@@ -406,11 +1187,14 @@ describe("TokenBuddy JSON inspection commands", () => {
       res.statusCode = 404;
       res.end(JSON.stringify({ error: "not_found" }));
     });
-    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 = "45678";
-      done();
+    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();
+      });
     });
   });
 
@@ -425,8 +1209,22 @@ describe("TokenBuddy JSON inspection commands", () => {
     } 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(done);
+    controlServer.close(() => proxyServer.close(() => {
+      rmDir(INSPECTION_STORE_ROOT);
+      rmDir(INSPECTION_HOME);
+      done();
+    }));
   });
 
   test("doctor --json reports daemon and provider state", async () => {
@@ -442,7 +1240,7 @@ describe("TokenBuddy JSON inspection commands", () => {
     expect(parsed.daemon).toMatchObject({
       running: true,
       controlPort,
-      proxyPort: 45678,
+      proxyPort,
       fixAvailable: true
     });
     expect(parsed.repair).toMatchObject({
@@ -450,12 +1248,60 @@ describe("TokenBuddy JSON inspection commands", () => {
       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) => {
@@ -466,47 +1312,127 @@ describe("TokenBuddy JSON inspection commands", () => {
 
     expect(output).toHaveLength(1);
     const parsed = JSON.parse(output[0]) as any;
-    expect(parsed.data).toEqual([
-      { id: "gpt-4", sellerId: "json-test-seller" }
+    expect(parsed.grouped).toEqual([
+      expect.objectContaining({
+        id: "gpt-4",
+        sellerCount: 1,
+        discountRange: "0.25",
+        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("0.25");
+    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", "config.json"), JSON.stringify({ keep: "field" }, 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", detected: true }),
-      expect.objectContaining({ id: "claude-code", detected: true }),
-      expect.objectContaining({ id: "openclaw", detected: true }),
-      expect.objectContaining({ id: "hermes", detected: false })
+      expect.objectContaining({ id: "codex", status: "configured", configured: true }),
+      expect.objectContaining({ id: "claude-code", status: "configured", configured: true }),
+      expect.objectContaining({ id: "openclaw", status: "configured", configured: true }),
+      expect.objectContaining({ id: "hermes", status: "installed", configured: false })
     ]));
 
     const changes = previewProviderInstall({
       providers: ["codex", "claude-code", "openclaw", "hermes"],
       proxyUrl,
-      model: "gpt-4",
+      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
     });
 
@@ -517,13 +1443,89 @@ describe("Provider install planning", () => {
     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", "config.json"), { force: true });
+    fs.writeFileSync(path.join(PROVIDER_HOME, ".openclaw", "openclaw.json"), JSON.stringify({ profile: "default" }, null, 2), "utf8");
+    fs.mkdirSync(path.join(PROVIDER_HOME, ".hermes"), { recursive: true });
+    fs.writeFileSync(path.join(PROVIDER_HOME, ".hermes", "config.yaml"), "model: gpt-4\n", "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", "openclaw.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", "config.yaml")]),
+      }),
+    ]));
+  });
+
   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", "hermes"],
+        providers: ["codex", "claude-code", "openclaw", "opencode", "hermes"],
         proxyUrl,
-        model: "gpt-4",
+        providerSelections: {
+          codex: {
+            selectionKind: "single-model",
+            protocolPreference: "responses",
+            defaultModel: "gpt-4",
+            sellerId: "seller-one",
+          },
+          "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",
+            sellerId: "seller-one",
+          },
+          opencode: {
+            selectionKind: "single-model",
+            protocolPreference: "responses",
+            defaultModel: "gpt-4",
+            sellerId: "seller-one",
+          },
+          hermes: {
+            selectionKind: "single-model",
+            protocolPreference: "chat_completions",
+            defaultModel: "gpt-4",
+            sellerId: "seller-one",
+          },
+        },
+        sellerRouting: {
+          mode: "fixed",
+          sellerId: "seller-one",
+        },
         home: PROVIDER_HOME
       }, store);
       expect(applied).toEqual(expect.arrayContaining([
@@ -539,15 +1541,30 @@ describe("Provider install planning", () => {
       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")).toMatchObject({
+        config: expect.objectContaining({
+          mode: "fixed",
+          sellerId: "seller-one",
+        }),
+      });
 
       const openclaw = JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".openclaw", "config.json"), "utf8"));
       expect(openclaw.keep).toBe("field");
       expect(openclaw.api_url).toBe(proxyUrl);
+      const opencode = JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".config", "opencode", "opencode.json"), "utf8"));
+      expect(opencode.share).toBe("disabled");
+      expect(opencode.provider.tokenbuddy.options.baseURL).toBe(`${proxyUrl}/v1`);
+      expect(opencode.provider.tokenbuddy.models["gpt-4"].name).toBe("gpt-4");
       expect(fs.existsSync(path.join(PROVIDER_HOME, ".hermes", "settings.json"))).toBe(true);
       expect(store.getProviderInstallSnapshot("codex")).toBeDefined();
 
       const rolledBack = rollbackProviderInstall({
-        providers: ["codex", "claude-code", "openclaw", "hermes"],
+        providers: ["codex", "claude-code", "openclaw", "opencode", "hermes"],
         home: PROVIDER_HOME
       }, store);
 
@@ -557,8 +1574,11 @@ describe("Provider install planning", () => {
       ]));
       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", "config.json"), "utf8"))).toEqual({ keep: "field" });
+      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", "settings.json"))).toBe(false);
       expect(store.getProviderInstallSnapshot("codex")).toBeUndefined();
+      expect(store.getProviderRuntimeConfig("claude-code")).toBeUndefined();
+      expect(store.getDaemonRuntimeConfig("routing")).toBeUndefined();
     } finally {
       store.close();
     }
@@ -570,9 +1590,11 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
   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;
@@ -591,6 +1613,25 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
     });
   });
 
+  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");
@@ -674,6 +1715,22 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
         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({
@@ -682,12 +1739,37 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
           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");
+          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 }
@@ -703,6 +1785,30 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
           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 }
@@ -718,6 +1824,7 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
           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 }
@@ -742,6 +1849,8 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
     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({
@@ -772,6 +1881,28 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
       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({
@@ -907,11 +2038,75 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
     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}`;
 
@@ -954,6 +2149,19 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
     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",
@@ -985,6 +2193,30 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
     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",
@@ -1005,17 +2237,48 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
     const body = await response.text();
     expect(body).toContain("chatcmpl-stream");
     expect(body).toContain("[DONE]");
+    expect(body).not.toContain("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" })
+      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("normalizes responses SSE shape for OpenCode-compatible consumers", 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();
+    expect(body).toContain("response.content_part.added");
+    expect(body).toContain("response.content_part.done");
+    expect(body).toContain("\"item_id\":\"item_stream_shape\"");
+    expect(body).toContain("\"output_text\":\"hello\"");
+    expect(body).toContain("\"content\":[{\"type\":\"output_text\",\"text\":\"hello\",\"annotations\":[]}]");
+  });
+
   test("fails closed when no compatible seller can serve the requested model", async () => {
     const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
       method: "POST",
@@ -1108,6 +2371,41 @@ describe("TokenBuddy manual routing mode", () => {
         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") {
+        events.push({ seller: "backup-seller", url: req.url });
+        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" }));
@@ -1183,4 +2481,41 @@ describe("TokenBuddy manual routing mode", () => {
     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("pins manual routing to the configured seller id when selectedSellerId is set", async () => {
+    daemon.stop();
+    events.length = 0;
+    daemon = new TokenbuddyDaemon({
+      controlPort: 0,
+      proxyPort: 0,
+      dbPath,
+      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
+      selectionMode: "manual",
+      selectedSellerId: "backup-seller"
+    });
+    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.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);
+    expect(events).toEqual([
+      { seller: "backup-seller", url: "/backup/manifest" },
+      { seller: "backup-seller", url: "/backup/purchase/create" },
+      { seller: "backup-seller", url: "/backup/purchase/complete" },
+      { seller: "backup-seller", url: "/backup/v1/chat/completions" }
+    ]);
+  });
 });