mslxdff 0.1.154 → 0.1.156

package/package.json

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

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

@@ -10,7 +10,7 @@ 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 { summarizeRequest } from "../model-trace.js";
+import { summarizeRequest, upstreamEcho } from "../model-trace.js";
 import { isEmptyTurnError } from "../routes/chat/relay-pipeline.js";
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -91,6 +91,8 @@ export async function runSerialTrial(ctx, deps = {}) {
     if (Object.keys(shareKeys).length) chatOpts.shareKeys = shareKeys;
     if (workbuddyUid) chatOpts.workbuddyUid = workbuddyUid;
     if (handlerCtx?.sessionId) chatOpts.sessionId = handlerCtx.sessionId;
+    // reqId = 本次客户端请求的身份：供应商据此"同请求粘号"（重试不换号，只有 401/403/429/5xx 冷却才换）
+    if (reqId) chatOpts.reqId = reqId;
     const chatOptsArg = Object.keys(chatOpts).length ? chatOpts : undefined;
     // 空转 200（模型无输出）同模型暂停重试：默认 2 次、间隔 1s；仅 EMPTY_MODEL_RESPONSE，
     // 429/403/500 与 fetch 异常走原有切号/failover（防烧额度）。MSLXDFF_EMPTY_TURN_RETRIES=0 关闭。
@@ -101,7 +103,7 @@ export async function runSerialTrial(ctx, deps = {}) {
       evt("upstream-try", { reqId, model, attempt: idx + 1, emptyRetry: emptyRetried, payload: summarizeRequest(forwarded) });
       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 });
+        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, ...upstreamEcho(upRes) });
       } catch (err) {
         if (auto) await auto.recordError(model, { message: errMsg(err) });
         lastErr = { model, upstream: null, status: 502, message: errMsg(err) };
@@ -148,7 +150,7 @@ export async function runSerialTrial(ctx, deps = {}) {
         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 });
+        evt("upstream-error", { reqId, model, status: upRes.status, message: upMsg.slice(0, 300), timing: upRes._t ?? null, ...upstreamEcho(upRes) });
         upRes = null;
         break;
       }
@@ -170,7 +172,8 @@ export async function runSerialTrial(ctx, deps = {}) {
           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 });
+            // 带上"刚空转的是哪个号/哪个站"：切号是重试驱动的，日志必须能自证
+            evt("empty-turn-retry", { reqId, model, retry: emptyRetried, max: emptyCfg.max, delayMs: emptyCfg.delayMs, ...upstreamEcho(upRes) });
             await sleep(emptyCfg.delayMs);
             continue;
           }

package/src/cli/commands/model/list-providers.js

@@ -1,7 +1,9 @@
 /**
  * 其他供应商 allowlist 段 + 遗留别名映射展示。
  * 输入均为已算好的数据；state/model-id 走动态 import（与原内联一致，避免循环依赖）。
+ * allowlist 按 compareModelIds 排序展示（只改展示顺序，不改 allowlist 落盘内容）。
  */
