mslxdff 0.1.150 → 0.1.152

package/package.json

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

package/src/chat-pipeline/serial-trial.js

@@ -10,6 +10,20 @@ import { handleBroadbandRelay } from "../routes/chat/broadband-handler.js";
 import { handleViaRoute } from "../routes/chat/via-route-handler.js";
 import { handleExhaustedLocal, handleExhaustedAll } from "../routes/chat/exhausted-handler.js";
 import { shouldUseGroupForModel, isHardLocalOnly, isKeyProviderDirectOnly } from "../state/schemas/use-group.js";
+import { isEmptyTurnError } from "../routes/chat/relay-pipeline.js";
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// 空转重试档位（每次请求读取 env，单测可覆盖）：默认同模型最多重试 2 次、间隔 1s；
+// MSLXDFF_EMPTY_TURN_RETRIES=0 关闭（回旧行为：空转直接换候选/终结）。
+function emptyRetryCfg() {
+  const r = Number(process.env.MSLXDFF_EMPTY_TURN_RETRIES);
+  const d = Number(process.env.MSLXDFF_EMPTY_TURN_RETRY_DELAY_MS);
+  return {
+    max: Number.isInteger(r) && r >= 0 ? r : 2,
+    delayMs: Number.isFinite(d) && d >= 0 ? d : 1000,
+  };
+}
 
 function groupSkipReason(model) {
   if (isHardLocalOnly(model)) return "provider local-only（禁组员，仅本机直连）";
@@ -54,7 +68,7 @@ export async function runSerialTrial(ctx, deps = {}) {
   }
 
   let lastErr = viaRouteLastErr;
-  for (let idx = 0; idx < order.length; idx++) {
+  candidate: for (let idx = 0; idx < order.length; idx++) {
     const model = order[idx];
     handlerCtx.model = model;
     handlerCtx.orderLen = order.length;
@@ -72,82 +86,99 @@ export async function runSerialTrial(ctx, deps = {}) {
       for (const e of ur.errors) evt("plugin-hook-error", { reqId, hook: "upstream:request", plugin: e.plugin, error: e.error });
       if (ur.changed && ur.value?.payload && typeof ur.value.payload === "object") { forwarded = ur.value.payload; evt("plugin-hook", { reqId, hook: "upstream:request", applied: true, model, rewrittenModel: forwarded.model ?? null }); }
     }
-    const tUp = performance.now();
-    evt("upstream-try", { reqId, model, attempt: idx + 1 });
-    try {
-      const chatOpts = {};
-      if (Object.keys(shareKeys).length) chatOpts.shareKeys = shareKeys;
-      if (workbuddyUid) chatOpts.workbuddyUid = workbuddyUid;
-      if (handlerCtx?.sessionId) chatOpts.sessionId = handlerCtx.sessionId;
-      upRes = await upstream.chat(forwarded, Object.keys(chatOpts).length ? chatOpts : undefined);
-      evt("upstream-done", { reqId, model, ok: !(upRes instanceof Error) && upRes.status < 400, status: upRes instanceof Error ? null : upRes.status, timing: upRes._t ?? null, error: null });
-    } catch (err) {
-      if (auto) await auto.recordError(model, { message: errMsg(err) });
-      lastErr = { model, upstream: null, status: 502, message: errMsg(err) };
-      logError(model, 502, errMsg(err));
-      evt("upstream-error", { reqId, model, status: 502, message: errMsg(err), timing: err._t ?? { attempts: [], waitMs: 0, totalMs: Math.round(performance.now() - tUp) } });
-    }
-    if (plugins?.length) {
-      runHook(plugins, "upstream:response", {
-        reqId, requested, model,
-        status: upRes instanceof Error ? null : upRes instanceof Object ? (upRes.status ?? null) : null,
-        ok: !(upRes instanceof Error) && upRes ? upRes.status < 400 : false,
-        error: upRes instanceof Error ? errMsg(upRes) : null,
-        timing: upRes?._t ?? null,
-      }).catch(() => {});
-    }
-    mark(`up-${model}`);
-    if (upRes && upRes.status >= 400) {
-      const isAllowlistBlock = upRes.status === 403 && (upRes.headers?.get?.("x-mslxdff-allowlist") === "1");
-      if (isAllowlistBlock) {
-        let bodyText = null; try { bodyText = await upRes.clone().text(); } catch {}
-        let errBody = { error: `model not allowed for provider` };
-        try { errBody = bodyText ? JSON.parse(bodyText) : errBody; } catch { errBody = { error: bodyText || "model not allowed" }; }
-        if (useAuto) {
+    const chatOpts = {};
+    if (Object.keys(shareKeys).length) chatOpts.shareKeys = shareKeys;
+    if (workbuddyUid) chatOpts.workbuddyUid = workbuddyUid;
+    if (handlerCtx?.sessionId) chatOpts.sessionId = handlerCtx.sessionId;
+    const chatOptsArg = Object.keys(chatOpts).length ? chatOpts : undefined;
+    // 空转 200（模型无输出）同模型暂停重试：默认 2 次、间隔 1s；仅 EMPTY_MODEL_RESPONSE，
+    // 429/403/500 与 fetch 异常走原有切号/failover（防烧额度）。MSLXDFF_EMPTY_TURN_RETRIES=0 关闭。
+    const emptyCfg = emptyRetryCfg();
+    let emptyRetried = 0;
+    for (;;) {
+      const tUp = performance.now();
+      evt("upstream-try", { reqId, model, attempt: idx + 1, emptyRetry: emptyRetried });
+      try {
+        upRes = await upstream.chat(forwarded, chatOptsArg);
+        evt("upstream-done", { reqId, model, ok: !(upRes instanceof Error) && upRes.status < 400, status: upRes instanceof Error ? null : upRes.status, timing: upRes._t ?? null, error: null });
+      } catch (err) {
+        if (auto) await auto.recordError(model, { message: errMsg(err) });
+        lastErr = { model, upstream: null, status: 502, message: errMsg(err) };
+        logError(model, 502, errMsg(err));
+        evt("upstream-error", { reqId, model, status: 502, message: errMsg(err), timing: err._t ?? { attempts: [], waitMs: 0, totalMs: Math.round(performance.now() - tUp) } });
+        upRes = null;
+      }
+      if (plugins?.length) {
+        runHook(plugins, "upstream:response", {
+          reqId, requested, model,
+          status: upRes instanceof Error ? null : upRes instanceof Object ? (upRes.status ?? null) : null,
+          ok: !(upRes instanceof Error) && upRes ? upRes.status < 400 : false,
+          error: upRes instanceof Error ? errMsg(upRes) : null,
+          timing: upRes?._t ?? null,
+        }).catch(() => {});
+      }
+      mark(`up-${model}`);
+      if (upRes && upRes.status >= 400) {
+        const isAllowlistBlock = upRes.status === 403 && (upRes.headers?.get?.("x-mslxdff-allowlist") === "1");
+        if (isAllowlistBlock) {
+          let bodyText = null; try { bodyText = await upRes.clone().text(); } catch {}
+          let errBody = { error: `model not allowed for provider` };
+          try { errBody = bodyText ? JSON.parse(bodyText) : errBody; } catch { errBody = { error: bodyText || "model not allowed" }; }
+          if (useAuto) {
+            logError(model, 403, errBody.error || "model not allowed");
+            evt("upstream-error", { reqId, model, status: 403, message: errBody.error, timing: upRes._t ?? null, allowlist: true, skipped: true });
+            lastErr = { model, upstream: upRes, status: 403, message: errBody.error || "model not allowed" };
+            if (canFallback && idx < order.length - 1) { evt("fallback", { reqId, from: model, to: order[idx + 1] ?? null, reason: `allowlist skip ${errBody.error || "blocked"}` }); continue candidate; }
+            return json(res, 403, errBody);
+          }
           logError(model, 403, errBody.error || "model not allowed");
-          evt("upstream-error", { reqId, model, status: 403, message: errBody.error, timing: upRes._t ?? null, allowlist: true, skipped: true });
-          lastErr = { model, upstream: upRes, status: 403, message: errBody.error || "model not allowed" };
-          if (canFallback && idx < order.length - 1) { evt("fallback", { reqId, from: model, to: order[idx + 1] ?? null, reason: `allowlist skip ${errBody.error || "blocked"}` }); continue; }
+          evt("upstream-error", { reqId, model, status: 403, message: errBody.error, timing: upRes._t ?? null, allowlist: true });
           return json(res, 403, errBody);
         }
-        logError(model, 403, errBody.error || "model not allowed");
-        evt("upstream-error", { reqId, model, status: 403, message: errBody.error, timing: upRes._t ?? null, allowlist: true });
-        return json(res, 403, errBody);
-      }
-      if (auto) await auto.recordError(model, { status: upRes.status });
-      // 读失败响应体（clone 不影响后续 relay 转发原响应；1s 上限防流式错误体拖慢）
-      let upBody = "";
-      try {
-        upBody = String(await Promise.race([
-          upRes.clone().text(),
-          new Promise((r) => { const t = setTimeout(() => r(""), 1000); t.unref?.(); }),
-        ])).replace(/\s+/g, " ").slice(0, 400);
-      } catch {}
-      const upMsg = upBody || `upstream ${upRes.status}`;
-      lastErr = { model, upstream: upRes, status: upRes.status, message: upMsg };
-      logError(model, upRes.status, `upstream ${upRes.status}${upBody ? ` body=${upBody.slice(0, 300)}` : ""}`);
-      evt("upstream-error", { reqId, model, status: upRes.status, message: upMsg.slice(0, 300), timing: upRes._t ?? null });
-      upRes = null;
-    }
-    if (upRes) {
-      const isStream = Boolean(body.stream);
-      const d = hedgeDelayMs();
-      const hasPeers = Boolean(peers) && peers.ordered().length > 0;
-      const canUseGroup = shouldUseGroupForModel(model);
-      const doHedge = canUseGroup && shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers, model }) && upRes.status === 200 && upRes.body;
-      if (doHedge) {
-        const hr = await hedge({ upRes, model, body, order, idx, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, logError, mark, perf0, stages, startedAt, plugins, res, hedgeDelayMs: d });
-        if (hr.handled) return { done: true };
-        if (hr.lastErr) lastErr = hr.lastErr;
-        if (hr.upRes === null) upRes = null;
-        else if (hr.upRes) upRes = hr.upRes;
+        if (auto) await auto.recordError(model, { status: upRes.status });
+        // 读失败响应体（clone 不影响后续 relay 转发原响应；1s 上限防流式错误体拖慢）
+        let upBody = "";
+        try {
+          upBody = String(await Promise.race([
+            upRes.clone().text(),
+            new Promise((r) => { const t = setTimeout(() => r(""), 1000); t.unref?.(); }),
+          ])).replace(/\s+/g, " ").slice(0, 400);
+        } catch {}
+        const upMsg = upBody || `upstream ${upRes.status}`;
+        lastErr = { model, upstream: upRes, status: upRes.status, message: upMsg };
+        logError(model, upRes.status, `upstream ${upRes.status}${upBody ? ` body=${upBody.slice(0, 300)}` : ""}`);
+        evt("upstream-error", { reqId, model, status: upRes.status, message: upMsg.slice(0, 300), timing: upRes._t ?? null });
+        upRes = null;
+        break;
       }
       if (upRes) {
-        const lr = await localRelay({ upRes, model, body, order, idx, lastErr, requested, useAuto, lockModel, auto, handlerCtx, evt, logCall, logError, mark, perf0, stages, startedAt, plugins, res });
-        if (lr.handled) return { done: true };
-        if (lr.lastErr) { lastErr = lr.lastErr; continue; }
-        return { done: true };
+        const isStream = Boolean(body.stream);
+        const d = hedgeDelayMs();
+        const hasPeers = Boolean(peers) && peers.ordered().length > 0;
+        const canUseGroup = shouldUseGroupForModel(model);
+        const doHedge = canUseGroup && shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers, model }) && upRes.status === 200 && upRes.body;
+        if (doHedge) {
+          const hr = await hedge({ upRes, model, body, order, idx, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, logError, mark, perf0, stages, startedAt, plugins, res, hedgeDelayMs: d });
+          if (hr.handled) return { done: true };
+          if (hr.lastErr) lastErr = hr.lastErr;
+          if (hr.upRes === null) upRes = null;
+          else if (hr.upRes) upRes = hr.upRes;
+        }
+        if (upRes) {
+          const lr = await localRelay({ upRes, model, body, order, idx, lastErr, requested, useAuto, lockModel, auto, handlerCtx, evt, logCall, logError, mark, perf0, stages, startedAt, plugins, res });
+          if (lr.handled) return { done: true };
+          if (lr.lastErr && isEmptyTurnError(lr.lastErr) && emptyRetried < emptyCfg.max) {
+            emptyRetried++;
+            evt("empty-turn-retry", { reqId, model, retry: emptyRetried, max: emptyCfg.max, delayMs: emptyCfg.delayMs });
+            await sleep(emptyCfg.delayMs);
+            continue;
+          }
+          if (lr.lastErr) { lastErr = lr.lastErr; continue candidate; }
+          return { done: true };
+        }
+        break;
       }
+      break;
     }
     if (canForwardPeers) {
       if (!shouldUseGroupForModel(model)) {

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/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/chat.js

@@ -256,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;

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

@@ -1,15 +1,29 @@
-// Cline 账号 × 模型额度周期统计。
-// 目标：记录“额度恢复后到下一次限流”之间正常响应累计的 output/completion tokens。
+// 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 } from "../../logs.js";
-import { appendEvent } from "../../logs.js";
+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")}`;
 }
@@ -105,6 +119,7 @@ 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();
@@ -116,6 +131,7 @@ function stateFor(accountId, model, now) {
   states.set(k, s);
   return s;
 }
+
 // 在消费终点直接记账（比包装 Response 可靠：streamToNonStream 已解析出 usage/正文，网关透传已有累积 bytes）。
 export function usageFromData(data) {
   const exact = exactOutputTokens(data?.usage);
@@ -127,15 +143,18 @@ export function usageFromData(data) {
 }
 
 
-export async function recordOutput({ accountId, model, tokens, estimated = false } = {}) {
-  const n = Number(tokens);
+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,
+    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,
   };
@@ -144,6 +163,7 @@ export async function recordOutput({ accountId, model, tokens, estimated = false
   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();
@@ -151,7 +171,7 @@ export async function recordLimit({ accountId, model, reason = "daily_limit", st
   const s = stateFor(accountId, model, now);
   if (s.limitedUntil && s.limitedUntil > now) return null;
   const row = {
-    type: "limit", at: now, accountId: accountId || "unknown", model,
+    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,
@@ -168,3 +188,87 @@ export async function recordLimit({ accountId, model, reason = "daily_limit", st
   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/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）
@@ -11,6 +12,11 @@ export const LAST_CANDIDATE_TIMEOUT_MS = (() => {
   return Number.isInteger(n) && n >= 0 ? n : 120_000;
 })();
 
+/** 空转 200 判定（serial-trial 同模型重试用）：与 execute 内 _emptyTurn 产生的 lastErr 同源 */
+export function isEmptyTurnError(err) {
+  return Number(err?.status) === 502 && String(err?.message || "").startsWith("EMPTY_MODEL_RESPONSE");
+}
+
 /**
  * RelayPipeline 深模块
  * 把 5 个 handler 各自的 fallback→relay→scoring→事件 6段流水收敛为单一真相。
@@ -216,6 +222,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/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;