mslxdff 0.1.149 → 0.1.151

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.149",
+  "version": "0.1.151",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/cli/commands/provider/cline-free.js

@@ -49,7 +49,10 @@ export async function handleClineFree(id, sub, rest = [], args = []) {
   const cat = await loadCatalog();
   const current = loadProviderAllowedModels("cline");
   const plan = computeNext(current, cat.ids, keepExtra);
-  const dryRun = !(isSync && yes);
+  // 兜底常量不是上游真相（与 daemon auto-sync 同一口径，ADR-0033）：上游不可达时拒绝写盘，
+  // 否则会把内置 FALLBACK_FREE 落成白名单，且 full-replace 还会挤掉 auto-sync 并入的 clinePass 条目。
+  const fallbackRefused = isSync && yes && cat.source === "fallback";
+  const dryRun = !(isSync && yes) || fallbackRefused;
   let written = [];
   if (isSync && !dryRun) {
     try {
@@ -85,7 +88,9 @@ export async function handleClineFree(id, sub, rest = [], args = []) {
   if (!isSync) {
     console.log(`\n预览（只读）。一键同步：mslxdff -provider cline free sync --yes   ·   只增不删：加 --keep-extra`);
   } else if (dryRun) {
-    console.log(`\n预览模式，未写入。执行：mslxdff -provider cline free sync --yes${keepExtra ? " --keep-extra" : ""}`);
+    console.log(fallbackRefused
+      ? `\n⛔ 上游目录不可达（${cat.error || cat.status}），已拒绝把内置兜底目录写进白名单——兜底常量不是上游真相（与 daemon auto-sync 同一口径）。待上游恢复后重试；确需手填用：mslxdff -provider cline allowlist set <id...>`
+      : `\n预览模式，未写入。执行：mslxdff -provider cline free sync --yes${keepExtra ? " --keep-extra" : ""}`);
   } else {
     console.log(`\n✅ 已写入 allowlist：${written.length} 个（providerConfigs.cline.allowedModels）`);
     console.log(`   生效：mslxdff -restart（daemon 的 /v1/models 聚合有 10 分钟缓存，重启即刷新）`);

package/src/cli/commands/provider/cline-quota.js

@@ -0,0 +1,65 @@
+/**
+ * mslxdff -provider cline quota [--json] [--account <hash>] [--model <substr>]
+ * 只读：聚合 cline-usage.jsonl 的账号×模型双口径统计，不碰转发/daemon/凭据。
+ * free 口径：本周期 tokens + 已完成周期数/上周期产出；pass 口径：近 24h + 累计。
+ * 空账本给空状态引导；--json 供脚本消费。
+ */
+import { normalizeProviderId } from "../../../providers/model-id.js";
+import { loadAndAggregate } from "../../../providers/cline/usage.js";
+
+function pickOpt(args, name) {
+  const i = args.indexOf(name);
+  if (i < 0) return "";
+  const v = args[i + 1];
+  return v && !String(v).startsWith("-") ? String(v) : "";
+}
+
+/** 纯渲染：entries 为 aggregateUsage 的 value 数组（可单测，不碰 IO）。 */
+export function formatQuota(entries) {
+  const list = [...(entries || [])];
+  if (!list.length) {
+    return [
+      "cline quota：账本为空（cline-usage.jsonl 无记录）。",
+      "先用 cline 模型成功跑一轮对话（流式/非流式都会记账），再来看：",
+      "  mslxdff -provider cline quota",
+    ].join("\n");
+  }
+  const byAcct = new Map();
+  for (const e of list) {
+    if (!byAcct.has(e.accountId)) byAcct.set(e.accountId, []);
+    byAcct.get(e.accountId).push(e);
+  }
+  const lines = [`cline quota：${byAcct.size} 个账号 · ${list.length} 条账号×模型`];
+  for (const [acct, rows] of byAcct) {
+    lines.push(`\n[${acct}]`);
+    for (const r of rows.sort((a, b) => String(a.model).localeCompare(String(b.model)))) {
+      if (r.modelType === "free") {
+        lines.push(`  ${r.model}（free）：本周期 ${r.currentCycleTokens} · 已完成 ${r.completedCycles} 周期（上周期 ${r.lastCompletedCycleTokens}）· 累计 ${r.totalTokens}`);
+      } else {
+        lines.push(`  ${r.model}（pass）：近24h ${r.last24hTokens} · 累计 ${r.totalTokens}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+export async function handleClineQuota(id, sub, rest = [], args = []) {
+  if (normalizeProviderId(id) !== "cline") return false;
+  if (String(sub || "").toLowerCase() !== "quota") return false;
+  const wantsJson = args.includes("--json") || args.includes("-json");
+  const acctFilter = pickOpt(args, "--account");
+  const modelFilter = pickOpt(args, "--model");
+  const map = await loadAndAggregate();
+  let entries = [...map.values()];
+  if (acctFilter) entries = entries.filter((e) => e.accountId === acctFilter);
+  if (modelFilter) entries = entries.filter((e) => String(e.model || "").includes(modelFilter));
+  if (wantsJson) {
+    console.log(JSON.stringify({ provider: "cline", entries }, null, 2));
+    process.exit(0);
+  }
+  console.log(formatQuota(entries));
+  if (!entries.length && map.size > 0) {
+    console.log("\n（过滤条件无命中，去掉 --account/--model 再试）");
+  }
+  process.exit(0);
+}

package/src/cli/commands/provider/index.js

@@ -89,6 +89,8 @@ const { handleQoderLogin } = await import("./qoder-login.js");
   if (await handleProviderBench(id, sub, rest, args)) return true;
   const { handleClineFree } = await import("./cline-free.js");
   if (await handleClineFree(id, sub, rest, args)) return true;
+  const { handleClineQuota } = await import("./cline-quota.js");
+  if (await handleClineQuota(id, sub, rest, args)) return true;
   if (normalizeProviderId(id) === "cline" && sub === "migrate") {
     const { runStateMigrations } = await import("../../../state/migrations.js");
     const dryRun = args.includes("--dry-run") || args.includes("--dryrun");

package/src/cli/format.js

@@ -109,6 +109,21 @@ export function fmtEvent(e) {
     case "auto-update-query-failed":
     case "auto-update-install-failed":
       return `${head} auto-update   failed ${e.type} error=${e.error||""}`;
+    case "cline-account-state": {
+      // 限流是「账号 × 模型」维度：模型名打头，pool 表示该模型上的可用账号，
+      // 避免把"这个模型的免费额度用尽"误读成"整池账号报废"。
+      const p = e.pool ? ` acct-ready=${e.pool.ready}/${e.pool.total}` : "";
+      const lm = e.limitedModel ? ` upstream=${e.limitedModel}` : "";
+      const detail = [e.reason, e.status ? `HTTP ${e.status}` : "", e.cooldownMs ? `cool ${Math.round(e.cooldownMs / 1000)}s` : ""].filter(Boolean).join(" ");
+      const hint = e.state === "pool-exhausted" ? " [该模型所有账号额度耗尽 → 换模型或等冷却]" : e.state === "switch" ? " [换号重试]" : e.state === "force-retry" ? " [全部号冷却中，强行取号重试]" : "";
+      return `${head} cline acct    ${e.state} model=${m(e.model)}${lm} account=${m(e.accountId)}${e.from ? ` from=${e.from}` : ""}${detail ? ` ${detail}` : ""}${p}${hint}`;
+    }
+    case "cline-model-usage":
+      return `${head} cline tokens  ${e.state === "limit" ? "限流封存" : "正常输出"}${e.estimated ? "(估算)" : ""} model=${m(e.model)} account=${m(e.accountId)} output=${m(e.outputTokens)} 周期累计=${m(e.cycleOutputTokens)}${e.cycleCount ? ` 第${e.cycleCount}周期` : ""}${e.reason ? ` reason=${e.reason}` : ""}`;
+    case "provider-state":
+      return `${head} provider      ${m(e.provider)} ${m(e.state)}${e.keys !== undefined ? ` keys=${e.keys}` : ""}${e.accounts !== undefined ? ` accounts=${e.accounts}` : ""}${e.baseUrl ? ` baseUrl=${e.baseUrl}` : ""}${e.error ? ` error=${e.error}` : ""}`;
+    case "provider-model-state":
+      return `${head} prov model    ${m(e.provider)} ${m(e.state)} model=${m(e.model)}${e.status ? ` HTTP ${e.status}` : ""}${e.error ? ` error=${e.error}` : ""}${e.durationMs !== undefined ? ` ${fmtDur(e.durationMs)}` : ""}`;
     default:
       return `${head} ${e?.type || "?"} ${JSON.stringify(e || {})}`;
   }

package/src/providers/cline/allowlist-sync.js

@@ -0,0 +1,93 @@
+/**
+ * Cline 白名单自动同步（上游列表 = 真相）。
+ *
+ * 背景：`providerConfigs.cline.allowedModels` 是一份**静态快照**（历史由 `-provider cline free sync --yes` 一次性写入）。
+ * 上游 `recommended-models` 会漂移——新模型上架免费通道、同一模型从 `cline-pass/` 挪到 `cline-free/`——
+ * 而静态快照不跟着变，于是 `isModelAllowed()` 精确匹配失败，把上游明明免费可用的模型当成"未授权"拦掉
+ * （实测 2026-09-24：`cline-free/gemini-3.8-flash`、`stealth/space-bunny-alpha`、`cline-free/mimo-v2.6-flash` 被拦，
+ *  而 allowlist 里只有 `cline-pass/mimo-v2.6-flash`，通道不同即视为不同 id）。
+ *
+ * 本模块把语义改成「每次成功读取上游列表后，立即把上游 id 并进白名单」：
+ *   - **只增不减**：上游下架的 id 保留在表内（与 modelPicks 孤儿"仅标记不自动删"的既有口径一致，回收走 prune），
+ *     避免同步动作变成删配置。
+ *   - **仅在上游成功路径调用**：内置兜底常量不是上游真相，写盘只会污染（由调用方保证，见 models.js）。
+ *   - **无新增不写盘**：上游 10 分钟缓存内反复命中同一列表时零写放大。
+ * 关掉：`MSLXDFF_CLINE_AUTOSYNC=0`（退回纯静态白名单行为）。
+ * Note: 只增不减 + 仅上游成功路径同步的取舍见 .agents/notes/implemented/feature/2026-09-24-cline-auto-sync-free-catalog.md
+ *
+ * 纯逻辑（planMerge）无 IO，可单测；IO 全走注入。
+ */
+
+/** 与 state/provider-config.js 的 normalizeAllowedModel 对齐：只剥首段等于 providerId 的前缀。调用方可注入同名函数保证单一真相。 */
+export function defaultNormalize(model, providerId) {
+  let s = String(model || "").trim();
+  if (!s) return "";
+  const idx = s.indexOf("/");
+  if (idx > 0 && s.slice(0, idx).toLowerCase() === String(providerId || "").toLowerCase()) s = s.slice(idx + 1);
+  return s;
+}
+
+/**
+ * 求并集：保留 current 原顺序与全部既有条目，把 upstreamIds 中缺失的追加到尾部。
+ * @param {string[]} current 当前白名单（裸 id）
+ * @param {string[]} upstreamIds 上游模型 id（可带 provider 前缀，内部归一）
+ * @param {(m:string, pid:string)=>string} [normalize]
+ * @param {string} [providerId]
+ * @returns {{next:string[], added:string[]}}
+ */
+export function planMerge(current, upstreamIds, normalize = defaultNormalize, providerId = "") {
+  const cur = Array.isArray(current) ? current : [];
+  const next = [...new Set(cur.map((m) => normalize(m, providerId)).filter(Boolean))];
+  const seen = new Set(next);
+  const added = [];
+  for (const raw of Array.isArray(upstreamIds) ? upstreamIds : []) {
+    const norm = normalize(raw, providerId);
+    if (!norm || seen.has(norm)) continue;
+    seen.add(norm);
+    next.push(norm);
+    added.push(norm);
+  }
+  return { next, added };
+}
+
+/**
+ * @param {object} opts
+ * @param {string} opts.providerId
+ * @param {() => string[]} opts.loadCurrent 读当前白名单（裸 id 数组）
+ * @param {(id:string, list:string[]) => unknown} opts.persist 写回白名单
+ * @param {(msg:string) => void} [opts.onLog]
+ * @param {(m:string, pid:string)=>string} [opts.normalize]
+ * @param {boolean} [opts.enabled] 显式覆盖 env 开关
+ */
+export function createAllowlistSync({ providerId, loadCurrent, persist, onLog, normalize = defaultNormalize, enabled } = {}) {
+  const isEnabled = () => {
+    if (typeof enabled === "boolean") return enabled;
+    return String(process.env.MSLXDFF_CLINE_AUTOSYNC ?? "") !== "0";
+  };
+  const log = (msg) => { try { onLog?.(msg); } catch {} };
+
+  /**
+   * 把一批上游模型并进白名单。
+   * @param {{id?:string}[]|string[]} models 上游模型对象数组或 id 数组
+   * @returns {{skipped:string, added:string[], total:number}}
+   */
+  function syncIds(models) {
+    if (!isEnabled()) return { skipped: "disabled", added: [], total: 0 };
+    if (!Array.isArray(models) || !models.length) return { skipped: "empty", added: [], total: 0 };
+    try {
+      const ids = models.map((m) => (typeof m === "string" ? m : m?.id)).filter(Boolean);
+      const cur = loadCurrent() || [];
+      const { next, added } = planMerge(cur, ids, normalize, providerId);
+      if (!added.length) return { skipped: "", added: [], total: next.length };
+      persist(providerId, next);
+      log(`[${providerId}] allowlist auto-sync: +${added.length} → ${next.length} total (${added.join(", ")})`);
+      return { skipped: "", added, total: next.length };
+    } catch (err) {
+      // 同步是增益动作，失败绝不打断模型列表读取与请求链路
+      log(`[${providerId}] allowlist auto-sync failed: ${String(err?.message || err)}`);
+      return { skipped: "error", added: [], total: 0 };
+    }
+  }
+
+  return { syncIds };
+}

package/src/providers/cline/auth.js

@@ -1,11 +1,20 @@
 import { joinUrl, sleep } from "../base.js";
 import { compatFetch } from "../../compat.js";
+import { appendEvent } from "../../logs.js";
+import { createHash } from "node:crypto";
 
 /**
  * Cline Token 池：多账号 round-robin + refresh 换 accessToken + 冷却 + 队列
  * 对标 pingmike2/cline2api-workers 的 accounts / getAccountToken / parseCooldown / enqueue
  */
 
+
+// 只记哈希标识，不落邮箱 / refreshToken（events.log 可读不可泄）
+function acctId(account) {
+  const seed = String(account?.refreshToken || "");
+  if (!seed) return "slot-unknown";
+  return `acct_${createHash("sha256").update(seed).digest("hex").slice(0, 8)}`;
+}
 export function parseCooldown(body, status) {
   const m = String(body || "").match(/try again in (?:(\d+)\s*h)?\s*(?:(\d+)\s*m)?\s*(?:(\d+)\s*s)?/i);
   if (m) {
@@ -86,7 +95,7 @@ export function createAuthPool({
     }
     const changed = accounts.length !== list.length || accounts.some((a, i) => a.refreshToken !== list[i]);
     if (changed) {
-      accounts = list.map((rt) => ({ refreshToken: rt, accessToken: null, expiry: 0, cooldownUntil: 0 }));
+      accounts = list.map((rt) => ({ refreshToken: rt, accessToken: null, expiry: 0, cooldownUntil: 0, limits: {} }));
       accountIndex = 0;
     }
     return accounts;
@@ -100,14 +109,27 @@ export function createAuthPool({
     queueTail = run.catch(() => {});
     return run;
   }
+  // 模型级限流：Cline 免费额度按「账号 × 模型」计，429 只应挡该模型，
+  // 不得把整个号冻住（muse-spark 被限时 deepseek 仍须能用同一账号）。
+  function markLimit(account, model, cooldownMs) {
+    if (!account || !model) return;
+    if (!account.limits) account.limits = {};
+    account.limits[model] = clock() + cooldownMs;
+  }
+  // 账号可用性：dead（账号死）/ cooldownUntil（refresh 失败，账号级）/ limits[model]（该模型 429）三关
+  function accountAvailable(acc, model, now = clock()) {
+    if (!acc || acc.dead) return false;
+    if (acc.cooldownUntil && acc.cooldownUntil > now) return false;
+    if (model && acc.limits && acc.limits[model] && acc.limits[model] > now) return false;
+    return true;
+  }
 
-  function pickAccount(pool) {
+  function pickAccount(pool, model) {
     const list = pool || accounts;
     for (let k = 0; k < list.length; k++) {
       const acc = list[accountIndex % list.length];
       accountIndex = (accountIndex + 1) % list.length;
-      if (acc.dead) continue;
-      if (!acc.cooldownUntil || acc.cooldownUntil <= clock()) {
+      if (accountAvailable(acc, model)) {
         currentAccount = acc;
         return acc;
       }
@@ -135,8 +157,14 @@ export function createAuthPool({
     if (!res.ok) {
       let t = "";
       try { t = await res.text(); } catch {}
-      if (isInvalidGrant(t, res.status)) { account.dead = true; throw new Error("invalid_grant"); }
-      account.cooldownUntil = now + 60 * 1000; throw new Error("refresh_failed");
+      if (isInvalidGrant(t, res.status)) {
+        account.dead = true;
+        appendEvent({ type: "cline-account-state", provider: id, state: "dead", accountId: acctId(account), status: res.status, reason: "invalid_grant" });
+        throw new Error("invalid_grant");
+      }
+      account.cooldownUntil = now + 60 * 1000;
+      appendEvent({ type: "cline-account-state", provider: id, state: "refresh-failed", accountId: acctId(account), status: res.status, cooldownMs: 60_000 });
+      throw new Error("refresh_failed");
     }
     let data;
     try { data = await res.json(); } catch { account.cooldownUntil = now + 60 * 1000; throw new Error("refresh_no_token"); }
@@ -159,20 +187,36 @@ export function createAuthPool({
     return accessToken;
   }
 
-  async function getAccessToken() {
+  async function getAccessToken(model) {
     const pool = accounts;
     if (pool.length === 0) throw new Error("缺少 CLINE_REFRESH_TOKEN（请用 cline_oauth.py 获取）");
     for (let attempt = 0; attempt < pool.length; attempt++) {
       const acc = pool[attempt % pool.length];
-      if (acc.dead) continue;
-      if (acc.cooldownUntil && acc.cooldownUntil > clock()) continue;
+      if (!accountAvailable(acc, model)) continue;
       currentAccount = acc;
       try { return await refreshOne(acc); } catch (e) { if (e.message === "account_cooldown") continue; continue; }
     }
     const acc = pool.find((a) => !a.dead) || null;
     if (!acc) throw new Error("无可用 Cline 账号");
     currentAccount = acc;
-    acc.cooldownUntil = 0;
+    // 防锁死：该模型全部号被限时，清掉这一号的该模型限制强取重试（只清模型维度，
+    // 不动账号级 cooldownUntil——那是 refresh 失败的冷却，仍由 accountAvailable 把关）。
+    if (model && acc.limits) delete acc.limits[model];
+    if (acc.cooldownUntil && acc.cooldownUntil > clock()) acc.cooldownUntil = 0;
+    appendEvent({
+      type: "cline-account-state",
+      provider: id,
+      state: "force-retry",
+      accountId: acctId(acc),
+      model,
+      reason: "all-accounts-cooling",
+      pool: {
+        total: pool.length,
+        cooling: pool.filter((a) => !accountAvailable(a, model)).length,
+        dead: pool.filter((a) => a.dead).length,
+        ready: pool.filter((a) => accountAvailable(a, model)).length,
+      },
+    });
     return refreshOne(acc);
   }
 
@@ -180,5 +224,5 @@ export function createAuthPool({
   function getAccounts() { return accounts; }
   function updateKeys(newKeys) { parseAccounts(newKeys); }
 
-  return { parseAccounts, getAccessToken, refreshOne, pickAccount, parseCooldown, enqueue, getCurrentAccount, getAccounts, updateKeys, _accounts: () => accounts };
+  return { parseAccounts, getAccessToken, refreshOne, pickAccount, parseCooldown, enqueue, getCurrentAccount, getAccounts, updateKeys, markLimit, accountAvailable, _accounts: () => accounts };
 }

package/src/providers/cline/chat.js

@@ -1,11 +1,41 @@
 import { joinUrl, sleep } from "../base.js";
+import { appendEvent } from "../../logs.js";
+import { createHash } from "node:crypto";
 import { clineHeaders } from "./headers.js";
 import { createTransport } from "../../transport/index.js";
 import { normalizeProviderId } from "../model-id.js";
+import { recordLimit, recordOutput, exactOutputTokens } from "./usage.js";
 import { createSdkDispatch } from "../../upstream-engine/sdk/dispatch.js";
 
 function genSessionId() { return `sess_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`; }
 
+// 只记哈希标识，不落邮箱 / refreshToken（events.log 可读不可泄）
+function acctId(account) {
+  const seed = String(account?.refreshToken || "");
+  if (!seed) return "slot-unknown";
+  return `acct_${createHash("sha256").update(seed).digest("hex").slice(0, 8)}`;
+}
+// 池子快照：ready/cooling 按「该模型」口径统计（ready=对该模型可用的号数）。
+// isReady 由调用方注入 authPool.accountAvailable(a, model)，避免与 auth 逻辑分叉。
+function poolStat(pool, isReady = () => true) {
+  let cooling = 0;
+  let dead = 0;
+  for (const a of pool || []) {
+    if (a.dead) dead++;
+    else if (!isReady(a)) cooling++;
+  }
+  const total = (pool || []).length;
+  return { total, cooling, dead, ready: total - cooling - dead };
+}
+
+// 429 错误体自带权威模型名（"...Daily free limit reached on model meta/muse-spark-1.3-contributor"）。
+function limitModelOf(bodyText) {
+  // 模型名可含 / . - _ : 字母数字（如 meta/muse-spark-1.3-contributor），
+  // 遇空格/引号/逗号/句号结尾或 "Try again" 前的空白即停。
+  const m = String(bodyText || "").match(/on model\s+([A-Za-z0-9/._:-]+?)(?=[\s"',]|\.\s|$)/i);
+  return m ? m[1] : "";
+}
+
 // stripProviderPrefix 只剥「本供应商」前缀（cline/<裸 id> → 裸 id），非本前缀（含上游自带多段 id
 // 如 meta/vendor/x）原样透传，不误削首段（旧实现按段数剥曾是潜在 bug）。
 function stripProviderPrefix(model, providerId) {
@@ -23,7 +53,7 @@ function unwrapData(obj) {
   return obj;
 }
 
-async function streamToNonStream(upstream) {
+async function streamToNonStream(upstream, track = null) {
   let content = "";
   let reasoning = "";
   let finishReason = null;
@@ -49,6 +79,11 @@ async function streamToNonStream(upstream) {
   const msg = { role: "assistant", content };
   if (reasoning) msg.reasoning = reasoning;
   if (!content && reasoning) { msg.content = reasoning; msg.reasoning_used_as_content = true; }
+  if (track) {
+    const exact = exactOutputTokens(usage);
+    if (exact) track({ tokens: exact, estimated: false });
+    else if (content || reasoning) track({ tokens: Math.ceil((content.length + reasoning.length) / 4), estimated: true });
+  }
   return {
     id: id || `gen_${Date.now()}`,
     object: "chat.completion",
@@ -74,7 +109,8 @@ export function createChatService({
   const sdk = createSdkDispatch({ id, providerName: id || "cline" });
 
   async function clineFetch(body, sessionId, allowSdk = false) {
-    const token = await authPool.getAccessToken();
+    const token = await authPool.getAccessToken(body?.model);
+    appendEvent({ type: "cline-account-state", provider: id || "cline", state: "selected", accountId: acctId(authPool.getCurrentAccount()), model: body?.model, pool: poolStat(authPool.getAccounts(), (a) => authPool.accountAvailable(a, body?.model)) });
     const headers = clineHeaders(sessionId, token);
     const finalUrl = joinUrl(resolvedBase, resolvedChat);
     const isStream = body?.stream === true;
@@ -85,6 +121,8 @@ export function createChatService({
     }
     return transport.request({ url: finalUrl, headers, body, stream: isStream, timeoutMs: connectTimeoutMs });
   }
+  // 记账回调：捕获当前账号哈希，成功输出进当前额度周期
+  const track = (model) => ({ tokens, estimated }) => recordOutput({ accountId: acctId(authPool.getCurrentAccount()), model, tokens, estimated }).catch(() => {});
 
   function isLimitHit(status, bodyText) {
     if (status === 429) return true;
@@ -113,9 +151,32 @@ export function createChatService({
         const { parseCooldown } = await import("./auth.js");
         const cooldownMs = parseCooldown(bodyText, resp.status);
         const cur = authPool.getCurrentAccount();
-        if (cur) { cur.cooldownUntil = Date.now() + cooldownMs; cur.accessToken = null; cur.expiry = 0; }
+        // 免费额度按「账号 × 模型」计：只把该模型挂到这个号上（limits[model]），
+        // 不动账号级 cooldownUntil、不清 accessToken——同号其它模型照常可用。
+        authPool.markLimit(cur, body?.model, cooldownMs);
+        const limitedModel = limitModelOf(bodyText);
+        if (limitedModel && limitedModel !== body?.model) authPool.markLimit(cur, limitedModel, cooldownMs);
+        const cycle = await recordLimit({ accountId: acctId(cur), model: body?.model, reason: resp.status === 429 ? "daily_limit" : "empty_response", status: resp.status, cooldownMs });
         const pool = authPool.getAccounts();
-        const hasOther = pool.some((a) => !a.cooldownUntil || a.cooldownUntil <= Date.now());
+        const ready = (a) => authPool.accountAvailable(a, body?.model);
+        const hasOther = pool.some(ready);
+        // 限流是「账号 × 模型」维度：429 只说明当前账号在这个模型上额度用尽，
+        // 换模型（如 muse-spark → deepseek）往往仍可用，故日志必须点名模型。
+        appendEvent({
+          type: "cline-account-state",
+          provider: id || "cline",
+          state: hasOther ? "switch" : "pool-exhausted",
+          accountId: acctId(cur),
+          model: body?.model,
+          limitedModel: limitedModel || undefined,
+          scope: "model",
+          reason: resp.status === 429 ? "daily_limit" : "empty_response",
+          status: resp.status,
+          cooldownMs,
+          pool: poolStat(pool, ready),
+          cycleOutputTokens: cycle?.cycleOutputTokens ?? 0,
+          cycleCount: cycle?.cycleCount ?? 0,
+        });
         if (!hasOther) return resp;
         await sleep(500 + Math.floor(Math.random() * 500));
         continue;
@@ -140,7 +201,7 @@ export function createChatService({
       }
       const ct = resp.headers.get("content-type") || "";
       let normalized = null;
-      if (ct.includes("text/event-stream")) normalized = await streamToNonStream(resp);
+      if (ct.includes("text/event-stream")) normalized = await streamToNonStream(resp, track(body?.model));
       else {
         const raw = await resp.json().catch(() => null);
         if (raw) normalized = unwrapData(raw);
@@ -154,7 +215,9 @@ export function createChatService({
       if (content && !isFallback) return { data: normalized };
       if (reasoning || isFallback) {
         const cur = authPool.getCurrentAccount();
-        if (cur) { cur.cooldownUntil = Date.now() + 30 * 1000; cur.accessToken = null; cur.expiry = 0; }
+        // 空响应是「模型 × 通道」形态问题（deepseek 非流式特性），同样只挡该模型。
+        authPool.markLimit(cur, body?.model, 30 * 1000);
+        appendEvent({ type: "cline-account-state", provider: id || "cline", state: "cooldown", accountId: acctId(cur), model: body?.model, reason: "empty_response", cooldownMs: 30000, scope: "model", pool: poolStat(authPool.getAccounts(), (a) => authPool.accountAvailable(a, body?.model)) });
         await sleep(300 + Math.floor(Math.random() * 300));
         resp = null;
         continue;
@@ -193,12 +256,26 @@ export function createChatService({
     for (const k of ["temperature", "top_p", "tools", "tool_choice", "stop", "presence_penalty", "frequency_penalty", "response_format", "user", "n", "seed"]) {
       if (body[k] !== undefined) upstreamBody[k] = body[k];
     }
+    // Gemini 3.x Flash 经 Vertex 的 maxOutputTokens 上限 65536：客户端（PI-Desktop 默认
+    // 128000）原样透传即 400 invalid argument（网关 SSE 内 detail：
+    // "Unable to submit request because it has a maxOutputTokens va..."）。
+    // 2026-09-25 直连实测：max 128000 必 400，65536/32000/500 全 200；
+    // reasoning_effort=high 单独不触发，仅夹上限。只夹 gemini，其他通道不动。
+    if (/gemini/i.test(String(upstreamModel || "")) && tokLimit > 65536) {
+      upstreamBody.max_tokens = 65536;
+      upstreamBody.max_completion_tokens = 65536;
+    }
     for (let netAttempt = 0; netAttempt < 3; netAttempt++) {
       try {
         const resp = await clineFetchWithRetry(upstreamBody, sessionId, isStream);
         if (!resp) throw new Error("empty response");
         if (!resp.ok) return resp;
-        if (isStream) return resp;
+        if (isStream) {
+          // 旁路观测：把本次选中的账号哈希与裸 model 挂到透传 Response 上，供 relay 记账用。
+          // 转发链路不读这两个字段；记账失败也不影响返回。见 .agents/notes/implemented/feature/2026-09-24-cline-usage-dualwindow.md
+          try { resp.clineAccountId = acctId(authPool.getCurrentAccount()); resp.clineModel = model; } catch {}
+          return resp;
+        }
         if (forceStream) {
           const ret = await nonStreamWithContentCheck(upstreamBody, sessionId, resp);
           if (ret.error) return ret.error;
@@ -213,6 +290,10 @@ export function createChatService({
         }
         const normalized = unwrapData(raw);
         normalized.model = model;
+        // 非流式终点：正文估算记账（上游有 usage 时 streamToNonStream 路径才拿得到精确值；此处 raw 无流）
+        const m2 = normalized?.choices?.[0]?.message || {};
+        const outLen2 = String(m2.content || "").length + String(m2.reasoning || "").length;
+        if (outLen2 > 0) track(model)({ tokens: Math.ceil(outLen2 / 4), estimated: true });
         return new Response(JSON.stringify(normalized), { status: 200, headers: { "Content-Type": "application/json" } });
       } catch (err) {
         if (netAttempt < 2 && String(err?.message || "").toLowerCase().includes("timed out")) { await sleep(300); continue; }

package/src/providers/cline/index.js

@@ -1,5 +1,5 @@
 import { createKeyRing } from "../keyring.js";
-  import { loadProviderKeys, loadProviderBaseUrl, loadProviderModelsPath, loadProviderChatPath, saveProviderConfig, loadProviderAuths } from "../../state.js";
+  import { loadProviderKeys, loadProviderBaseUrl, loadProviderModelsPath, loadProviderChatPath, saveProviderConfig, loadProviderAuths, loadProviderAllowedModels, saveProviderAllowedModels, normalizeAllowedModel } from "../../state.js";
 import { envInt, joinUrl, getUndici, createAgent, collectApiKeysGeneric, createChatRunner } from "../base.js";
 import { compatFetch } from "../../compat.js";
 import { joinModelId } from "../model-id.js";
@@ -9,6 +9,7 @@ import { createAuthPool } from "./auth.js";
 import { clineHeaders, isRefreshToken } from "./headers.js";
 import { createChatService } from "./chat.js";
 import { createModelsService } from "./models.js";
+import { createAllowlistSync } from "./allowlist-sync.js";
 
 const { UndiciFetch } = getUndici();
 
@@ -101,7 +102,18 @@ export function createClineProvider({
   }
 
   // 快照文件供 daemon 启动自检 free 列表增删（默认 logDir 下，gitignored；测试可注入 tmp 路径）
-  const modelsSvc = createModelsService({ id, baseUrl: resolvedBase, modelsPath: resolvedModelsPath, fetchImpl, dispatcher, ring, loadKeys: (pid) => loadProviderKeys(pid, file ? { file } : {}), snapshotPath: snapshotPath || join(logDir(), "cline-free.json") });
+  // 白名单 auto-sync（上游列表 = 真相）：每次成功取 recommended-models 后，把 free + clinePass
+  // 并进 providerConfigs.cline.allowedModels，只增不减——解决上游新上架/换通道的免费模型被静态快照拦成 blocked。
+  // persist 复用 saveProviderAllowedModels（保留 keys/auths/baseUrl，并保留 allowAnyModels）。
+  // 关掉：MSLXDFF_CLINE_AUTOSYNC=0；无新增不写盘。
+  const allowlistSync = createAllowlistSync({
+    providerId: id,
+    loadCurrent: () => loadProviderAllowedModels(id, file ? { file } : {}),
+    persist: (pid, list) => saveProviderAllowedModels(pid, list, file ? { file } : {}),
+    normalize: normalizeAllowedModel,
+    onLog: (msg) => console.log(msg),
+  });
+  const modelsSvc = createModelsService({ id, baseUrl: resolvedBase, modelsPath: resolvedModelsPath, fetchImpl, dispatcher, ring, loadKeys: (pid) => loadProviderKeys(pid, file ? { file } : {}), snapshotPath: snapshotPath || join(logDir(), "cline-free.json"), onModelsRefreshed: (list) => allowlistSync.syncIds(list) });
 
   async function listModels() {
     const list = await modelsSvc.listModels();

package/src/providers/cline/models.js

@@ -11,7 +11,16 @@ function isClineBotHost(baseUrl) {
   try { const u = new URL(baseUrl); return u.hostname === "api.cline.bot" || u.hostname.endsWith(".cline.bot"); } catch { return String(baseUrl).includes("cline.bot"); }
 }
 
-export function createModelsService({ id, baseUrl, modelsPath, fetchImpl, dispatcher, ring, loadKeys, snapshotPath } = {}) {
+export function createModelsService({ id, baseUrl, modelsPath, fetchImpl, dispatcher, ring, loadKeys, snapshotPath, onModelsRefreshed } = {}) {
+  // 白名单 auto-sync 通知：只在上游成功取数后调用（内置兜底不是上游真相，不触发）。
+  // 异常一律吞掉——同步是增益动作，绝不打断模型列表读取与请求链路。
+  function notifyRefresh(list) {
+    if (!onModelsRefreshed) return;
+    try {
+      const r = onModelsRefreshed(list);
+      if (r && typeof r.catch === "function") r.catch(() => {});
+    } catch {}
+  }
   if (!fetchImpl) fetchImpl = UndiciFetch || compatFetch;
   const resolvedBase = String(baseUrl).trim().replace(/\/+$/, "");
   const resolvedPath = modelsPath || "/ai/cline/recommended-models";
@@ -63,12 +72,12 @@ export function createModelsService({ id, baseUrl, modelsPath, fetchImpl, dispat
           }
         }
         if (!all.length) return fallbackList();
-        cache = all; fetchedAt = now; return all;
+        cache = all; fetchedAt = now; notifyRefresh(all); return all;
       }
       const raw = Array.isArray(json.data) ? json.data : Array.isArray(json.models) ? json.models : Array.isArray(json) ? json : [];
       const out = raw.filter((m) => m && typeof m.id === "string").map((m) => ({ ...m, id: joinModelId(id, m.id) }));
       if (!out.length) return fallbackList();
-      cache = out; fetchedAt = now; return out;
+      cache = out; fetchedAt = now; notifyRefresh(out); return out;
     } catch { return fallbackList(); } finally { clearTimeout(timer); }
   }
 
@@ -121,6 +130,9 @@ export function createModelsService({ id, baseUrl, modelsPath, fetchImpl, dispat
     // 这里 cat.models 只有 free，写进去会把 pass 挤掉 10 分钟（daemon 启动后 /v1/models 就缺 pass）。
     let change = null;
     if (snapshotPath) { try { change = detectFreeChanges(valid.map((m) => m.id)); } catch {} }
+    // 自检同样是一次「读取上游」，故也喂给白名单 auto-sync：开机后即便没人访问 /v1/models，
+    // 新上架免费模型也已可用。这里只有 free（fetchFreeCatalog 只抽 free），clinePass 由 listModels 成功路径补齐。
+    notifyRefresh(valid);
     return {
       ok: true,
       status: cat.status,

package/src/providers/cline/usage.js

@@ -0,0 +1,274 @@
+// Cline 账号 × 模型用量统计（双口径）。
+// - free 模型：按「额度周期」统计——限额恢复后开始 → 再次到限额之间累计的 output tokens。
+// - pass 模型：按「最近 24h 滚动窗口」统计 output tokens。
+// Note: 双口径设计（isFreeModel + aggregateUsage）见 .agents/notes/implemented/feature/2026-09-24-cline-usage-dualwindow.md
+// 不记录 token、邮箱、prompt、响应正文；账号只使用调用方传入的稳定哈希。
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { logDir, appendEvent } from "../../logs.js";
+
+const FILE = "cline-usage.jsonl";
+const states = new Map();
+let loaded;
+
+// free 模型判定：后缀 -free / 含 :free / 已知免费家族；否则视为 pass（付费）
+const KNOWN_FREE_MODELS = ["muse-spark", "space-bunny-alpha", "solar-pro4", "laguna-s-2.1"];
+export function isFreeModel(id) {
+  const s = String(id || "").toLowerCase();
+  if (s.startsWith("cline-pass/")) return false;
+  if (s.startsWith("cline-free/")) return true;
+  if (s.endsWith("-free") || s.includes(":free")) return true;
+  if (KNOWN_FREE_MODELS.some((k) => s.includes(k))) return true;
+  return false;
+}
+// pass 模型统计窗口：最近 24 小时
+export const FREE_WINDOW = 24 * 3600 * 1000;
+
+function keyOf(accountId, model) {
+  return `${String(accountId || "unknown")}|${String(model || "unknown")}`;
+}
+
+function newState() {
+  return {
+    currentOutputTokens: 0,
+    cycleStartAt: Date.now(),
+    limitedUntil: 0,
+    completedCycles: 0,
+    lastCycleOutputTokens: 0,
+    lastCycleStartAt: null,
+    lastCycleEndAt: null,
+    lastReason: null,
+  };
+}
+
+async function ensureLoaded() {
+  if (!loaded) {
+    loaded = (async () => {
+      let text = "";
+      try { text = await readFile(join(logDir(), FILE), "utf8"); } catch { return; }
+      for (const line of text.split("\n")) {
+        if (!line) continue;
+        try {
+          const row = JSON.parse(line);
+          const k = keyOf(row.accountId, row.model);
+          const s = states.get(k) || newState();
+          if (row.type === "output") {
+            s.currentOutputTokens = Number(row.cycleOutputTokens) || 0;
+            s.cycleStartAt = Number(row.cycleStartAt) || Number(row.at) || s.cycleStartAt;
+            s.limitedUntil = 0;
+          } else if (row.type === "limit") {
+            s.completedCycles = Math.max(0, (Number(row.cycleCount) || 1) - 1);
+            s.lastCycleOutputTokens = Number(row.cycleOutputTokens) || 0;
+            s.lastCycleStartAt = Number(row.cycleStartAt) || null;
+            s.lastCycleEndAt = Number(row.at) || null;
+            s.lastReason = row.reason || null;
+            s.currentOutputTokens = 0;
+            s.cycleStartAt = 0;
+            s.limitedUntil = Number(row.until) || 0;
+          }
+          states.set(k, s);
+        } catch {}
+      }
+    })();
+  }
+  return loaded;
+}
+
+export function exactOutputTokens(usage) {
+  const n = Number(usage?.completion_tokens ?? usage?.completionTokens ?? usage?.output_tokens ?? usage?.outputTokens);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+}
+
+// 上游有时不给 usage（本次真实 Cline 响应就是如此）；按输出正文估算并明确标记 estimated。
+function parseOutput(text) {
+  const s = String(text || "");
+  let parsed = null;
+  try { parsed = JSON.parse(s); } catch {}
+  if (parsed) {
+    const exact = exactOutputTokens(parsed?.usage || parsed);
+    if (exact) return { tokens: exact, estimated: false };
+    const output = parsed?.choices?.[0]?.message || parsed?.choices?.[0]?.delta || parsed?.output || parsed;
+    return { tokens: Math.ceil(JSON.stringify(output || "").length / 4), estimated: true };
+  }
+  let usage = null;
+  let output = "";
+  for (const line of s.split("\n")) {
+    const t = line.trim();
+    // transport 的 stream() 已剥掉 "data:" 前缀；SDK/原生流则带前缀。两种都认。
+    const raw = t.startsWith("data:") ? t.slice(5).trim() : t;
+    if (!raw || raw === "[DONE]") continue;
+    try {
+      const j = JSON.parse(raw);
+      if (j?.usage) usage = j.usage;
+      const piece = j?.choices?.[0]?.delta || j?.choices?.[0]?.message;
+      if (piece) output += JSON.stringify(piece);
+    } catch {}
+  }
+  const exact = exactOutputTokens(usage);
+  return exact ? { tokens: exact, estimated: false } : { tokens: Math.ceil(output.length / 4), estimated: true };
+}
+
+async function append(row) {
+  try {
+    await mkdir(logDir(), { recursive: true });
+    await appendFile(join(logDir(), FILE), JSON.stringify(row) + "\n");
+  } catch {}
+}
+
+function event(row) {
+  try { appendEvent({ ...row, type: "cline-model-usage" }); } catch {}
+}
+
+// free 模型才走「限额恢复 → 再次限额」的周期开关；pass 模型不开新周期（其统计由 aggregateUsage 按 24h 窗口切片）。
+function stateFor(accountId, model, now) {
+  const k = keyOf(accountId, model);
+  const s = states.get(k) || newState();
+  if (s.limitedUntil && now >= s.limitedUntil) {
+    s.limitedUntil = 0;
+    s.currentOutputTokens = 0;
+    s.cycleStartAt = now;
+  }
+  states.set(k, s);
+  return s;
+}
+
+// 在消费终点直接记账（比包装 Response 可靠：streamToNonStream 已解析出 usage/正文，网关透传已有累积 bytes）。
+export function usageFromData(data) {
+  const exact = exactOutputTokens(data?.usage);
+  if (exact) return { tokens: exact, estimated: false };
+  const msg = data?.choices?.[0]?.message;
+  const text = String(msg?.content || "") + String(msg?.reasoning || "");
+  if (!text) return { tokens: 0, estimated: false };
+  return { tokens: Math.ceil(text.length / 4), estimated: true };
+}
+
+
+export async function recordOutput({ accountId, model, tokens, outputTokens, estimated = false } = {}) {
+  // computeOutputRow 回的是 outputTokens，track/非流式路径传的是 tokens：两边都认，
+  // 否则 relay 旁路组合调用静默记不上（2026-09-25 gemini 流式零记账实测）。
+  const n = Number(tokens ?? outputTokens);
+  if (!model || !Number.isFinite(n) || n <= 0) return null;
+  await ensureLoaded();
+  const now = Date.now();
+  const free = isFreeModel(model);
+  const s = stateFor(accountId, model, now);
+  s.currentOutputTokens += n;
+  const row = {
+    type: "output", at: now, accountId: accountId || "unknown", model, modelType: free ? "free" : "pass",
+    outputTokens: n, estimated: !!estimated, cycleOutputTokens: s.currentOutputTokens,
+    cycleStartAt: s.cycleStartAt, cycleCount: s.completedCycles + 1,
+  };
+  await append(row);
+  event(row);
+  return row;
+}
+
+// 仅 free 模型会因 daily_limit 被封周期；pass 若收到 limit 也建 limit 行留痕，但不影响其 24h 窗口统计。
+export async function recordLimit({ accountId, model, reason = "daily_limit", status = 429, cooldownMs = 0 } = {}) {
+  if (!model) return null;
+  await ensureLoaded();
+  const now = Date.now();
+  const s = stateFor(accountId, model, now);
+  if (s.limitedUntil && s.limitedUntil > now) return null;
+  const row = {
+    type: "limit", at: now, accountId: accountId || "unknown", model, modelType: isFreeModel(model) ? "free" : "pass",
+    cycleOutputTokens: s.currentOutputTokens, cycleStartAt: s.cycleStartAt,
+    cycleEndAt: now, until: now + Math.max(0, Number(cooldownMs) || 0),
+    reason, status, cycleCount: s.completedCycles + 1,
+  };
+  s.completedCycles += 1;
+  s.lastCycleOutputTokens = s.currentOutputTokens;
+  s.lastCycleStartAt = s.cycleStartAt;
+  s.lastCycleEndAt = now;
+  s.lastReason = reason;
+  s.currentOutputTokens = 0;
+  s.cycleStartAt = 0;
+  s.limitedUntil = row.until;
+  await append(row);
+  event({ ...row, state: "limit" });
+  return row;
+}
+
+/**
+ * 纯聚合：把 cline-usage.jsonl 的行数组算成「每账号×模型」的双口径统计。无 IO，可直接单测。
+ * - free：currentCycleTokens = 最近一次限额恢复后到此刻的累计；completedCycles = 已封存周期数；
+ *          lastCompletedCycleTokens = 上一完整周期产出；totalTokens = 全时段总和。
+ * - pass：last24hTokens = 窗口内 (at > now-FREE_WINDOW) 的 output 之和；totalTokens = 全时段总和。
+ * @param {Array<{type:string,at:number,accountId:string,model:string,outputTokens:number,cycleOutputTokens?:number,cycleCount?:number,until?:number}>} rows
+ * @param {number} [now]
+ * @returns {Map<string,{accountId:string,model:string,modelType:"free"|"pass",currentCycleTokens:number,completedCycles:number,lastCompletedCycleTokens:number,last24hTokens:number,totalTokens:number}>}
+ */
+export function aggregateUsage(rows, now = Date.now()) {
+  const out = new Map();
+  const windowStart = now - FREE_WINDOW;
+  // 先按 key 分组，组内按时间升序处理，保证「周期/窗口」判定稳定。
+  const grouped = new Map();
+  for (const r of Array.isArray(rows) ? rows : []) {
+    if (!r || !r.model) continue;
+    const k = keyOf(r.accountId, r.model);
+    if (!grouped.has(k)) grouped.set(k, []);
+    grouped.get(k).push(r);
+  }
+  for (const [k, list] of grouped) {
+    list.sort((a, b) => (Number(a.at) || 0) - (Number(b.at) || 0));
+    const model = list[0].model;
+    const accountId = list[0].accountId || "unknown";
+    const free = isFreeModel(model);
+    let totalTokens = 0;
+    let last24hTokens = 0;
+    // free 周期游标
+    let cycleTokens = 0;
+    let completedCycles = 0;
+    let lastCompletedCycleTokens = 0;
+    for (const r of list) {
+      const at = Number(r.at) || 0;
+      const n = Number(r.outputTokens) || 0;
+      if (r.type === "output") {
+        totalTokens += n;
+        if (at > windowStart) last24hTokens += n;
+        if (free) cycleTokens += n;
+      } else if (r.type === "limit" && free) {
+        // 封存当前周期
+        completedCycles += 1;
+        lastCompletedCycleTokens = cycleTokens;
+        cycleTokens = 0;
+      }
+    }
+    out.set(k, {
+      accountId, model, modelType: free ? "free" : "pass",
+      currentCycleTokens: free ? cycleTokens : 0,
+      completedCycles: free ? completedCycles : 0,
+      lastCompletedCycleTokens: free ? lastCompletedCycleTokens : 0,
+      last24hTokens,
+      totalTokens,
+    });
+  }
+  return out;
+}
+
+// 读取 JSONL 全量并聚合（供 CLI / 报表消费）。IO 失败返回空 Map，不影响调用方。
+export async function loadAndAggregate(now = Date.now()) {
+  let text = "";
+  try { text = await readFile(join(logDir(), FILE), "utf8"); } catch { return new Map(); }
+  const rows = [];
+  for (const line of text.split("\n")) {
+    if (!line) continue;
+    try { rows.push(JSON.parse(line)); } catch {}
+  }
+  return aggregateUsage(rows, now);
+}
+// Note: 流式记账走 computeOutputRow（纯函数）+ recordOutput；reqId 登记表方案已否决（多一跳、无消费方），不保留。
+
+/**
+ * 从 relay-done 的流结果算 cline 专属 output tokens（纯函数，无 IO）。
+ * usage 有 completion_tokens → 记精确（estimated=false）；否则按 detail.chars 估算（estimated=true）。
+ * @param {{model:string, accountId?:string, usage?:object, chars?:number|null}} opts
+ * @returns {{accountId:string, model:string, outputTokens:number, estimated:boolean}|null} 零/负 token 返回 null（跳过）
+ */
+export function computeOutputRow({ model, accountId, usage, chars } = {}) {
+  if (!model) return null;
+  const exact = exactOutputTokens(usage);
+  const n = exact > 0 ? exact : (Number(chars) > 0 ? Math.ceil(Number(chars) / 4) : 0);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  return { accountId: accountId || "unknown", model, outputTokens: n, estimated: exact <= 0 };
+}

package/src/providers/dispatcher.js

@@ -1,3 +1,4 @@
+import { appendEvent } from "../logs.js";
 import { splitModelId, DEFAULT_PROVIDER, joinModelId } from "./model-id.js";
 import { isModelAllowed as stateIsAllowed, loadProviderAllowedModels as stateLoadAllowed, loadProviderAllowAnyModels as stateLoadAllowAny } from "../state.js";
 
@@ -44,18 +45,36 @@ export function createProviderDispatcher(providers = [], opts = {}) {
     if (!isAllowedFn(provider.id, raw)) {
       const allowed = getAllowedFn(provider.id) || [];
       const msg = `model not allowed for provider "${provider.id}": "${raw}" — allowed: ${allowed.join(", ") || "(none)"} (use: mslxdff -provider ${provider.id} allowlist add <model>)`;
+      appendEvent({ type: "provider-model-state", provider: provider.id, model: body?.model, rawModel: raw, state: "blocked", reason: "allowlist", status: 403 });
       return new Response(JSON.stringify({ error: msg }), { status: 403, headers: { "Content-Type": "application/json", "x-mslxdff-allowlist": "1" } });
     }
     const forwarded = raw === body?.model ? body : { ...body, model: raw };
     // ADR-0008：本请求携带瞬时共享 key（shareKeys 由组员侧按 header 解析后传入）。
     const sharedKeys = opts?.shareKeys?.[provider.id];
-    if (sharedKeys && sharedKeys.length && typeof provider.chatWithKeys === "function") {
-      return provider.chatWithKeys(forwarded, sharedKeys, opts);
-    }
-    if (provider.id === "workbuddy" && workbuddyUid) {
-      return provider.chat(forwarded, { ...opts, workbuddyUid });
+    const startedAt = Date.now();
+    let res;
+    try {
+      if (sharedKeys && sharedKeys.length && typeof provider.chatWithKeys === "function") {
+        res = await provider.chatWithKeys(forwarded, sharedKeys, opts);
+      } else if (provider.id === "workbuddy" && workbuddyUid) {
+        res = await provider.chat(forwarded, { ...opts, workbuddyUid });
+      } else {
+        res = await provider.chat(forwarded, opts);
+      }
+    } catch (err) {
+      appendEvent({ type: "provider-model-state", provider: provider.id, model: body?.model, rawModel: raw, state: "upstream-error", error: String(err?.message || err), durationMs: Date.now() - startedAt });
+      throw err;
     }
-    return provider.chat(forwarded, opts);
+    appendEvent({
+      type: "provider-model-state",
+      provider: provider.id,
+      model: body?.model,
+      rawModel: raw,
+      status: res?.status,
+      state: res?.status === 429 ? "limited" : res?.ok ? "ok" : "upstream-error",
+      durationMs: Date.now() - startedAt,
+    });
+    return res;
   }
 
   // 聚合所有供应商的模型列表；默认供应商（opencode）裸 id，其它带前缀

package/src/routes/chat/relay-pipeline.js

@@ -3,6 +3,7 @@ import { recordModelStats } from "../../state.js";
 import { normalizeFullId } from "../../providers/model-id.js";
 import { computeMetrics } from "../../metrics.js";
 import { recordChatUsage } from "../../usage/record.js"; // 窗口报表唯一写入点（canonical 名单记防双计）— 见 .agents/notes/implemented/feature/2026-09-19-usage-report-jsonl.md
+import { recordOutput, computeOutputRow } from "../../providers/cline/usage.js"; // cline 专属旁路统计（账号×模型，流式也覆盖）
 
 // 唯一/最后候选没有 failover 去向：首块闸门退化为纯"防连接泄漏"，放宽避免误杀慢模型
 // （参考 opencode：zen 通道不设超时；openai responses 硬编码 300s headerTimeout）
@@ -216,6 +217,13 @@ export function createRelayPipeline({
         // 窗口报表：逐请求落 usage（行形状由 usage/record.js 拥有，含 prompt/total ——
         // state 的 modelStats 只存 completion 的 EMA）。只按 canonical 名记一次，避免双计。
         recordChatUsage({ model: fullId, via, usage, ttfbMs: ttfb, totalMs: total, tps: m.tps }).catch(() => {});
+        // cline 旁路记账：流式时 provider 已把账号哈希挂在 upRes 上，这里用消费完的 usage 记一笔。
+        // 纯旁路：只调 recordOutput，不改转发/切号/重试；无账号或非 cline 直接跳过。
+        if (upRes?.clineAccountId) {
+          const clineModel = upRes.clineModel || String(actual).replace(/^cline\//, "");
+          const orow = computeOutputRow({ model: clineModel, accountId: upRes.clineAccountId, usage, chars });
+          if (orow) recordOutput(orow).catch(() => {});
+        }
       } catch {}
     }
 

package/src/runtime/providers-setup.js

@@ -100,6 +100,7 @@ export async function setupProviders() {
           providers.push(provider);
           console.log(`provider enabled: ${gid} (${keys.length} key${keys.length > 1 ? "s" : ""}) baseUrl=${base || provider.baseUrl} [custom]`);
           appendEvent({ ts: Date.now(), type: "provider-enabled", provider: gid, keys: keys.length, baseUrl: base || provider.baseUrl });
+          appendEvent({ type: "provider-state", provider: gid, state: "enabled", keys: keys.length, accounts: auths.length, baseUrl: base || provider.baseUrl });
         } catch (err) {
           console.log(`provider ${gid} failed: ${err?.message || err}`);
           appendEvent({ ts: Date.now(), type: "provider-error", provider: gid, error: String(err?.message || err) });
@@ -126,6 +127,7 @@ export async function setupProviders() {
           providers.push(createWorkbuddyProvider({ apiKeys: wbKeys, auths: wbAuths }));
           console.log(`provider enabled: workbuddy (${wbKeys.length} key${wbKeys.length > 1 ? "s" : ""}) baseUrl=https://copilot.tencent.com (env)`);
           appendEvent({ ts: Date.now(), type: "provider-enabled", provider: "workbuddy", keys: wbKeys.length, baseUrl: "https://copilot.tencent.com" });
+          appendEvent({ type: "provider-state", provider: "workbuddy", state: "enabled", keys: wbKeys.length, accounts: wbAuths.length });
         } catch (err) {
           console.log(`provider workbuddy failed: ${err?.message || err}`);
         }

package/src/state/schemas/allowlist.js

@@ -27,10 +27,15 @@ export function saveProviderAllowedModels(id, list, { file = defaultStateFile()
   const auths = normalizeAuths(cur.auths);
   const modelsPath = typeof cur.modelsPath === "string" ? normalizeEndpointPath(cur.modelsPath) : "";
   const chatPath = typeof cur.chatPath === "string" ? normalizeEndpointPath(cur.chatPath) : "";
-  if (!baseUrl && !keys.length && !auths.length && !clean.length && !modelsPath && !chatPath) {
+  // allowAnyModels 是独立语义开关：只有它也设过时，即使其余字段全空也不能整键删（否则 clear 会把「允许任意」连带抹掉，供应商从放行降级成全拦 403）
+  if (!baseUrl && !keys.length && !auths.length && !clean.length && !modelsPath && !chatPath && typeof cur.allowAnyModels !== "boolean") {
     delete configs[id];
   } else {
     configs[id] = { baseUrl, keys };
+    // 重建 cfg 是 `{ baseUrl, keys }` 起手，不显式带 allowAnyModels 就会静默丢用户的「允许任意」设置
+    // （实测 2026-09-24：saveProviderAllowedModels 把 allowAnyModels:true 抹成默认 false）。
+    // cline 白名单 auto-sync 会周期性写这里，丢了就是持续丢，必须保留。
+    if (typeof cur.allowAnyModels === "boolean") configs[id].allowAnyModels = cur.allowAnyModels;
     if (auths.length) configs[id].auths = auths;
     if (clean.length) configs[id].allowedModels = clean;
     if (modelsPath) configs[id].modelsPath = modelsPath;

package/src/state/schemas/provider.js

@@ -183,6 +183,8 @@ export function saveProviderConfig(id, { baseUrl, keys, auths, allowedModels, mo
   if (!cleanUrl && !cleanKeys.length && !finalAllowed.length && !finalAuths.length && !finalModelsPath && !finalChatPath) delete configs[id];
   else {
     configs[id] = { baseUrl: cleanUrl, keys: cleanKeys };
+    // 同 saveProviderAllowedModels：起手不带 allowAnyModels 就会静默丢用户的「允许任意」设置（cline token 轮换每走一次这里就丢一次）
+    if (typeof cur.allowAnyModels === "boolean") configs[id].allowAnyModels = cur.allowAnyModels;
     if (finalAuths.length) configs[id].auths = finalAuths;
     if (finalAllowed.length) configs[id].allowedModels = finalAllowed;
     if (finalModelsPath) configs[id].modelsPath = finalModelsPath;