+import { compareModelIds } from "./list-sort.js";
 export async function renderOtherProviders({ pickedIds, ids, fullAliases }) {
   const { loadProviderConfigs, loadProviderAllowedModels, loadProviderAllowAnyModels, loadProviderBaseUrl } = await import("../../../state.js");
   const { loadModelAliases: _la2, getAliasForModel: _gaf } = await import("../../../providers/model-id.js");
@@ -38,8 +40,7 @@ export async function renderOtherProviders({ pickedIds, ids, fullAliases }) {
           console.log(`     或放行全部: mslxdff -provider ${pid} allowAny on`);
         }
       } else {
-        for (const raw of allowed) {
-          const canonical = `${pid}/${raw}`;
+        for (const canonical of allowed.map((raw) => `${pid}/${raw}`).sort(compareModelIds)) {
           let alias = null;
           try { alias = _gaf(canonical); } catch {}
           if (!alias && String(canonical).includes("/")) alias = String(canonical).replace(/\//g, "-");

package/src/cli/commands/model/list-render.js

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { compareModelIds, providerOf, providerRank } from "./list-sort.js";
 
 /** 构建 id → 别名映射（原 list 两处重复逻辑收敛） */
 export function buildAliasMap(ids, getAliasForModel) {
@@ -57,22 +58,19 @@ export function renderFreeList({ ids, at, pickedIds, sortedProvs, groups, aliasM
   }
 }
 
-/** 按供应商分组 + 排序（opencode/workbuddy/cline/openrouter 优先） */
+/** 按供应商分组 + 排序（opencode 段最前，已知供应商优先，组内字母序） */
 export function groupByProvider(ids) {
   const groups = {};
   for (const id of ids) {
-    const prov = String(id).includes("/") ? String(id).split("/")[0] : "opencode";
+    const prov = providerOf(id);
     if (!groups[prov]) groups[prov] = [];
     groups[prov].push(id);
   }
-  const order = ["opencode", "workbuddy", "cline", "openrouter"];
+  for (const key of Object.keys(groups)) groups[key].sort(compareModelIds);
   const sortedProvs = Object.keys(groups).sort((a, b) => {
-    const ia = order.indexOf(a), ib = order.indexOf(b);
-    if (ia !== -1 || ib !== -1) {
-      if (ia === -1) return 1;
-      if (ib === -1) return -1;
-      return ia - ib;
-    }
+    const ra = providerRank(a);
+    const rb = providerRank(b);
+    if (ra !== rb) return ra - rb;
     return a.localeCompare(b);
   });
   return { groups, sortedProvs };

package/src/cli/commands/model/list-sort.js

@@ -0,0 +1,52 @@
+// `-models` / `-model list` 展示排序：opencode free 优先 → 其余供应商分组 → 组内字母序。
+// 单一来源：本文件被 list.js（交互候选）与 list-render.js（分组渲染）共用。
+// Note: 排序只影响展示顺序，不改 picks/候选集合 — 见 .agents/notes/implemented/feature/2026-09-28-models-sort-opencode-free-first.md
+import { isFreeModel } from "../../../models.js";
+
+/** 供应商展示优先级（opencode 恒第一；未知供应商按字母序排其后） */
+export const PROVIDER_ORDER = ["opencode", "workbuddy", "cline", "openrouter", "qoder", "codearts", "traework", "bai"];
+
+/** 取模型 id 的供应商前缀；无斜杠的裸 id 归 opencode */
+export function providerOf(id) {
+  const s = String(id || "");
+  const i = s.indexOf("/");
+  return i > 0 ? s.slice(0, i).toLowerCase() : "opencode";
+}
+
+/** 供应商排序权重：opencode=0，已知供应商=其序号+1，未知=大数（按字母序兜底） */
+export function providerRank(prov) {
+  const i = PROVIDER_ORDER.indexOf(prov);
+  return i === -1 ? PROVIDER_ORDER.length : i;
+}
+
+/**
+ * 模型 id 排序比较器：
+ *  1) opencode free（isFreeModel）最前 —— 用户主诉求
+ *  2) opencode 非 free 次之
+ *  3) 其余供应商按 PROVIDER_ORDER，未知按字母序
+ *  4) 同段内 localeCompare 字母序（大小写不敏感兜底）
+ */
+export function compareModelIds(a, b) {
+  const pa = providerOf(a);
+  const pb = providerOf(b);
+  const fa = pa === "opencode" && isFreeModel(a);
+  const fb = pb === "opencode" && isFreeModel(b);
+  // 段位：0=opencode free，1=opencode 其他，2=其他供应商
+  const ga = fa ? 0 : pa === "opencode" ? 1 : 2;
+  const gb = fb ? 0 : pb === "opencode" ? 1 : 2;
+  if (ga !== gb) return ga - gb;
+  if (ga === 2) {
+    const ra = providerRank(pa);
+    const rb = providerRank(pb);
+    if (ra !== rb) return ra - rb;
+    if (pa !== pb) return pa.localeCompare(pb);
+  }
+  const la = String(a).toLowerCase();
+  const lb = String(b).toLowerCase();
+  return la === lb ? String(a).localeCompare(String(b)) : la.localeCompare(lb);
+}
+
+/** 返回排序后的新数组（不改原数组） */
+export function sortModelIds(ids) {
+  return [...(ids || [])].sort(compareModelIds);
+}

package/src/cli/commands/model/list-tty.js

@@ -0,0 +1,76 @@
+// 交互式 `-models`（TTY 多选）主流程：从 list.js 拆出以守住 ≤10KB 体积门。
+// 候选合并（allowlist + live + picks 孤儿）→ 展示排序 → 勾选落盘。
+// Note: 排序规则单一来源在 list-sort.js；候选集合语义不变（只改展示顺序）。
+import { loadModelErrors, loadModelPicks, saveModelPicks } from "../../../state.js";
+import { getPreferredModel } from "../../../auto.js";
+import { pickInteractiveMulti } from "../../interactive.js";
+import { filterStalePicks } from "../../../providers/model-id.js";
+import { mergeLiveIds } from "./list-live.js";
+import { sortModelIds } from "./list-sort.js";
+
+/**
+ * 拼交互候选：opencode live ids + 已启用 provider 的 allowlist + live 补齐 + 可见 picks。
+ * 返回 { items, pickedIds }；items 已按 sortModelIds 排序。
+ */
+export async function buildPickerItems(liveIds, pickedIds) {
+  const statuses = loadModelErrors();
+  const current = getPreferredModel();
+  const combinedIds = [...liveIds];
+  const seen = new Set(combinedIds);
+  let staleFilter = null;
+  try {
+    const { loadProviderConfigs, loadProviderAllowedModels } = await import("../../../state.js");
+    const { buildProviderRows } = await import("../../provider-row.js");
+    // 已知 = 已启用（与 -provider list 同一 enabled 口径：有 baseUrl 且有 key；
+    // openrouter 有 key 即算，opencode 内置恒启用）。未启用 provider 的 picks
+    // 不进列表，启用后自动回来（数据未动）。
+    const knownProviders = buildProviderRows({}).filter((r) => r.enabled).map((r) => r.id);
+    loadProviderConfigs();
+    const allowedIds = [];
+    for (const pid of knownProviders.filter((k) => String(k).toLowerCase() !== "opencode")) {
+      for (const raw of loadProviderAllowedModels(pid)) {
+        const canonical = `${pid}/${raw}`;
+        allowedIds.push(canonical);
+        if (!seen.has(canonical)) {
+          seen.add(canonical);
+          combinedIds.push(canonical);
+        }
+      }
+    }
+    await mergeLiveIds({ combinedIds, seen, knownProviders, liveIds });
+    staleFilter = { knownProviders, liveIds, allowedIds };
+  } catch {}
+  // provider 已不存在的 picks 孤儿不进交互列表（数据不动，status --all 仍可审计）。
+  // configs 读失败时 staleFilter 为空 → 不过滤（默认放行）。
+  const visiblePicks = staleFilter ? filterStalePicks(pickedIds, staleFilter) : pickedIds;
+  for (const pid of visiblePicks) {
+    if (!seen.has(pid)) {
+      seen.add(pid);
+      combinedIds.push(pid);
+    }
+  }
+  // 展示排序：opencode free 最前 → opencode 其他 → 各供应商分组，组内字母序。
+  const items = sortModelIds(combinedIds).map((id) => {
+    const e = statuses[id];
+    return {
+      id,
+      status: typeof e === "number" ? "error" : e?.status || "normal",
+      current: id === current,
+      picked: pickedIds.includes(id),
+    };
+  });
+  return { items, pickedIds };
+}
+
+/** 跑一轮 TTY 勾选并落盘 picks（取消则不写）。调用方负责 exit。 */
+export async function runInteractivePick(liveIds) {
+  const pickedIds = loadModelPicks();
+  const { items } = await buildPickerItems(liveIds, pickedIds);
+  const result = await pickInteractiveMulti(items, new Set(pickedIds), Math.max(0, items.findIndex((x) => x.current)));
+  if (!result) {
+    console.log("cancelled — picks unchanged");
+    return;
+  }
+  saveModelPicks([...result]);
+  console.log(`saved ${result.size} picked model(s): ${[...result].join(", ") || "(none — auto uses full list)"}`);
+}

package/src/cli/commands/model/list.js

@@ -2,16 +2,12 @@ import { join } from "node:path";
 import { createModelsService } from "../../../models.js";
 import { createUpstreamClient } from "../../../upstream.js";
 import { logDir } from "../../../logs.js";
-import { loadModelErrors, loadModelPicks, saveModelPicks } from "../../../state.js";
-import { getPreferredModel } from "../../../auto.js";
+import { loadModelPicks } from "../../../state.js";
 import { fmtShanghaiYMDHM } from "../../../time.js";
 import { readModelsCache } from "../../util.js";
-import { pickInteractiveMulti } from "../../interactive.js";
 import { buildAliasMap, readFullAliases, renderProviderList, renderFreeList, groupByProvider } from "./list-render.js";
 import { renderOtherProviders } from "./list-providers.js";
-import { filterStalePicks } from "../../../providers/model-id.js";
-import { mergeLiveIds } from "./list-live.js";
-
+import { compareModelIds } from "./list-sort.js";
 /**
  * `-model list` 全流程：参数解析 → 刷新/回退 → provider 分支 → TTY 交互 → 分组渲染。
  * 渲染下沉 list-render / list-providers，本文件只留流程编排。
@@ -104,8 +100,7 @@ export async function handleModelList(args, idx, sub) {
           const at2 = cachedAt ? ` (cached ${fmtShanghaiYMDHM(cachedAt)})` : "";
           console.log(`${allowed.length} model(s) for ${prov}${at2} (allowlist，原名 + 别名):`);
           const pickedIds2 = loadModelPicks();
-          for (const raw of allowed) {
-            const canonical = `${prov}/${raw}`;
+          for (const canonical of allowed.map((raw) => `${prov}/${raw}`).sort(compareModelIds)) {
             let alias = null;
             try { alias = getAliasForModel(canonical); } catch {}
             if (!alias && String(canonical).includes("/")) alias = String(canonical).replace(/\//g, "-");
@@ -134,60 +129,8 @@ export async function handleModelList(args, idx, sub) {
       process.exit(0);
     }
     if (sub === undefined && process.stdin.isTTY && process.stdout.isTTY) {
-      const statuses = loadModelErrors();
-      const current = getPreferredModel();
-      const pickedIds = loadModelPicks();
-      const combinedIds = [...ids];
-      const seen = new Set(combinedIds);
-      let staleFilter = null;
-      try {
-        const { loadProviderConfigs, loadProviderAllowedModels } = await import("../../../state.js");
-        const { buildProviderRows } = await import("../../provider-row.js");
-        // 已知 = 已启用（与 -provider list 同一 enabled 口径：有 baseUrl 且有 key；
-        // openrouter 有 key 即算，opencode 内置恒启用）。未启用 provider 的 picks
-        // 不进列表，启用后自动回来（数据未动）。
-        const knownProviders = buildProviderRows({}).filter((r) => r.enabled).map((r) => r.id);
-        const configs = loadProviderConfigs();
-        const allowedIds = [];
-        for (const pid of knownProviders.filter((k) => String(k).toLowerCase() !== "opencode")) {
-          const allowed = loadProviderAllowedModels(pid);
-          for (const raw of allowed) {
-            const canonical = `${pid}/${raw}`;
-            allowedIds.push(canonical);
-            if (!seen.has(canonical)) {
-              seen.add(canonical);
-              combinedIds.push(canonical);
-            }
-          }
-        }
-        await mergeLiveIds({ combinedIds, seen, knownProviders, liveIds: ids });
-        staleFilter = { knownProviders, liveIds: ids, allowedIds };
-      } catch {}
-      // provider 已不存在的 picks 孤儿不进交互列表（数据不动，status --all 仍可审计）。
-      // configs 读失败时 staleFilter 为空 → 不过滤（默认放行）。
-      const visiblePicks = staleFilter ? filterStalePicks(pickedIds, staleFilter) : pickedIds;
-      for (const pid of visiblePicks) {
-        if (!seen.has(pid)) {
-          seen.add(pid);
-          combinedIds.push(pid);
-        }
-      }
-      const items = combinedIds.map((id) => {
-        const e = statuses[id];
-        return {
-          id,
-          status: typeof e === "number" ? "error" : e?.status || "normal",
-          current: id === current,
-          picked: pickedIds.includes(id),
-        };
-      });
-      const result = await pickInteractiveMulti(items, new Set(pickedIds), Math.max(0, items.findIndex((x) => x.current)));
-      if (!result) {
-        console.log("cancelled — picks unchanged");
-        process.exit(0);
-      }
-      saveModelPicks([...result]);
-      console.log(`saved ${result.size} picked model(s): ${[...result].join(", ") || "(none — auto uses full list)"}`);
+      const { runInteractivePick } = await import("./list-tty.js");
+      await runInteractivePick(ids);
       process.exit(0);
     }
     const at = cachedAt ? ` (cached ${fmtShanghaiYMDHM(cachedAt)})` : "";

package/src/model-trace.js

@@ -1,4 +1,6 @@
 // Per-model request trace formatting. Never include prompt, response body, headers or credentials.
+// Note: 同步 appendFileSync（异步 append 会在并发下打乱同一请求的阶段行序）— 见 .agents/notes/implemented/feature/2026-09-25-model-trace-log.md
+// Note: 事件面用黑名单（默认全可见，只排除噪声/敏感面）+ 决定类事件只渲染登记过的标量字段——起因是 empty-turn-retry 曾被阶段白名单静默吞掉，"关键决定不许再被漏登记" — 见 .agents/notes/implemented/feature/2026-09-27-qoder-per-request-sticky-account.md
 import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { logDir } from "./logs.js";
@@ -40,14 +42,21 @@ export function summarizeRequest(body = {}) {
 function hostPort(value) {
   try { const u = new URL(String(value)); return u.port ? `${u.hostname}:${u.port}` : u.hostname; } catch { return "-"; }
 }
-const TRACE_STAGES = new Set([
-  "request", "alias", "ordered", "model-try", "upstream-try", "upstream-done", "upstream-error",
-  "peer-request", "peer-forward", "peer-error", "relay-start", "relay-first-chunk", "relay-done",
-  "client-response", "result", "exhausted-local", "exhausted-all",
+// 黑名单（而非白名单）：模型日志默认收下**所有**事件，只排除噪声与凭据面。
+// 起因：`empty-turn-retry`（"切号换 URL"的真实触发者）曾被白名单静默吞掉，排障时只见现象不见原因。
+// 关键决定不允许再被漏登记：新增事件默认可见，确属噪声/敏感才在此登记排除。
+const TRACE_DENY = new Set([
+  "peer-health",     // 组员心跳，秒级高频，无决策价值
+  "heartbeat",       // 运行心跳
+  "client-session",  // 客户端会话标识（路由用），非决定且属敏感面
 ]);
 
 export function shouldTraceModel(type) {
-  return TRACE_STAGES.has(String(type || ""));
+  const t = String(type || "");
+  if (!t) return false;
+  if (TRACE_DENY.has(t)) return false;
+  if (t.startsWith("upstream-probe")) return false; // 探针类（probe/probe-error/probe-skip）
+  return true;
 }
 
 function safeText(value, n = 140) {
@@ -61,6 +70,41 @@ function kv(obj) {
   return Object.entries(obj).filter(([, v]) => v != null && v !== "").map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : v}`).join(" ");
 }
 
+// 决定类事件的可见字段白名单：只渲染这些标量；事件里的 payload/detail/stages/请求正文等一律不落模型日志。
+// 「加日志」不等于「倒数据」——新增决定字段要显式登记在这里才会出现。
+const DECISION_FIELDS = [
+  "status", "from", "to", "reason", "hook", "applied", "skipped", "plugin",
+  "provider", "before", "after", "models", "skippedFaulty", "limit", "tried",
+  "winPeer", "winTarget", "peer", "peers", "peerLabel", "routeBest", "at",
+  "latencyMs", "ttfMs", "hedged", "hops", "hasShare", "elapsedMs", "threshold",
+  "stallHits", "maxGapMs", "interrupted", "providers", "via",
+  "retry", "max", "delayMs", "upstream", "account", "pick", "cooled",
+];
+
+function decisionKv(data = {}) {
+  const out = [];
+  for (const k of DECISION_FIELDS) {
+    const v = data[k];
+    if (v == null || v === "") continue;
+    out.push(`${k}=${Array.isArray(v) ? v.join("|") : v}`);
+  }
+  return out.join(" ");
+}
+
+// provider 回显头 → 日志字段（谁上的 / 打哪个站 / 为什么选它 / 是否被冷却）：
+// 单一来源，防各处重复写法漂移；取不到时返回空对象（其它供应商零变化）。
+export function upstreamEcho(res) {
+  const h = res?.headers;
+  if (typeof h?.get !== "function") return {};
+  const pick = (name) => h.get(name) || null;
+  return {
+    upstream: pick("x-mslxdff-upstream"),
+    account: pick("x-mslxdff-workbuddy-uid") || pick("x-mslxdff-qoder-region"),
+    pick: pick("x-mslxdff-qoder-account"),
+    cooled: pick("x-mslxdff-qoder-cooldown"),
+  };
+}
+
 export function formatModelTrace({ type, reqId, model, data = {}, request = null, totalMs = null } = {}) {
   const base = { time: fmtShanghaiYMDHMS(new Date()), req: reqId || "-", model: model || "-", stage: type || "-" };
   let detail = "";
@@ -70,15 +114,16 @@ 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 ${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}` : ""} ${safeText(data.message || data.error || "")}`;
+  else if (type === "empty-turn-retry") detail = `retry ${data.retry ?? "-"}/${data.max ?? "-"} delay=${data.delayMs ?? "-"}ms${data.upstream ? ` after=${data.upstream}` : ""}${data.account ? ` account=${data.account}` : ""}${data.pick ? ` pick=${data.pick}` : ""} reason=empty turn`;
   else if (type === "peer-request" || type === "peer-forward" || type === "peer-error") detail = `peer=${hostPort(data.peer)} status=${data.status ?? "-"} latency=${data.latencyMs ?? "-"}ms payload=${kv(data.payload || {})} ${safeText(data.message || data.error || "")}`;
   else if (type === "relay-done") {
     const d = data.detail || {};
     const u = d.usage || {};
-    detail = `upstream_response status=${data.status ?? "-"} finish=${d.sawFinishReason || "-"} chunks=${d.receivedChunks ?? "-"} bytes=${d.receivedBytes ?? "-"} tools=${d.toolCalls ?? 0} chars=${d.chars ?? 0} usage(prompt=${u.prompt_tokens ?? "-"}/completion=${u.completion_tokens ?? "-"}) elapsed=${data.totalMs ?? "-"}ms`;
+    detail = `upstream_response status=${data.status ?? "-"} finish=${d.sawFinishReason || "-"} chunks=${d.receivedChunks ?? "-"} bytes=${d.receivedBytes ?? "-"} tools=${d.toolCalls ?? 0} chars=${d.chars ?? 0} usage(prompt=${u.prompt_tokens ?? "-"}/completion=${u.completion_tokens ?? "-"}) elapsed=${data.totalMs ?? "-"}ms${data.upstream ? ` upstream=${data.upstream}` : ""}${data.account ? ` account=${data.account}` : ""}${data.pick ? ` pick=${data.pick}` : ""}`;
   } else if (type === "result" || type === "client-response") {
-    detail = `client status=${data.status ?? "-"} via=${data.via || "-"} actual=${data.actual || model || "-"} fallback=${data.fallback?.fallback ? 1 : 0} total=${totalMs ?? data.durationMs ?? "-"}ms`;
-  } else detail = safeText(data.message || data.reason || data.error || "");
+    detail = `client status=${data.status ?? "-"} via=${data.via || "-"} actual=${data.actual || model || "-"} fallback=${data.fallback?.fallback ? 1 : 0} total=${totalMs ?? data.durationMs ?? "-"}ms${data.upstream ? ` upstream=${data.upstream}` : ""}${data.account ? ` account=${data.account}` : ""}${data.pick ? ` pick=${data.pick}` : ""}`;
+  } else detail = safeText(`${decisionKv(data)} ${data.message || data.error || ""}`, 200);
   return `[${base.time}] [req=${base.req}] [model=${base.model}] [stage=${base.stage}] ${detail}`;
 }
 

package/src/providers/keyring.js

@@ -52,5 +52,6 @@ export function createKeyRing(keys = [], { cooldownMs = DEFAULT_COOLDOWN_MS, now
     return list.filter((k) => !isCooling(k)).length;
   }
 
-  return { next, onError, replace, available, size: list.length, cooldownMs, keys: [...list] };
+  // isCooling 对外暴露：粘号选择器要判断"上次这个号还在冷却吗"（决定是否必须换号）
+  return { next, onError, replace, available, isCooling, size: list.length, cooldownMs, keys: [...list] };
 }

package/src/providers/qoder/chat.js

@@ -5,7 +5,11 @@ import { normalizeRegion } from "./constants.js";
 import { buildUpstreamRequest } from "./request.js";
 import { reshapeQoderStream } from "./stream.js";
 import { aggregateQoderStream, toCompletionJson } from "./aggregate.js";
-import { errorStatus } from "./sse.js";
+import { errorStatus, extractDelta } from "./sse.js";
+
+function hostOf(url) {
+  try { return new URL(String(url)).host; } catch { return "-"; }
+}
 
 function errRes(status, msg, type = "upstream_error") {
   return new Response(JSON.stringify({ error: { message: msg, type } }), { status, headers: { "Content-Type": "application/json" } });
@@ -15,11 +19,88 @@ function mapUpstreamError(status, detail) {
   return { kind: status === 401 || status === 403 ? "auth" : "upstream", status, detail: String(detail || "").slice(0, 300) };
 }
 
+// 预读上限：判决恒在首帧（实测 457 字节），8 帧足够覆盖"角色帧先到、判决帧随后"，
+// 又不会把首字节延迟拖到不可控。超窗未得判决即放弃（退化为无冷却的流内 error，见 SPEC 已知上限）。
+const PEEK_MAX_FRAMES = 8;
+
+// 预读上游首帧只为取「流内判决」：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, frames: [] };
+  let reader;
+  try { reader = upRes.body.getReader(); } catch { return { res: upRes, status: 0, frames: [] }; }
+  const dec = new TextDecoder();
+  const frames = [];
+  let text = "";
+  let status = 0;
+  let decided = false;
+  try {
+    for (let i = 0; i < PEEK_MAX_FRAMES && !decided; i++) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value) { frames.push(value); text += dec.decode(value, { stream: true }); }
+      // 逐行判定：先到判决（err）或先到有效载荷即停，避免无谓等待
+      for (const raw of text.split("\n")) {
+        const line = raw.trim();
+        if (!line.startsWith("data:")) continue;
+        const p = line.slice(5).trim();
+        if (!p || p === "[DONE]") continue;
+        const d = extractDelta(p);
+        if (d.err) { status = Number(d.err.status) || 0; 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(正常流)"}`);
+  // 回灌：已读帧先按原样吐出，再接续同一个 reader 的剩余部分
+  const body = new ReadableStream({
+    start(ctrl) {
+      for (const f of frames) { try { ctrl.enqueue(f); } catch {} }
+      (async () => {
+        try {
+          for (;;) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            if (value) ctrl.enqueue(value);
+          }
+        } catch {}
+        try { ctrl.close(); } catch {}
+      })();
+    },
+  });
+  return { res: new Response(body, { status: upRes.status, headers: upRes.headers }), status, frames };
+}
 export function createChatService({ id = "qoder", fetchImpl, timeoutMs } = {}) {
   if (!fetchImpl) fetchImpl = compatFetch;
 
   // body: OpenAI chat 请求；sess: 已建 COSY 会话；region: 该账号所属区（每号独立选端点）。返回 Response。
-  async function runChat(body, sess, region = "global") {
+  // 回显（可观测，不落凭据）：x-mslxdff-upstream=本次请求的 host、x-mslxdff-qoder-region=cn|global；
+  // 管线层据此把"这次谁上的、打哪个站"投进模型日志（此前 provider 内部选号/切 URL 完全静默，排障无据）。
+  const withEcho = (res, url, region, pick) => {
+    try {
+      res.headers.set("x-mslxdff-upstream", hostOf(url));
+      res.headers.set("x-mslxdff-qoder-region", normalizeRegion(region));
+      // 账号选择决定（new/sticky/switch/forced）：管线把它写进模型日志，"为什么会切号"才有据可查
+      if (pick) res.headers.set("x-mslxdff-qoder-account", String(pick));
+    } catch {}
+    return res;
+  };
+
+  // 上游状态回显（内部交接用，不落日志）：流式路径按对外契约把非 200 整形成 "200 + 流内 error"，
+  // 真实状态码只能靠这个头带出——否则 401/403/429/5xx 到不了 provider 门面，坏号不被冷却，
+  // 而"同请求粘号"（ADR-0036）会把后续重试继续粘在这个坏号上。
+  // Note: 流内判决需预读首帧才能拿到（HTTP 200 里裹 statusCodeValue）— 见 .agents/notes/implemented/bug-fix/2026-09-27-qoder-envelope-verdict-cooldown.md
+  const withUpstreamStatus = (res, st) => {
+    try { res.headers.set("x-mslxdff-qoder-upstream-status", String(st)); } catch {}
+    return res;
+  };
+
+  async function runChat(body, sess, region = "global", pick = "") {
     const stream = body?.stream !== false;
     const model = body?.model || "qfmodel";
     const chatId = "chatcmpl-qoder-" + Math.random().toString(16).slice(2, 10);
@@ -27,22 +108,34 @@ export function createChatService({ id = "qoder", fetchImpl, timeoutMs } = {}) {
     const messages = Array.isArray(body?.messages) ? body.messages : [];
     const maxTokens = Number(body?.max_tokens) || 0;
 
-    let upRes;
+    let upRes; let reqUrl = "";
+    const echo = (res) => withEcho(res, reqUrl, region, pick);
+    // 排障日志（QODER_DEBUG_STREAM=1 开）：记录出口/状态/耗时/响应头，便于对比"200 但空轮"
+    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 });
+      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();
       upRes = await fetchImpl(req.url, {
         method: "POST",
         headers: req.headers,
         body: req.bodyStr,
         signal: timeoutSignal(timeoutMs || 120_000),
       });
+      upMs = Date.now() - t0;
+      cdbg(`[res] status=${upRes.status} ms=${upMs} ct=${upRes.headers.get("content-type")} host=${hostOf(reqUrl)}`);
     } catch (e) {
       const detail = String(e?.message || e).slice(0, 300);
-      if (stream) return reshapeQoderStream(new Response("data: [DONE]\n\n"), { model, chatId });
-      return errRes(502, detail);
+      cdbg(`[res-throw] ms=${upMs} err=${detail}`);
+      // 网络异常（超时/连接失败）折成 502：门面据此冷却该号（否则坏号恒在轮换池里）
+      if (stream) return withUpstreamStatus(echo(reshapeQoderStream(new Response("data: [DONE]\n\n"), { model, chatId })), 502);
+      return withUpstreamStatus(echo(errRes(502, detail)), 502);
     }
     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);
       if (stream) {
         // 首包错误也走流内 error 事件（与旧 reshapeStream catch 语义一致：200 + event:error + DONE）
@@ -54,17 +147,26 @@ export function createChatService({ id = "qoder", fetchImpl, timeoutMs } = {}) {
             c.close();
           },
         });
-        return new Response(s, { status: 200, headers: { "Content-Type": "text/event-stream" } });
+        // 对外仍是 200（契约不变），真实状态码经回显头交门面决定是否冷却
+        return withUpstreamStatus(echo(new Response(s, { status: 200, headers: { "Content-Type": "text/event-stream" } })), upRes.status);
       }
-      return errRes(errorStatus(e), e.detail, e.kind);
+      return withUpstreamStatus(echo(errRes(errorStatus(e), e.detail, e.kind)), upRes.status);
+    }
+    if (stream) {
+      // 预读首帧取流内判决（qoder 把 403/429 裹在 200 的信封里），预读帧原样回灌给整形器。
+      // 判决状态码经 withUpstreamStatus 出门面 → index.js 据此 ring.onError 冷却该号 →
+      // 粘号选择器下次因 isCooling 为真而换号。对外仍恒 200（契约不变）。
+      const peek = await peekEnvelopeVerdict(upRes, cdbg);
+      const shaped = echo(reshapeQoderStream(peek.res, { model, chatId, prefetched: peek.frames }));
+      // 只在真有判决时挂状态码：正常流不写这个头（index.js 靠它区分"要不要冷却"）
+      return peek.status ? withUpstreamStatus(shaped, peek.status) : shaped;
     }
-    if (stream) return reshapeQoderStream(upRes, { model, chatId });
     try {
       const agg = await aggregateQoderStream(upRes);
       const out = toCompletionJson({ model, chatId, ...agg });
-      return new Response(JSON.stringify(out), { status: 200, headers: { "Content-Type": "application/json" } });
+      return echo(new Response(JSON.stringify(out), { status: 200, headers: { "Content-Type": "application/json" } }));
     } catch (e) {
-      return errRes(errorStatus(e), String(e?.detail || e?.message || e).slice(0, 300), e?.kind || "upstream_error");
+      return echo(errRes(errorStatus(e), String(e?.detail || e?.message || e).slice(0, 300), e?.kind || "upstream_error"));
     }
   }
 

package/src/providers/qoder/index.js

@@ -1,6 +1,7 @@
 // qoder provider 门面（原生直连，零桥依赖）：
 // 多号 = keys[] 里每条 device_token blob（auths/qoder-<uid>.json 落盘由 login 维护）；
-// 每请求 round-robin 选号 → 建会话 → COSY 签名直调上游；恒 local-only 不借 key。
+// 选号 → 建会话 → COSY 签名直调上游；恒 local-only 不借 key。
+// Note: 同请求粘号（一次客户端请求内复用同一个号，仅 401/403/429/5xx 冷却才换）与流式坏号冷却（真实状态码经内部头带出）— 见 .agents/notes/implemented/feature/2026-09-27-qoder-per-request-sticky-account.md
 import { loadProviderKeys, loadProviderConfig } from "../../state.js";
 import { listAccountDocs } from "./account-store.js";
 import { defaultStateFile } from "../../state/store.js";
@@ -11,6 +12,7 @@ import { normalizeRegion } from "./constants.js";
 import { fingerprintSeed, deriveMachineId, deriveMachineToken, deriveMachineType } from "./fingerprint.js";
 import { newSession } from "./session.js";
 import { createChatService } from "./chat.js";
+import { createStickyPicker } from "./sticky.js";
 import { createModelsService } from "./models.js";
 import { compatFetch } from "../../compat.js";
 
@@ -55,15 +57,27 @@ export function createQoderProvider({
 
 
 
+  // 选号：同一客户端请求内粘住（重试不换号），只有该号被冷却（401/403/429/5xx）才换下一个；
+  // 无 scope（拿不到 reqId，如独立的 models 探活）时退回原 round-robin。
+  const pickKey = createStickyPicker({
+    pick: () => ring.next() || keys[0] || "",
+    isCooling: (k) => ring.isCooling(k),
+    ttlMs: envInt("MSLXDFF_QODER_STICKY_MS", 600_000),
+  });
+
   // 凭据 → 会话（会话含 RSA/AES 临时密钥，进程内可复用；此处按请求轻建，成本低）
-  function pickSession() {
-    const key = ring.next() || keys[0] || "";
+  function pickSession(scope) {
+    let decision = "new";
+    const key = pickKey(scope, (d) => { decision = d; });
+    // 全部号都在冷却时 pick() 只能兜底取 keys[0]：这是"被迫选择"，必须与正常轮转区分开
+    if (ring.available() === 0) decision = "forced";
     const blob = accountFromBlob(key);
     if (!blob?.deviceToken) return null;
     const auth = authList.find((a) => String(a?.refreshToken || "") === String(blob.refreshToken || "")) || authList[0] || {};
     const region = normalizeRegion(region0 || auth.region || "global");
     const sess = buildSessionFor({ ...blob, uid: auth.uid, name: auth.name, region });
-    return { sess, region };
+    // key/pick 带出：onError(key) 要冷却"刚用过的这个号"；pick 让日志能写"这次为什么是它"
+    return { sess, region, key, pick: decision };
   }
   const region0 = region; // 构造参数优先
 
@@ -71,14 +85,37 @@ export function createQoderProvider({
   // models 服务按号选区：构造时无固定 region，listModels(sess, region) 动态传
   const modelsSvc = createModelsService({ id, fetchImpl });
 
-  async function chat(body) {
-    const picked = pickSession();
+  // 失败冷却：401/403/429/5xx 冷却当前号（cooldownMs，默认 30s），坏号不再参与轮换。
+  // 对齐 workbuddy/chat.js 的 onError 语义——此前 qoder 只 next() 不 onError，坏号恒在轮换池里。
+  // 网络异常（fetch throw）同样冷却。业务错（4xx 内容类）不冷却。
+  async function chat(body, opts) {
+    // scope=reqId：同一次客户端请求的多次上游调用（空转重试）粘同一个号
+    const picked = pickSession(opts?.reqId ? `req:${opts.reqId}` : null);
     if (!picked) {
       return new Response(JSON.stringify({ error: { message: "qoder: 无可用账号 — 先跑 mslxdff -provider qoder login", type: "auth_error" } }), { status: 401, headers: { "Content-Type": "application/json" } });
     }
+    const pickedKey = picked.key || "";
     const stripped = { ...body };
     if (typeof stripped.model === "string" && stripped.model.startsWith("qoder/")) stripped.model = stripped.model.slice(6);
-    return chatSvc.runChat(stripped, picked.sess, picked.region);
+    let res;
+    try {
+      res = await chatSvc.runChat(stripped, picked.sess, picked.region, picked.pick);
+    } catch (e) {
+      try { ring.onError(pickedKey); } catch {}
+      throw e;
+    }
+    const badAuth = (n) => n === 401 || n === 403 || n === 429 || n >= 500;
+    const st = res?.status ?? 0;
+    // 流式路径把上游非 200 整形成 200 + 流内 error（对外契约），真实状态码只能从回显头取；
+    // 否则坏号（401/403/429/5xx）永不冷却，粘号还会把重试继续粘在这个坏号上。
+    const ust = Number(res?.headers?.get?.("x-mslxdff-qoder-upstream-status")) || 0;
+    const bad = badAuth(st) ? st : (badAuth(ust) ? ust : 0);
+    if (bad) {
+      try { ring.onError(pickedKey); } catch {}
+      // 冷却是个决定：钉在响应上，管线写进模型日志（cooled=<status>）
+      try { res.headers?.set?.("x-mslxdff-qoder-cooldown", String(bad)); } catch {}
+    }
+    return res;
   }
 
    // 全号聚合：双号分属 cn/global 两区，模型表各不同（cn 14 个/global 15 个）；
@@ -140,9 +177,9 @@ export function createQoderProvider({
    }
 
   async function close() {}
-  async function chatWithKeys(body, keysOverride) {
+  async function chatWithKeys(body, keysOverride, opts) {
     const tmp = createQoderProvider({ id, apiKeys: keysOverride, file, fetchImpl, cooldownMs, connectTimeoutMs });
-    return tmp.chat(body);
+    return tmp.chat(body, opts);
   }
 
   return { id, chat, chatWithKeys, listModels, preheat, close, keyRing: ring, baseUrl: "qoder://native", region: normalizeRegion(region || authList[0]?.region) };

package/src/providers/qoder/sse.js

@@ -1,17 +1,30 @@
 // qoder 上游 SSE 信封解析（转译 qoder2api bridge.go ExtractDelta）
 // 帧形态：data:{"headers":{},"body":"<内层JSON>","statusCodeValue":200}
 // 信封 statusCodeValue!=200 = 瞬时上游错；内层 code!=0 = 业务错；usage 同帧合并
+// 排障日志（QODER_DEBUG_STREAM=1 开）：静默吞帧的分支必须有痕，否则"内容凭空消失"无从追
+const DBG_SSE = () => process.env.QODER_DEBUG_STREAM === "1";
+const ddbg = (...a) => { if (DBG_SSE()) console.log("[qoder-sse]", ...a); };
+
 export function extractDelta(dataLine) {
   let wrapper;
-  try { wrapper = JSON.parse(dataLine); } catch { return {}; }
+  try { wrapper = JSON.parse(dataLine); } catch (e) {
+    ddbg(`[envelope-parse-fail] ${e.message} line=${dataLine.slice(0, 300)}`);
+    return {};
+  }
   if (wrapper.statusCodeValue !== undefined && Number(wrapper.statusCodeValue) !== 200) {
     const detail = typeof wrapper.body === "string" && wrapper.body ? wrapper.body : JSON.stringify(wrapper).slice(0, 400);
     return { err: { kind: "upstream", status: Number(wrapper.statusCodeValue) || 502, detail } };
   }
   const inner = wrapper.body;
-  if (!inner || typeof inner !== "string") return {};
+  if (!inner || typeof inner !== "string") {
+    ddbg(`[body-not-string] bodyType=${typeof inner} envelopeKeys=${Object.keys(wrapper).join(",")} envelope=${dataLine.slice(0, 300)}`);
+    return {};
+  }
   let j;
-  try { j = JSON.parse(inner); } catch { return {}; }
+  try { j = JSON.parse(inner); } catch (e) {
+    ddbg(`[inner-parse-fail] ${e.message} body=${inner.slice(0, 300)}`);
+    return {};
+  }
   let usageIn = 0, usageOut = 0;
   if (j.usage && typeof j.usage === "object") {
     usageIn = Math.trunc(Number(j.usage.prompt_tokens) || 0);
@@ -33,6 +46,9 @@ export function extractDelta(dataLine) {
     return { err: { kind: /inappropriate|DataInspection|Sensitive|ContentFilter/i.test(String(j.message)) ? "content_policy" : "business", code: j.code, detail: String(j.message || "") } };
   }
   if (usageIn > 0 || usageOut > 0) return { usageIn, usageOut };
+  // 走到这里 = 帧既无 content/tool_calls、也无业务错、也无 usage。空轮排查的关键取证点：
+  // 把内层 JSON 的顶层键与 choices 原样打出来，一眼看出上游改了什么字段名。
+  ddbg(`[no-delta] innerKeys=${Object.keys(j).join(",")} choicesLen=${choices.length} inner=${JSON.stringify(j).slice(0, 400)}`);
   return {};
 }
 

package/src/providers/qoder/sticky.js

@@ -0,0 +1,38 @@
+// qoder 同请求粘号：一个客户端请求内的多次上游调用（空转重试/换路重试）复用同一个号，
+// 只有该号进入冷却（401/403/429/5xx → ring.onError）才切到下一个号。
+// 背景：keyring 每次 next() 都前进一格，而 qoder 两个号分属 cn/global 两区（region 决定 URL），
+// 于是「重试」会把同一个请求甩到另一个区——排障时表现为"URL 莫名在切"。粘号把"切号"收回到
+// 唯一正当理由：该号已被冷却。无 scope（拿不到请求标识）时退化为原 round-robin，与旧行为一致。
+// Note: 切号的唯一正当理由是冷却（401/403/429/5xx）——空转等其它失败不换号，故选择器要能问 keyring "上次这个号还在冷却吗" — 见 .agents/notes/implemented/feature/2026-09-27-qoder-per-request-sticky-account.md
+export function createStickyPicker({ pick, isCooling = () => false, now = Date.now, ttlMs = 600_000, maxEntries = 200 } = {}) {
+  const seen = new Map(); // scope → { key, at }
+
+  function evict() {
+    const t = now();
+    for (const [scope, hit] of seen) if (t - hit.at >= ttlMs) seen.delete(scope);
+    while (seen.size > maxEntries) seen.delete(seen.keys().next().value);
+  }
+
+  // onDecision（可选）：把"这次为什么选它"回报给调用方 —— 决定必须可观测。
+  // sticky=同请求复用 / new=新请求轮转选中 / switch=上次的号在冷却(或 TTL 过期)故换 / rr=无 scope 退回轮转
+  return function pickSticky(scope, onDecision) {
+    if (!scope) {
+      onDecision?.("rr");
+      return pick();
+    }
+    const hit = seen.get(scope);
+    // 粘住：同一请求内复用上次的号，除非它已被冷却（那时必须换）
+    if (hit && now() - hit.at < ttlMs && !isCooling(hit.key)) {
+      hit.at = now();
+      onDecision?.("sticky");
+      return hit.key;
+    }
+    const key = pick();
+    onDecision?.(hit ? "switch" : "new");
+    if (key) {
+      seen.set(scope, { key, at: now() });
+      if (seen.size > maxEntries) evict();
+    }
+    return key;
+  };
+}

package/src/providers/qoder/stream.js

@@ -3,6 +3,9 @@
 // usage 只在尾帧出现：收到即记，附在 finish chunk 上一次发出（与旧回放语义一致）。
 import { extractDelta } from "./sse.js";
 
+// 空轮排障用的临时日志开关：QODER_DEBUG_STREAM=1 才输出，默认静默（问题定位后可摘）
+const DBG_STREAM = () => process.env.QODER_DEBUG_STREAM === "1";
+const sdbg = (...a) => { if (DBG_STREAM()) console.log("[qoder-stream]", ...a); };
 function openaiChunk({ model, chatId, delta, finish, usage }) {
   const c = {
     id: chatId,
@@ -19,11 +22,13 @@ function errorEvent(e) {
   return `event: error\ndata: ${JSON.stringify({ message: String(e?.detail || e?.message || e), type: e?.kind || "upstream_error" })}\n\n`;
 }
 
-export function reshapeQoderStream(upstreamRes, { model, chatId }) {
+export function reshapeQoderStream(upstreamRes, { model, chatId, prefetched = [] }) {
   const src = upstreamRes.body;
   const enc = new TextEncoder();
   const dec = new TextDecoder();
-  let buf = "";
+  // 预读帧（chat.js 为取流内判决而先读的字节）原样回灌：既不丢内容也不重复，
+  // 判决帧会在这里被正常解析并抛错，同时 chat.js 已用同一批帧定出状态码挂上门面。
+  let buf = prefetched.map((b) => dec.decode(b, { stream: true })).join("");
   let usage = null;
   let finish = "stop";
   let sawContent = false;
@@ -32,40 +37,58 @@ export function reshapeQoderStream(upstreamRes, { model, chatId }) {
     async start(ctrl) {
       const reader = src.getReader();
       const send = (t) => ctrl.enqueue(enc.encode(t));
+      let chunkIdx = 0;
+      let contentLen = 0;
+      let lineIdx = 0;
       try {
-        send(openaiChunk({ model, chatId, delta: { role: "assistant" } }));
+        sdbg(`[enter] model=${model} chatId=${chatId} ct=${upstreamRes.headers.get("content-type")} status=${upstreamRes.status}`);
+        // role: assistant will be attached on first real delta to avoid premature payload commit
         for (;;) {
           const { done, value } = await reader.read();
-          if (value) buf += dec.decode(value, { stream: !done });
+          if (value) {
+            const text = dec.decode(value, { stream: !done });
+            buf += text;
+            sdbg(`[chunk#${chunkIdx++}] bytes=${value.byteLength} done=${done} decodedLen=${text.length} raw=${JSON.stringify(text.slice(0, 500))}`);
+          }
           const lines = buf.split("\n");
           buf = lines.pop();
+          sdbg(`[buf] lines=${lines.length} leftover=${JSON.stringify(buf.slice(0, 200))}`);
           for (const raw of lines) {
             const line = raw.replace(/\r$/, "");
-            if (!line.startsWith("data:")) continue;
+            lineIdx++;
+            if (!line.startsWith("data:")) { sdbg(`[line#${lineIdx}] non-data: ${JSON.stringify(line.slice(0, 200))}`); continue; }
             const payload = line.slice(5).trim();
-            if (!payload || payload === "[DONE]") continue;
+            if (!payload || payload === "[DONE]") { sdbg(`[line#${lineIdx}] skip: ${JSON.stringify(payload)}`); continue; }
             const d = extractDelta(payload);
-            if (d.err) throw d.err;
+            sdbg(`[line#${lineIdx}] payload=${JSON.stringify(payload.slice(0, 800))}`);
+            sdbg(`[line#${lineIdx}] parsed keys=${Object.keys(d).join(",")} content=${JSON.stringify((d.content || "").slice(0, 200))} reasoning=${JSON.stringify((d.reasoning || "").slice(0, 200))} toolCalls=${(d.toolCalls || []).length} usageIn=${d.usageIn} usageOut=${d.usageOut} err=${!!d.err}`);
+            if (d.err) { sdbg(`[line#${lineIdx}] ERROR from extractDelta: ${JSON.stringify(d.err)}`); throw d.err; }
             if (d.usageIn || d.usageOut) {
               usage = { prompt_tokens: d.usageIn, completion_tokens: d.usageOut, total_tokens: d.usageIn + d.usageOut };
+              sdbg(`[usage] ${JSON.stringify(usage)}`);
             }
             const delta = {};
-            if (d.content) { delta.content = d.content; sawContent = true; }
+            if (!sawContent) delta.role = "assistant";
+            if (d.content) { delta.content = d.content; contentLen += d.content.length; sawContent = true; }
             if (d.reasoning) { delta.reasoning_content = d.reasoning; sawContent = true; }
             if (d.toolCalls) { delta.tool_calls = d.toolCalls; finish = "tool_calls"; sawContent = true; }
             if (Object.keys(delta).length) send(openaiChunk({ model, chatId, delta }));
+            sdbg(`[acc] line#=${lineIdx} sawContent=${sawContent} contentLen=${contentLen} finish=${finish} usage=${JSON.stringify(usage)}`);
           }
           if (done) break;
         }
+        sdbg(`[end] totalChunks=${chunkIdx} totalLines=${lineIdx} sawContent=${sawContent} contentLen=${contentLen} finish=${finish} usage=${JSON.stringify(usage)}`);
         if (!sawContent && !usage) {
+          sdbg(`[empty-stream] sawContent=false usage=null → throw 502 empty upstream stream`);
           throw { kind: "upstream", status: 502, detail: "empty upstream stream" };
         }
         send(openaiChunk({ model, chatId, delta: {}, finish, usage }));
         send("data: [DONE]\n\n");
         finishSent = true;
       } catch (e) {
+        sdbg(`[catch] finishSent=${finishSent} e=${JSON.stringify(e?.message || e)}`);
         if (!finishSent) {
-          try { send(openaiChunk({ model, chatId, delta: {} })); } catch {}
+          if (sawContent) { try { send(openaiChunk({ model, chatId, delta: {} })); } catch {} }
           try { send(errorEvent(e)); } catch {}
           try { send("data: [DONE]\n\n"); } catch {}
           finishSent = true;

package/src/routes/chat/exhausted-handler.js

@@ -1,3 +1,4 @@
+// Note: 失败收尾四分支在 result 后补 client-response，与成功路径对账口径一致（result 条数 == client-response 条数）— 见 .agents/notes/implemented/bug-fix/2026-09-25-sdk-headers-timeout-and-failure-client-response.md
 import { relay } from "../stream.js";
 import { json } from "../helpers.js";
 import { performance } from "node:perf_hooks";

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

@@ -4,6 +4,7 @@ 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 专属旁路统计（账号×模型，流式也覆盖）
+import { upstreamEcho } from "../../model-trace.js"; // 回显头→日志字段（谁上的/哪个号/为什么/是否冷却）单一来源
 
 // 唯一/最后候选没有 failover 去向：首块闸门退化为纯"防连接泄漏"，放宽避免误杀慢模型
 // （参考 opencode：zen 通道不设超时；openai responses 硬编码 300s headerTimeout）
@@ -120,6 +121,7 @@ export function createRelayPipeline({
       aborted: out.aborted,
       interrupted: out.interrupted ?? false,
       timedOut: out.timedOut ?? false,
+      ...upstreamEcho(upRes),
       detail: out.detail ?? null,
     });
 
@@ -140,9 +142,13 @@ export function createRelayPipeline({
       // 错误包络暂扣后下游不再直观看到上游原文：把摘要带进最终报错（截断 200 字），排障不断线。
       const _err = _d.upstreamErrorText ? ` upstream=${String(_d.upstreamErrorText).slice(0, 200)}` : "";
       try { _logError(actual, 502, `empty turn${_why}${_err}`); } catch {}
-      _evt("upstream-error", { reqId, model: actual, status: 502, message: "empty turn", timing: null });
+      _evt("upstream-error", { reqId, model: actual, status: 502, message: "empty turn", timing: null, ...upstreamEcho(upRes) });
       _evt("fallback", { reqId, from: actual, to: null, reason: "empty turn" });
-      return { handled: false, upRes: null, lastErr: { model: actual, upstream: null, status: 502, message: `EMPTY_MODEL_RESPONSE: upstream returned 200 with no content${_why}${_err} — retry or rephrase` } };
+      let _errMsg = `EMPTY_MODEL_RESPONSE: upstream returned 200 with no content${_why}${_err} — retry or rephrase`;
+      if (_d.upstreamErrorText && _d.upstreamErrorText.includes("retryAfterSeconds")) {
+        _errMsg = _d.upstreamErrorText;
+      }
+      return { handled: false, upRes: null, lastErr: { model: actual, upstream: null, status: 502, message: _errMsg } };
     }
 
     // 5a. 首块超时未写字节 → 回退（显式 timedOut 字段，status 只是 HTTP 语义展示）
@@ -150,7 +156,7 @@ export function createRelayPipeline({
       const why = out.detail?.upstreamError ? ` (upstream read error: ${out.detail.upstreamError})` : "";
       if (auto) try { await auto.recordError(actual, { status: 502, slow: true, note: `stream timeout ${streamTimeoutMs}ms` }); } catch {}
       try { _logError(actual, 502, `stream timeout ${streamTimeoutMs}ms${why}`); } catch {}
-      _evt("upstream-error", { reqId, model: actual, status: 502, message: "stream timeout", timing: null });
+      _evt("upstream-error", { reqId, model: actual, status: 502, message: "stream timeout", timing: null, ...upstreamEcho(upRes) });
       _evt("fallback", { reqId, from: actual, to: null, reason: "stream timeout" });
       return { handled: false, upRes: null, lastErr: { model: actual, upstream: null, status: 502, message: `stream timed out after ${streamTimeoutMs}ms${why}` } };
     }
@@ -161,7 +167,7 @@ export function createRelayPipeline({
         try { await auto.recordError(actual, { status: 200, slow: true, note: `stall ${C.STALL_TIMEOUT_MS}ms` }); } catch {}
         try { await auto.recordLatency(actual, out.totalMs ?? (Date.now() - curStartedAt)); } catch {}
       }
-      _evt("slow-model", { reqId, model: actual, elapsedMs: out.totalMs ?? (Date.now() - curStartedAt), threshold: C.STALL_TIMEOUT_MS, interrupted: true, detail: out.detail ?? null });
+      _evt("slow-model", { reqId, model: actual, elapsedMs: out.totalMs ?? (Date.now() - curStartedAt), threshold: C.STALL_TIMEOUT_MS, interrupted: true, detail: out.detail ?? null, ...upstreamEcho(upRes) });
       try { _logCall(actual, 200); } catch {}
       // interrupted 的 200 也是真实消耗（最贵的长生成）——照常落 usage 标 interrupted:1，口径与 5c 一致 — 见 .agents/notes/implemented/feature/2026-09-19-usage-report-jsonl.md
       if (out.status === 200) {
@@ -172,7 +178,7 @@ export function createRelayPipeline({
           recordChatUsage({ model: normalizeFullId(actual), via, usage: u, interrupted: 1, ttfbMs: t0, totalMs: t1, tps: null }).catch(() => {});
         } catch {}
       }
-      _evt("result", { reqId, model: actual, status: out.status, via, timing: upRes?._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, interrupted: true, detail: out.detail ?? null, fallback, requested, actual });
+      _evt("result", { reqId, model: actual, status: out.status, via, timing: upRes?._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, interrupted: true, ...upstreamEcho(upRes), detail: out.detail ?? null, fallback, requested, actual });
       _evt("client-response", { requested, actual, via, fallback, status: out.status, reqId, interrupted: true });
       if (plugins?.length) runHook(plugins, "request:completed", { reqId, requested, useAuto, hops, stream: Boolean(body?.stream), durationMs: Date.now() - curStartedAt, via, status: out.status, actual, interrupted: true, fallback }).catch(() => {});
       return { handled: true };
@@ -186,13 +192,13 @@ export function createRelayPipeline({
     if (C.SLOW_TOTAL_MS && auto && elapsed > C.SLOW_TOTAL_MS && out.status === 200) {
       try { await auto.recordError(actual, { status: 200, slow: true, note: `slow ${elapsed}ms` }); } catch {}
       try { await auto.recordLatency(actual, latencyMs); } catch {}
-      _evt("slow-model", { reqId, model: actual, elapsedMs: elapsed, threshold: C.SLOW_TOTAL_MS, reason: "total", detail: out.detail ?? null });
+      _evt("slow-model", { reqId, model: actual, elapsedMs: elapsed, threshold: C.SLOW_TOTAL_MS, reason: "total", detail: out.detail ?? null, ...upstreamEcho(upRes) });
       scoredSlow = true;
     }
     if (out.detail?.stallHits > 0 && auto && out.status === 200) {
       try { await auto.recordError(actual, { status: 200, slow: true, note: `stall ${out.detail.stallHits}x gap>${C.SCORE_STALL_MS}ms maxGap ${out.detail.maxGapMs}ms` }); } catch {}
       try { await auto.recordLatency(actual, latencyMs); } catch {}
-      _evt("slow-model", { reqId, model: actual, elapsedMs: elapsed, threshold: C.SCORE_STALL_MS, reason: "stall", stallHits: out.detail.stallHits, maxGapMs: out.detail.maxGapMs, detail: out.detail ?? null });
+      _evt("slow-model", { reqId, model: actual, elapsedMs: elapsed, threshold: C.SCORE_STALL_MS, reason: "stall", stallHits: out.detail.stallHits, maxGapMs: out.detail.maxGapMs, detail: out.detail ?? null, ...upstreamEcho(upRes) });
       scoredSlow = true;
     }
     if (!scoredSlow && auto && out.status === 200) {
@@ -234,7 +240,7 @@ export function createRelayPipeline({
       } catch {}
     }
 
-    _evt("result", { reqId, model: actual, status: out.status, via, timing: upRes?._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, detail: out.detail ?? null, fallback, requested, actual });
+    _evt("result", { reqId, model: actual, status: out.status, via, timing: upRes?._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, ...upstreamEcho(upRes), detail: out.detail ?? null, fallback, requested, actual });
     _evt("client-response", { requested, actual, via, fallback, status: out.status, reqId });
     if (plugins?.length) runHook(plugins, "request:completed", { reqId, requested, useAuto, hops, stream: Boolean(body?.stream), durationMs: Date.now() - curStartedAt, via, status: out.status, actual, fallback }).catch(() => {});
     return { handled: true };

package/src/routes/stream.js

@@ -35,12 +35,40 @@ function hasPayload(text) {
 // 否则返回 null（透传）。解析失败一律透传（默认保安全）。
 // 背景：网关把上游失败包成 HTTP 200 SSE；暂扣后下游流式 UI 不再展示瞬时错误
 //（如 Vertex 503 + google fallback 400），本轮走空转重试，客户端只看到最终结果。
+// Note: 流内错误包络捕获与 retryAfterSeconds 错误直出 — 见 .agents/notes/implemented/bug-fix/2026-09-28-retry-after-surfacing-error.md
+function extractRetryAfterSec(obj) {
+  if (!obj) return null;
+  if (typeof obj === "number") return obj;
+  if (typeof obj === "string") {
+    const m = obj.match(/"retryAfterSeconds"\s*:\s*(\d+)/i) || obj.match(/\bretryAfterSeconds\s*[:=]\s*(\d+)/i);
+    if (m) return Number(m[1]);
+    try {
+      const parsed = JSON.parse(obj);
+      return extractRetryAfterSec(parsed);
+    } catch {}
+  }
+  if (typeof obj === "object") {
+    if (Number.isFinite(obj.retryAfterSeconds)) return Number(obj.retryAfterSeconds);
+    if (obj.message) {
+      const r = extractRetryAfterSec(obj.message);
+      if (r != null) return r;
+    }
+  }
+  return null;
+}
+
 function holdableChunk(txt) {
   if (typeof txt !== "string" || !txt.includes("data:")) return null;
   let sawData = false;
+  let sawEventError = false;
+  let retrySec = null;
   const errs = [];
-  for (const line of txt.split("\n")) {
-    const t = line.trim();
+  for (const rawLine of txt.split("\n")) {
+    const t = rawLine.trim();
+    if (t.startsWith("event:") && t.slice(6).trim() === "error") {
+      sawEventError = true;
+      continue;
+    }
     if (!t.startsWith("data:")) continue;
     const d = t.slice(5).trim();
     if (!d || d === "[DONE]") continue;
@@ -53,15 +81,26 @@ function holdableChunk(txt) {
     const msg = c0.message || {};
     const out = delta.content || msg.content || delta.tool_calls || msg.tool_calls || delta.reasoning || msg.reasoning;
     if (out && !(Array.isArray(out) && out.length === 0)) return null;
+
+    const r = extractRetryAfterSec(j);
+    if (r != null) {
+      retrySec = r;
+      continue;
+    }
     if (j.error && typeof j.error === "object") {
       const m = j.error.message || j.error.code || "";
       if (m) errs.push(String(m).slice(0, 300));
-    } else if (c0.finish_reason !== "error") {
-      return null;
+    } else if (sawEventError && j.message) {
+      errs.push(String(j.message).slice(0, 300));
+    } else if (c0.finish_reason === "error") {
+      errs.push("finish_reason=error 空帧");
     }
   }
   if (!sawData) return null;
-  return errs.length ? errs.join(" | ") : "finish_reason=error 空帧";
+  if (retrySec != null) return `上游供应商触发 retryAfterSeconds: ${retrySec} ，请等候重试`;
+  if (errs.length) return errs.join(" | ");
+  if (sawEventError) return "event: error 空帧";
+  return null;
 }
 
 // 自持 reader 优先：for-await 会锁定 ReadableStream，使 body.cancel() 必 reject（真流上等于空操作），

package/src/timeline.js

@@ -1,4 +1,5 @@
 // 人读请求时间线：只输出状态/耗时/出口，不输出 prompt、响应正文或凭据。
+// Note: 渲染口径与失败路径 client-response 对账（result 与 client-response 条数须相等）— 见 .agents/notes/implemented/feature/2026-09-25-model-trace-log.md
 function hostPort(value) {
   try { const u = new URL(String(value)); return u.port ? `${u.hostname}:${u.port}` : u.hostname; } catch { return String(value || "-").slice(0, 80); }
 }

package/src/upstream-engine/sdk/attempt.js

@@ -8,6 +8,7 @@
 //（cline muse-spark 2026-09-25 17:48 悬空 27min+，无 upstream-done/error/result）。
 // 默认 120s（覆盖慢模型首块握手的合理上限），MSLXDFF_SDK_HEADERS_TIMEOUT_MS=0 关闭。
 // 注意错误文案不得含 "timed out"：cline runChat 靠该子串做网络重试，命中会把挂死放大 3 倍。
+// Note: 闸门定时器不可 unref()（会让事件循环排空、node:test 判 cancelled）— 见 .agents/notes/implemented/bug-fix/2026-09-25-sdk-headers-timeout-and-failure-client-response.md
 import { toModelPrompt, toModelTools, toModelToolChoice, toModelParams } from "./convert.js";
 import { createSseSerializer } from "./sse.js";
 import { diagnoseToolSequence, compactSequence } from "./diagnose.js";