mslxdff 0.1.232 → 0.1.233

package/package.json

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

package/src/auto.js

@@ -176,13 +176,21 @@ export function createAutoSelector({
 
   async function candidatesFor(requested) {
     if (!requested) return candidates();
+    // 分段计时取证（2026-10-22：真机 candidatesFor 烧 20-26s，源码只 await loadList 与 persistPicks
+    // 两口——不测还是猜。>500ms 才留痕，正常毫秒级零噪音）。
+    const tL = Date.now();
     const list = await loadList();
+    const loadMs = Date.now() - tL;
     // 显式指定某模型 = 认可它，自动加入勾选集（仅当它是真实上游 free 模型时，避免垃圾 id 污染）
     const picks = loadPicks();
+    const tP = Date.now();
     if (list.includes(requested) && !picks.includes(requested) && persistPicks) {
       await persistPicks([...picks, requested]);
     }
+    const persistMs = Date.now() - tP;
+    if (loadMs > 500 || persistMs > 500) console.log(`[auto-slow] candidatesFor model=${requested} loadList=${loadMs}ms persistPicks=${persistMs}ms listSize=${list.length}`);
     const all = list.includes(requested) ? list : [requested, ...list];
+    const tR = Date.now();
     const others = rankModels(all.filter((id) => id !== requested), lastErrorAt, {
       now: now(),
       cooldownMs,
@@ -190,6 +198,8 @@ export function createAutoSelector({
       latencies,
       preferred: getPreferredModel({ file: file ?? undefined }),
     });
+    const rankMs = Date.now() - tR;
+    if (rankMs > 500) console.log(`[auto-slow] candidatesFor.rank model=${requested} rank=${rankMs}ms`);
     // 显式指定模型：严格优先，永不因冷却被挤到最后（原设计：A deepseek 失败 → B/D deepseek 并发 → 都失败才 fallback）
     // 冷却仅影响 auto 的择优，不影响指定模型的“很难被更改”语义
     return [requested, ...others];

package/src/chat-pipeline/index.js

@@ -94,8 +94,18 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
       // 指定模型 = 死锁单模型：额度耗尽只换组员/组长（同模型换机器），**绝不换模型**。
       // candidatesFor 的持久化副作用（把显式指定的模型加入勾选集，供日后 auto 用）必须保留——
       // 见 auto.js:180「显式指定某模型 = 认可它，自动加入勾选集」，历史上删它会丢勾选记录。
+      // 但**不 await**（2026-10-22 日志定罪：loadList 拉全量模型目录烧 24s，写盘 persistPicks 仅 0ms）。
+      // 此路径 order 已定死 [requested]，candidatesFor 返回值根本不被消费，只为触发"加入勾选集"副作用——
+      // 为副作用让主请求干等 24s 是自伤。改后台 fire-and-forget：勾选照样持久化，主请求零阻塞。
       if (auto && requested) {
-        try { await auto.candidatesFor(requested); } catch {}
+        const tCf = performance.now();
+        Promise.resolve()
+          .then(() => auto.candidatesFor(requested))
+          .catch(() => {})
+          .finally(() => {
+            const ms = Math.round(performance.now() - tCf);
+            if (ms > 5000) console.log(`[pipeline-bg] candidatesFor 后台耗时 model=${requested} ms=${ms}（未阻塞主请求）`);
+          });
       }
       order = [requested];
     }

package/src/model-trace.js

@@ -84,6 +84,8 @@ const DECISION_FIELDS = [
   "latencyMs", "ttfMs", "hedged", "hops", "hasShare", "elapsedMs", "threshold",
   "stallHits", "maxGapMs", "interrupted", "providers", "via",
   "retry", "step", "max", "delayMs", "upstream", "account", "pick", "cooled", "queued", "nudged", "retries", "waitedMs", "raiseFrom", "raiseTo",
+  // qoder 判决定点日志（2026-10-22）：login/额度/排队判决各走各的路径，没有这三项，403 盲飞无从分辨
+  "login", "nocapacity", "retryAfter",
   "heldOpen", "terminalForm", "requestWaitedMs", "budgetMs", "budgetOut",
   // 终局判决（ADR-0058）：取证时第一眼要看的三件——判的哪种、命中哪条判据、是否因此没问组员
   "kind", "marker", "peersSkipped",
@@ -103,8 +105,10 @@ function decisionKv(data = {}) {
   return out.join(" ");
 }
 
-// provider 回显头 → 日志字段（谁上的 / 打哪个站 / 为什么选它 / 是否被冷却 / 是否被判排队）：
+// provider 回显头 → 日志字段（谁上的 / 打哪个站 / 为什么选它 / 是否被冷却 / 是否被判排队 / 判决命中哪种）：
 // 单一来源，防各处重复写法漂移；取不到时返回空对象（其它供应商零变化）。
+// login/nocapacity/retryAfter（2026-10-22 补）：qoder 判决链曾全程盲飞——403 直出日志里只有状态码，
+// 看不出内部是 login 误伤、queue 漏检还是根本没命中，三轮排查全靠猜（用户实证批评：没多打日志）。
 export function upstreamEcho(res) {
   const h = res?.headers;
   if (typeof h?.get !== "function") return {};
@@ -115,6 +119,10 @@ export function upstreamEcho(res) {
     pick: pick("x-mslxdff-qoder-account"),
     cooled: pick("x-mslxdff-qoder-cooldown"),
     queued: pick("x-mslxdff-qoder-queued"),
+    login: pick("x-mslxdff-qoder-login"),
+    nocapacity: pick("x-mslxdff-qoder-nocapacity"),
+    verdict: pick("x-mslxdff-qoder-verdict"),
+    qoderRetry: pick("x-mslxdff-qoder-retry-after"),
   };
 }
 
@@ -128,7 +136,7 @@ export function formatModelTrace({ type, reqId, model, data = {}, request = null
   else if (type === "alias") detail = `rawModel=${data.rawModel || "-"} requested=${data.requested || model || "-"}`;
   else if (type === "exhausted-local" || type === "exhausted-all") detail = `last=${data.lastModel || model || "-"} status=${data.lastStatus ?? "-"} order=${(data.order || []).join(" | ")}`;
   else if (type === "upstream-try") detail = `target=${data.model || model || "-"} attempt=${data.attempt ?? "-"} payload=${kv(data.payload || {})}`;
-  else if (type === "upstream-done" || type === "upstream-error") detail = `upstream status=${data.status ?? "-"} timing=${data.timing?.totalMs ?? "-"}ms${data.upstream ? ` via=${data.upstream}` : ""}${data.account ? ` account=${data.account}` : ""}${data.pick ? ` pick=${data.pick}` : ""}${data.cooled ? ` cooled=${data.cooled}` : ""}${data.queued ? ` queued=1` : ""} ${safeText(data.message || data.error || "")}`;
+  else if (type === "upstream-done" || type === "upstream-error") detail = `upstream status=${data.status ?? "-"} timing=${data.timing?.totalMs ?? "-"}ms${data.upstream ? ` via=${data.upstream}` : ""}${data.account ? ` account=${data.account}` : ""}${data.pick ? ` pick=${data.pick}` : ""}${data.cooled ? ` cooled=${data.cooled}` : ""}${data.queued ? ` queued=1` : ""}${data.login ? ` login=1` : ""}${data.nocapacity ? ` nocapacity=1` : ""}${data.verdict ? ` verdict=${data.verdict}` : ""}${data.qoderRetry ? ` retry=${data.qoderRetry}s` : ""} ${safeText(data.message || data.error || "")}`;
   else if (type === "empty-turn-retry") detail = `空转重试：retry ${data.retry ?? "-"}/${data.max ?? "-"}${data.step != null ? ` step=${data.step}` : ""} delay=${data.delayMs ?? "-"}ms${data.waitedMs ? ` waited=${data.waitedMs}ms` : ""}${data.requestWaitedMs != null ? ` 请求级累计=${data.requestWaitedMs}ms/预算${data.budgetMs ?? "-"}ms` : ""}${data.raiseTo ? ` max_tokens ${data.raiseFrom}→${data.raiseTo}` : ""}${data.upstream ? ` after=${data.upstream}` : ""}${data.account ? ` account=${data.account}` : ""}${data.pick ? ` pick=${data.pick}` : ""}${data.nudged ? ` nudged=1` : ""} reason=empty turn${data.reason ? ` :: ${safeText(data.reason, 120)}` : ""}`;
   else if (type === "empty-turn-recovered") detail = `空转重试成功：第 ${data.retries ?? "-"}/${data.max ?? "-"} 次重拉拿到真实输出，本轮共白等 ${data.waitedMs ?? "-"}ms${data.upstream ? ` via=${data.upstream}` : ""}${data.account ? ` account=${data.account}` : ""}${data.pick ? ` pick=${data.pick}` : ""}`;
   else if (type === "empty-turn-exhausted") detail = `空转重试已用尽：重试 ${data.retries ?? 0}/${data.max ?? "-"} 次仍零输出（累计等待 ${data.waitedMs ?? 0}ms${data.budgetOut ? `，请求级等待预算 ${data.budgetMs ?? "-"}ms 用尽` : ""}），交回换候选${data.heldOpen ? "（响应仍开着，换过去的正文还能送达）" : "（响应已封口，重拉只为省额度）"}${data.upstream ? ` after=${data.upstream}` : ""}${data.account ? ` account=${data.account}` : ""}${data.pick ? ` pick=${data.pick}` : ""}${data.reason ? ` :: ${safeText(data.reason, 120)}` : ""}`;

package/src/models.js

@@ -1,7 +1,7 @@
 const KNOWN_FREE_OPENCODE_MODELS = ["big-pickle"];
 const CACHE_TTL_MS = 2 * 60 * 60 * 1000;
 const DEFAULT_REFRESH_MS = 2 * 60 * 60 * 1000;
-import { mkdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, writeFileSync, readFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { compatFetch } from "./compat.js";
 
@@ -28,7 +28,21 @@ export function createModelsService({ baseUrl, headers, ttlMs = CACHE_TTL_MS, re
   if (providers?.length) {
     let aggregate = null;
     let aggFetchedAt = 0;
+    let aggInflight = null;
+    let aggTimer = null;
     let lastAllowlistKey = "";
+    // 冷启动预热：读上一次 persist 的磁盘目录当首值（真机取证：全目录拉取烧 20-26s，
+    // 首个 candidatesFor 冷等全程）。aggFetchedAt 用磁盘记录的真实时间；get 对
+    // 「有旧值」的情形一律 stale-while-revalidate（立即返回 + 后台刷），主请求零等待。
+    if (cacheFile) {
+      try {
+        const raw = JSON.parse(readFileSync(cacheFile, "utf8"));
+        if (Array.isArray(raw?.data)) {
+          aggregate = { object: "list", data: raw.data };
+          aggFetchedAt = Number(raw.cachedAt) || 0;
+        }
+      } catch { /* 无缓存/坏档：按冷处理 */ }
+    }
     async function currentAllowlistKey() {
       try {
         const { loadProviderAllowedModels, loadProviderAllowAnyModels } = await import("./state.js");
@@ -42,6 +56,15 @@ export function createModelsService({ baseUrl, headers, ttlMs = CACHE_TTL_MS, re
     }
     async function aggLoad() {
       const all = [];
+      // 单供应商拉取失败时沿用旧缓存里它的段（取证教训：此前失败=整段消失，
+      // 且 2h TTL 内无人再拉（startAutoRefresh 曾是空函数），目录会长期缺一大块）。
+      const prevByProvider = new Map();
+      for (const m of aggregate?.data || []) {
+        const pid = typeof m?.id === "string" ? m.id.split("/")[0] : "";
+        if (!pid) continue;
+        if (!prevByProvider.has(pid)) prevByProvider.set(pid, []);
+        prevByProvider.get(pid).push(m);
+      }
       for (const p of providers) {
         try {
           let list = (await p.listModels?.()) ?? [];
@@ -66,7 +89,9 @@ export function createModelsService({ baseUrl, headers, ttlMs = CACHE_TTL_MS, re
           } catch {}
           all.push(...list);
         } catch {
-          // 单供应商取数失败不拖垮整体
+          // 单供应商取数失败不拖垮整体：有旧数据则保留旧数据
+          const prev = prevByProvider.get(p.id);
+          if (prev?.length) all.push(...prev);
         }
       }
       aggregate = { object: "list", data: all };
@@ -76,42 +101,84 @@ export function createModelsService({ baseUrl, headers, ttlMs = CACHE_TTL_MS, re
       if (cacheFile) persistModels(aggregate, cacheFile);
       return aggregate;
     }
+    // 对当前 aggregate（含磁盘 stale 值）做白名单二次过滤后返回；过滤失败回原值。
+    async function aggSnapshot() {
+      try {
+        const { loadProviderAllowedModels, loadProviderAllowAnyModels } = await import("./state.js");
+        const { splitModelId } = await import("./providers/model-id.js");
+        const filteredData = aggregate.data.filter((m) => {
+          if (!m || !m.id) return false;
+          const { provider, raw } = splitModelId(m.id, providers.map((x) => x.id));
+          const allowed = loadProviderAllowedModels(provider);
+          const allowAny = loadProviderAllowAnyModels(provider);
+          if (!allowed.length && !allowAny) return false;
+          if (!allowed.length) return true;
+          return allowed.includes(String(raw || "").trim());
+        });
+        if (filteredData.length !== aggregate.data.length) return { ...aggregate, data: filteredData };
+        return aggregate;
+      } catch {
+        return aggregate;
+      }
+    }
+    function aggRefreshInBackground() {
+      void aggLoadShared().then(() => { aggFetchedAt = Date.now(); }).catch(() => {});
+    }
     async function get() {
       const now = Date.now();
-      if (aggregate && now - aggFetchedAt < ttlMs) {
+      const fresh = aggregate && now - aggFetchedAt < ttlMs;
+      if (fresh) {
         // 热更新白名单：allowlist 变化时，即使命中 TTL 也要重载（否则 clear 后仍返回旧过滤结果）
         try {
           const curKey = await currentAllowlistKey();
           if (curKey !== lastAllowlistKey) {
-            const out = await aggLoad();
+            const out = await aggLoadShared();
             aggFetchedAt = Date.now();
             return out;
           }
         } catch {}
-        // 否则尝试在缓存上二次过滤（处理 allowlist 从空变非空等未触发重载的场景）
-        try {
-          const { loadProviderAllowedModels, loadProviderAllowAnyModels } = await import("./state.js");
-          const { splitModelId } = await import("./providers/model-id.js");
-          const filteredData = aggregate.data.filter((m) => {
-            if (!m || !m.id) return false;
-            const { provider, raw } = splitModelId(m.id, providers.map((x) => x.id));
-            const allowed = loadProviderAllowedModels(provider);
-            const allowAny = loadProviderAllowAnyModels(provider);
-            if (!allowed.length && !allowAny) return false;
-            if (!allowed.length) return true;
-            return allowed.includes(String(raw || "").trim());
-          });
-          if (filteredData.length !== aggregate.data.length) return { ...aggregate, data: filteredData };
-          return aggregate;
-        } catch {
-          return aggregate;
-        }
+        return aggSnapshot();
       }
-      const out = await aggLoad();
+      // 有旧值（含冷启动磁盘 stale）：立即返回 + 后台刷新，主请求零等待。
+      // 取证教训：全目录拉取 20-26s，此前冷路径同步阻塞整个首请求。
+      if (aggregate) {
+        aggRefreshInBackground();
+        return aggSnapshot();
+      }
+      // 完全无值（首次冷跑）：只能等这一趟。
+      const out = await aggLoadShared();
       aggFetchedAt = Date.now();
       return out;
     }
-    return { get, startAutoRefresh: () => {}, stopAutoRefresh: () => {} };
+    // 并发去重：aggLoad 要遍历全部供应商拉目录（真机实测 20-26s），
+    // 无去重时赛马/后台任务并发触发就各烧各的（真机日志实证同窗口重复 3 次）。
+    function aggLoadShared() {
+      if (aggInflight) return aggInflight;
+      aggInflight = (async () => {
+        try {
+          return await aggLoad();
+        } catch (e) {
+          // 失败保旧：有旧聚合就回退旧值，绝不让半次刷新把目录清空
+          if (aggregate) return aggregate;
+          throw e;
+        } finally {
+          aggInflight = null;
+        }
+      })();
+      return aggInflight;
+    }
+    function aggStartAutoRefresh(intervalMs = refreshMs) {
+      if (aggTimer) return aggStopAutoRefresh;
+      aggTimer = setInterval(() => {
+        void aggLoadShared().then(() => { aggFetchedAt = Date.now(); }).catch(() => {});
+      }, intervalMs);
+      aggTimer.unref?.();
+      return aggStopAutoRefresh;
+    }
+    function aggStopAutoRefresh() {
+      if (aggTimer) { clearInterval(aggTimer); aggTimer = null; }
+    }
+    return { get, startAutoRefresh: aggStartAutoRefresh, stopAutoRefresh: aggStopAutoRefresh };
   }
   let cache = null;
   let fetchedAt = 0;

package/src/providers/qoder/account-store.js

@@ -96,6 +96,24 @@ export async function saveQoderAccount({ uid, deviceToken, refreshToken = "", re
   return { file: fp, accounts: st.keys.length, updated: st.updated > 0 };
 }
 
+// 刷新成功后按 uid 原位更新令牌对（deviceToken 时效短，105 过期即刷）。
+// auth 文档保留原 region/name；state 行按 uid 覆盖（persistAccounts 命中既有 uid 行即替换）。
+export async function updateQoderAccountTokens({ uid, deviceToken, refreshToken, file } = {}) {
+  if (!uid || !deviceToken) throw new Error("updateQoderAccountTokens: 缺少 uid/deviceToken");
+  const docs = listAccountDocs();
+  const found = docs.find((d) => String(d.uid) === String(uid));
+  const a = found?.doc?.auth || {};
+  const acc = found?.doc?.account || {};
+  writeAccountFile({
+    uid, deviceToken, refreshToken,
+    region: a.region || "global",
+    name: acc.name || "", email: acc.email || "", userType: acc.userType || "personal_standard",
+    organizationId: acc.organizationId || "", organizationName: acc.organizationName || "",
+  });
+  await persistAccounts([{ uid, deviceToken, refreshToken, region: a.region || "global", name: acc.name || "", domain: "qoder.com" }], file);
+  return { updated: Boolean(found) };
+}
+
 // 重建 provider 的行级 auth：由 keys[i] blob + auths[i] 还原 deviceToken。
 export function accountFromBlob(blob) {
   try {

package/src/providers/qoder/chat.js

@@ -2,12 +2,12 @@
 // false → 聚合回 JSON。装配走 request.js，帧格式走 sse.js，两条管线共享。
 import { compatFetch, timeoutSignal } from "../../compat.js";
 import { mapModel } from "./payload.js";
-import { effortFromBody, isReasoningEnabled } from "../../thinking-effort.js";
+import { effortFromBody, effortLevelFromBody, isReasoningEnabled } from "../../thinking-effort.js";
 import { normalizeRegion } from "./constants.js";
 import { buildUpstreamRequest } from "./request.js";
 import { reshapeQoderStream } from "./stream.js";
 import { aggregateQoderStream, toCompletionJson } from "./aggregate.js";
-import { errorStatus, extractDelta } from "./sse.js";
+import { errorStatus, extractDelta, findQuotaSignal, findLoginSignal, findQueueSignal, retryAfterFrom } from "./sse.js";
 
 function hostOf(url) {
   try { return new URL(String(url)).host; } catch { return "-"; }
@@ -25,21 +25,39 @@ function mapUpstreamError(status, detail) {
 // 又不会把首字节延迟拖到不可控。超窗未得判决即放弃（退化为无冷却的流内 error，见 SPEC 已知上限）。
 const PEEK_MAX_FRAMES = 8;
 
+// 判决旗标（统一出口）：登录过期/额度/排队（含无容量子型）+ retryAfter 秒数。
+// 非 200 直出与 200 信封裹身两条路径共用同一解析口，防两处漂移。
+function verdictFlagsFrom(objOrText) {
+  const v = { login: false, quota: false, queued: false, noCapacity: false, retryAfter: 0 };
+  if (findLoginSignal(objOrText)) v.login = true;
+  else if (findQuotaSignal(objOrText)) v.quota = true;
+  else {
+    const q = findQueueSignal(objOrText);
+    if (q) { v.queued = true; v.noCapacity = q.noCapacity === true; }
+  }
+  const ra = retryAfterFrom(typeof objOrText === "string" ? objOrText : JSON.stringify(objOrText ?? ""));
+  if (ra.retryAfter) v.retryAfter = ra.retryAfter;
+  return v;
+}
+
 // 预读上游首帧只为取「流内判决」：qoder 把限流/鉴权判决裹在 HTTP 200 的 SSE 信封里
 //（statusCodeValue:403 + serviceAvailable:false），upRes.status 恒 200，判决只有读完帧才知道。
 // 不预读则状态码永远出不来流式路径 → 门面不冷却该号（ADR-0036 的粘号会把重试继续粘在它上面）。
 // 返回 { res, status, frames }：res 是把预读帧回灌后的等价上游响应，frames 交回灌用。
 // 任何异常都降级为「无判决」（status=0）：排障手段不得变成故障源。
 async function peekEnvelopeVerdict(upRes, cdbg) {
-  if (!upRes?.body) return { res: upRes, status: 0, quota: false, queued: false, frames: [] };
+  if (!upRes?.body) return { res: upRes, status: 0, quota: false, queued: false, noCapacity: false, retryAfter: 0, login: false, frames: [] };
   let reader;
-  try { reader = upRes.body.getReader(); } catch { return { res: upRes, status: 0, quota: false, queued: false, frames: [] }; }
+  try { reader = upRes.body.getReader(); } catch { return { res: upRes, status: 0, quota: false, queued: false, noCapacity: false, retryAfter: 0, login: false, frames: [] }; }
   const dec = new TextDecoder();
   const frames = [];
   let text = "";
   let status = 0;
   let quota = false;
   let queued = false;
+  let noCapacity = false;
+  let retryAfter = 0;
+  let login = false;
   let decided = false;
   try {
     for (let i = 0; i < PEEK_MAX_FRAMES && !decided; i++) {
@@ -53,14 +71,22 @@ async function peekEnvelopeVerdict(upRes, cdbg) {
         const p = line.slice(5).trim();
         if (!p || p === "[DONE]") continue;
         const d = extractDelta(p);
-        if (d.err) { status = Number(d.err.status) || 0; quota = d.err.kind === "quota"; queued = d.err.queued === true; decided = true; break; }
+        if (d.err) {
+          status = Number(d.err.status) || 0;
+          quota = d.err.kind === "quota";
+          queued = d.err.queued === true;
+          noCapacity = d.err.noCapacity === true;
+          retryAfter = Number(d.err.retryAfter) || 0;
+          login = d.err.loginExpired === true;
+          decided = true; break;
+        }
         if (d.content || d.reasoning || d.toolCalls || d.usageIn || d.usageOut) { decided = true; break; }
       }
     }
   } catch (e) {
     cdbg(`[peek-throw] ${String(e?.message || e).slice(0, 160)}`);
   }
-  cdbg(`[peek] frames=${frames.length} verdict=${status || "none(正常流)"} quota=${quota} queued=${queued}`);
+  cdbg(`[peek] frames=${frames.length} verdict=${status || "none(正常流)"} quota=${quota} queued=${queued} noCapacity=${noCapacity} ra=${retryAfter} login=${login}`);
   // 回灌：已读帧先按原样吐出，再接续同一个 reader 的剩余部分
   const body = new ReadableStream({
     start(ctrl) {
@@ -77,7 +103,7 @@ async function peekEnvelopeVerdict(upRes, cdbg) {
       })();
     },
   });
-  return { res: new Response(body, { status: upRes.status, headers: upRes.headers }), status, quota, queued, frames };
+  return { res: new Response(body, { status: upRes.status, headers: upRes.headers }), status, quota, queued, noCapacity, retryAfter, login, frames };
 }
 export function createChatService({ id = "qoder", fetchImpl, timeoutMs, getModelMeta } = {}) {
   if (!fetchImpl) fetchImpl = compatFetch;
@@ -114,6 +140,31 @@ export function createChatService({ id = "qoder", fetchImpl, timeoutMs, getModel
     try { res.headers.set("x-mslxdff-qoder-queued", "1"); } catch {}
     return res;
   };
+  // 无容量旗标：10605 且 queueCount:0 + serviceAvailable:false = 整池共享同一 p3 队列、
+  // 换号救不了，只能等 Retry-After。门面据此**不换号轮询**，带 429+Retry-After 如实透给客户端。
+  const withNoCapacity = (res, retryAfter) => {
+    try {
+      res.headers.set("x-mslxdff-qoder-nocapacity", "1");
+      if (retryAfter) {
+        res.headers.set("x-mslxdff-qoder-retry-after", String(retryAfter));
+        res.headers.set("Retry-After", String(retryAfter)); // 对客户端的标准交代（relay 层原样转发响应头）
+      }
+    } catch {}
+    return res;
+  };
+  // 登录过期标记（内部交接，不落日志）：门面据此走「刷新令牌→原地重发」，不当普通坏号冷却轮询。
+  const withLogin = (res) => {
+    try { res.headers.set("x-mslxdff-qoder-login", "1"); } catch {}
+    return res;
+  };
+  // 判决结果钉头（2026-10-22 用户实证「没多打日志→排查全靠猜」后补）：verdict 取值
+  // login/quota/queue/queue-nocapacity/none，由 model-trace.upstreamEcho 落进模型日志。
+  // 关键在 none 也要显式钉——「压根没命中」与「命中但走别的分支」在 403 盲视图里必须分得开。
+  const verdictName = (v) => (v.login ? "login" : v.quota ? "quota" : v.queued ? (v.noCapacity ? "queue-nocapacity" : "queue") : "none");
+  const withVerdict = (res, v) => {
+    try { res.headers.set("x-mslxdff-qoder-verdict", verdictName(v)); } catch {}
+    return res;
+  };
 
   async function runChat(body, sess, region = "global", pick = "") {
     const stream = body?.stream !== false;
@@ -122,14 +173,20 @@ export function createChatService({ id = "qoder", fetchImpl, timeoutMs, getModel
     const tools = Array.isArray(body?.tools) && body.tools.length ? body.tools : null;
     const messages = Array.isArray(body?.messages) ? body.messages : [];
     const maxTokens = Number(body?.max_tokens) || 0;
-    // is_reasoning 由模型目录供数（index 注入 getModelMeta，只读 peekModels 快照缓存，chat 路径恒 0 上游调用）；
-    // 冷缓存/缺失一律降级 false（= 旧行为，不阻断对话）—— P0：推理标志此前从未出门。
+    // is_reasoning 与能力元数据（窗口/档位）由模型目录一次供数（index 注入 getModelMeta，
+    // 只读 peekModels 快照缓存，chat 路径恒 0 额外上游调用；preheat 负责灌缓存）。
+    // 冷缓存/缺失一律降级：isReasoning=false、无 meta（= 旧行为，不阻断对话）。
+    let meta = null;
     let isReasoning = false;
     try {
-      if (getModelMeta) isReasoning = (await getModelMeta(sess, normalizeRegion(region), mapModel(model)))?.is_reasoning === true;
+      if (getModelMeta) {
+        meta = (await getModelMeta(sess, normalizeRegion(region), mapModel(model))) || null;
+        isReasoning = meta?.is_reasoning === true;
+      }
     } catch {}
     // 客户端显式档位优先于目录推断（grill-decisions Q3）：关断→false、其余非空→true；无档位→沿用目录结论。
     isReasoning = isReasoningEnabled(effortFromBody(body), isReasoning);
+    const effortLevel = effortLevelFromBody(body); // 真档位串（low/medium/high…），透传给装配口对齐模型档位
 
     let upRes; let reqUrl = "";
     const echo = (res) => withEcho(res, reqUrl, region, pick);
@@ -137,7 +194,7 @@ export function createChatService({ id = "qoder", fetchImpl, timeoutMs, getModel
     const cdbg = (...a) => { if (process.env.QODER_DEBUG_STREAM === "1") console.log("[qoder-chat]", ...a); };
     let upMs = 0;
     try {
-      const req = buildUpstreamRequest({ sess, region: normalizeRegion(region), model, messages, tools, maxTokens, isReasoning });
+      const req = buildUpstreamRequest({ sess, region: normalizeRegion(region), model, messages, tools, maxTokens, isReasoning, meta, effort: effortLevel });
       reqUrl = req.url;
       cdbg(`[req] url=${hostOf(req.url)} region=${normalizeRegion(region)} model=${model} msgs=${messages.length} tools=${tools?.length ?? 0} maxTokens=${maxTokens} stream=${stream} bodyBytes=${req.bodyStr?.length ?? 0}`);
       const t0 = Date.now();
@@ -159,7 +216,15 @@ export function createChatService({ id = "qoder", fetchImpl, timeoutMs, getModel
     if (upRes.status !== 200) {
       const detail = await upRes.text().catch(() => "");
       cdbg(`[res-non200] status=${upRes.status} body=${detail.slice(0, 300)}`);
-      const e = mapUpstreamError(upRes.status, detail);
+      // 真 HTTP 403 也可能直出 10605 排队/110 额度/105 登录（不只裹 200 信封）。
+      // 旧版一律 mapUpstreamError(403)→auth→冷却换号，把「整池共享的 p3 无容量」当死号轮询白烧。
+      // 先解析 body 定旗标：无容量 → 不换号、带 Retry-After 如实透；额度/登录 → 交门面对应处理。
+      const vf = verdictFlagsFrom(detail);
+      cdbg(`[verdict] status=${upRes.status} login=${vf.login} quota=${vf.quota} queued=${vf.queued} noCapacity=${vf.noCapacity} ra=${vf.retryAfter} bodyLen=${detail.length} body=${detail.slice(0, 300)}`);
+      const e = vf.login ? { kind: "auth", status: 401, detail }
+        : vf.quota ? { kind: "quota", status: 429, detail }
+        : vf.queued ? { kind: "upstream", status: 429, detail }
+        : mapUpstreamError(upRes.status, detail);
       if (stream) {
         // 首包错误也走流内 error 事件（与旧 reshapeStream catch 语义一致：200 + event:error + DONE）
         const enc = new TextEncoder();
@@ -171,21 +236,36 @@ export function createChatService({ id = "qoder", fetchImpl, timeoutMs, getModel
           },
         });
         // 对外仍是 200（契约不变），真实状态码经回显头交门面决定是否冷却
-        return withUpstreamStatus(echo(new Response(s, { status: 200, headers: { "Content-Type": "text/event-stream" } })), upRes.status);
+        let shaped = withUpstreamStatus(echo(new Response(s, { status: 200, headers: { "Content-Type": "text/event-stream" } })), upRes.status);
+        shaped = withVerdict(shaped, vf);
+        if (vf.quota) shaped = withQuota(shaped);
+        if (vf.login) shaped = withLogin(shaped);
+        if (vf.queued) shaped = vf.noCapacity ? withNoCapacity(shaped, vf.retryAfter) : withQueued(shaped);
+        return shaped;
       }
-      return withUpstreamStatus(echo(errRes(errorStatus(e), e.detail, e.kind)), upRes.status);
+      let out = withUpstreamStatus(echo(errRes(errorStatus(e), e.detail, e.kind)), upRes.status);
+      out = withVerdict(out, vf);
+      if (vf.quota) out = withQuota(out);
+      if (vf.login) out = withLogin(out);
+      if (vf.queued) out = vf.noCapacity ? withNoCapacity(out, vf.retryAfter) : withQueued(out);
+      return out;
     }
     if (stream) {
       // 预读首帧取流内判决（qoder 把 403/429 裹在 200 的信封里），预读帧原样回灌给整形器。
       // 判决状态码经 withUpstreamStatus 出门面 → index.js 据此 ring.onError 冷却该号 →
       // 粘号选择器下次因 isCooling 为真而换号。对外仍恒 200（契约不变）。
       const peek = await peekEnvelopeVerdict(upRes, cdbg);
+      const pvf = { login: peek.login, quota: peek.quota, queued: peek.queued, noCapacity: peek.noCapacity };
       let shaped = echo(reshapeQoderStream(peek.res, { model, chatId, prefetched: peek.frames }));
       // 只在真有判决时挂状态码：正常流不写这个头（index.js 靠它区分"要不要冷却"）
       if (peek.status) shaped = withUpstreamStatus(shaped, peek.status);
+      // verdict 钉头同理只钉有判决的流——正常流不写，避免成功请求日志被 verdict=none 刷屏
+      if (peek.status) shaped = withVerdict(shaped, pvf);
       if (peek.quota) shaped = withQuota(shaped);
-      // 排队旗标（内部交接）：门面据此走队列档冷却并在同一请求内换号，别把排队号送回客户端
-      if (peek.queued) shaped = withQueued(shaped);
+      // 排队旗标（内部交接）：真排队（有人等位）→ 门面换号碰别的号；无容量 → 门面不换号透 Retry-After
+      if (peek.queued) shaped = peek.noCapacity ? withNoCapacity(shaped, peek.retryAfter) : withQueued(shaped);
+      // 登录过期旗标：门面据此刷新令牌原地重发（不冷却换号轮询整池过期号）
+      if (peek.login) shaped = withLogin(shaped);
       return shaped;
     }
     try {
@@ -193,9 +273,18 @@ export function createChatService({ id = "qoder", fetchImpl, timeoutMs, getModel
       const out = toCompletionJson({ model, chatId, ...agg });
       return echo(new Response(JSON.stringify(out), { status: 200, headers: { "Content-Type": "application/json" } }));
     } catch (e) {
-      const out = echo(errRes(errorStatus(e), String(e?.detail || e?.message || e).slice(0, 300), e?.kind || "upstream_error"));
-      const marked = e?.kind === "quota" ? withQuota(out) : out;
-      return e?.queued ? withQueued(marked) : marked;
+      // 聚合出口的判决折态（2026-10-22 真机实锤 req=mvj6u7wj：HTTP 恒 200、403 裹在 SSE 信封
+      // statusCodeValue 里，extractDelta 的 err.status=403 原样 errRes 出去 → nocapacity 头挂了、
+      // 状态却还是 403。无容量档必须与非 200 直出路径同口径折 429，否则门面 break 后
+      // lastRes 透给客户端仍是 403，Retry-After 语义全丢）。
+      const cvf = { login: e?.loginExpired === true, quota: e?.kind === "quota", queued: e?.queued === true, noCapacity: e?.noCapacity === true };
+      const aggStatus = cvf.noCapacity ? 429 : errorStatus(e);
+      let out = echo(errRes(aggStatus, String(e?.detail || e?.message || e).slice(0, 300), e?.kind || "upstream_error"));
+      out = withVerdict(out, cvf);
+      if (cvf.noCapacity && e?.retryAfter) out = withNoCapacity(out, e.retryAfter);
+      let marked = cvf.quota ? withQuota(out) : out;
+      if (cvf.queued && !cvf.noCapacity) marked = withQueued(marked);
+      return cvf.login ? withLogin(marked) : marked;
     }
   }
 

package/src/providers/qoder/checkin.js

@@ -54,18 +54,27 @@ export function dailyCheckinClaim({ deviceToken, region, fetchImpl = compatFetch
   return call(fetchImpl, region, EP_CHECKIN_CLAIM, { method: "POST", deviceToken, body: {}, timeoutMs });
 }
 
-// 余额：/api/v2/quota/usage → userQuota{total,used,remaining,unit} + isQuotaExceeded
+// 余额：/api/v2/quota/usage → 基础池 userQuota + 奖励池 addOnQuota（签到/活动领的额度）。
+// ⚠ 取证教训（2026-10-22）：旧版只读 userQuota，漏了 addOnQuota —— Free 号 userQuota 恒 0/0，
+// 但领过签到奖励的号 addOnQuota.remaining=100 仍有额度，被误报成「已耗尽」。
+// exhausted 以接口综合判断 isQuotaExceeded 为权威（两池都用完才 true），不自行推断。
 export async function fetchQuota({ deviceToken, region, fetchImpl = compatFetch, timeoutMs } = {}) {
   const r = await call(fetchImpl, region, EP_QUOTA, { deviceToken, timeoutMs });
   if (r.status !== 200) return { ok: false, status: r.status, error: r.error || r.text.slice(0, 160) };
-  const q = r.json?.userQuota || {};
+  const num = (v) => Number(v) || 0;
+  const q = r.json?.userQuota;
+  const add = r.json?.addOnQuota;
+  const base = { total: num(q?.total), used: num(q?.used), remaining: num(q?.remaining) };
+  const addOn = add ? { total: num(add.total), used: num(add.used), remaining: num(add.remaining) } : null;
   return {
     ok: true,
-    total: Number(q.total) || 0,
-    used: Number(q.used) || 0,
-    remaining: Number(q.remaining) || 0,
-    unit: String(q.unit || "credits"),
+    total: base.total + (addOn?.total ?? 0),
+    used: base.used + (addOn?.used ?? 0),
+    remaining: base.remaining + (addOn?.remaining ?? 0),
+    unit: String(q?.unit || add?.unit || "credits"),
     exhausted: Boolean(r.json?.isQuotaExceeded),
+    base,
+    addOn,
   };
 }
 
@@ -102,15 +111,19 @@ export async function runCheckin({ deviceToken, region, fetchImpl = compatFetch,
   }
   if (st.status === 401) { r.message = `device token 失效（HTTP 401）：请重新 mslxdff -provider qoder login`; return r; }
 
-  // 干跑：只报状态，不发任何 claim 请求
-  if (probeOnly && st.status === 200 && st.json?.status) {
+  // 取证教训（2026-10-22）：上游 cn 老入口 daily-check-in 已 DISABLED，但字段还在返回。
+  // 旧代码把 DISABLED 当活跃态去 claim，拿到 409 就报「今日已领取」直接 return ——
+  // 永远走不到 campaigns 兜底，天天错过真积分活动（act-20261020-993，每日 10:00 UTC+8 刷新）。
+  // 修法：DISABLED 唯一豁免——不碰老入口直接落 campaigns；其余状态保持原行为（试领，409=已领）。
+  const legacy = st.status === 200 ? String(st.json?.status || "") : "";
+  const legacyActive = st.status === 200 && st.json?.status && legacy !== "DISABLED";
+  if (probeOnly && legacyActive) {
     r.ok = true;
-    r.status = st.json.status === "CLAIMED" ? "already" : "claimable";
-    r.message = `干跑：status=${st.json.status} 每日奖励 ${r.reward}`;
+    r.status = legacy === "CLAIMED" ? "already" : "claimable";
+    r.message = `干跑：status=${legacy} 每日奖励 ${r.reward}`;
     return r;
   }
-  // 主流程：daily-check-in（国内站）
-  if (st.status === 200 && st.json?.status) {
+  if (legacyActive) {
     const claim = await dailyCheckinClaim({ deviceToken, region: reg, fetchImpl, timeoutMs });
     if (claim.status === 409) { r.ok = true; r.status = "already"; r.message = "今日已领取"; return r; }
     if (claim.status === 200) {