creditdaddy 1.6.2 → 1.6.5

package/src/providers.js

@@ -17,6 +17,7 @@ import { fetchCatpawQuota, fetchCatpawProfile } from './catpawClient.js';
 import { fetchTraeQuota, checkinTrae, verifyTraeAccount } from './traeClient.js';
 import { fetchMiniMaxQuota, checkinMiniMax, verifyMiniMaxAccount } from './minimaxClient.js';
 import { fetchDoubaoStatus, checkinDoubao } from './doubaoClient.js';
+import { fetchLoomyQuota, verifyLoomyAccount } from './loomyClient.js';
 /** 从 userinfo 响应中挑一个可读的显示名 */
 export function displayNameFrom(ui) {
   const pick = [ui?.nickname, ui?.name, ui?.username, ui?.email]
@@ -230,6 +231,14 @@ const PRODUCTS = {
       };
     },
   },
+  loomy: {
+    label: '讯飞 Loomy',
+    quota: (account) => fetchLoomyQuota(account),
+    verify: (account) => verifyLoomyAccount(account),
+  },
+  // 码道 CodeArts（issue #40）已于 2026-10-30 撤下：华为云控制台会话受闲置超时 +
+  // WAF 指印绑定，本机无法续期，实测当日内即失效，无法支撑每日定时签到。详见
+  // cookieSites.js 末尾的口径说明。
 };
 
 /** 包裹 MiniMax 的 ctx.onRefresh：回写账号库后，安全同步新凭据回本机 auth.json（仅本机导入账号且客户端未运行时） */

package/src/qoderClient.js

@@ -55,8 +55,10 @@ export async function exchangePatToJobToken(pat, isCn = false) {
     const text = await res.text().catch(() => '');
     throw new Error(`PAT 兑换失败: HTTP ${res.status} ${text.slice(0, 120)}`);
   }
-  const data = await res.json();
-  if (!data.token) throw new Error('PAT 兑换未返回 job token');
+  // 200 但 body 非 JSON（边缘节点 HTML 拦截页/空响应）：裸 res.json() 抛 SyntaxError，
+  // resolveToken 的兜底 catch 会把它报成「token 不可用」，用户冤枉地去重导 token
+  const data = await res.json().catch(() => null);
+  if (!data?.token) throw new Error('PAT 兑换未返回 job token（响应非 JSON 或缺 token）');
   return { jobToken: data.token, expiresAt: data.expires_at || null };
 }
 
@@ -84,7 +86,9 @@ export async function fetchUserinfo(account) {
     preferProxy: account.provider === 'qoder',
   });
   if (!res.ok) throw new Error(`userinfo HTTP ${res.status}`);
-  return res.json();
+  const data = await res.json().catch(() => null);
+  if (!data || typeof data !== 'object') throw new Error(`userinfo 响应非 JSON（HTTP ${res.status}）`);
+  return data;
 }
 
 /** 查询配额/积分用量 */
@@ -97,7 +101,9 @@ export async function fetchQuotaUsage(account) {
   });
   if (res.status === 401 || res.status === 403) throw new Error(`鉴权失败 (HTTP ${res.status})，token 可能已过期`);
   if (!res.ok) throw new Error(`quota HTTP ${res.status}`);
-  return res.json();
+  const data = await res.json().catch(() => null);
+  if (!data || typeof data !== 'object') throw new Error(`quota 响应非 JSON（HTTP ${res.status}）`);
+  return data;
 }
 
 function webHeaders(cookie, provider) {
@@ -135,7 +141,9 @@ export async function fetchUsageDetail(account) {
     throw err;
   }
   if (!res.ok) throw new Error(`usage detail HTTP ${res.status}`);
-  return res.json();
+  const data = await res.json().catch(() => null);
+  if (!data || typeof data !== 'object') return null;   // 结构异常按「无明细」回落聚合数据
+  return data;
 }
 
 /**
@@ -174,7 +182,8 @@ async function getCampaigns(base, headers) {
     throw err;
   }
   if (!res.ok) throw new Error(`活动列表 HTTP ${res.status}`);
-  const payload = await res.json();
+  const payload = await res.json().catch(() => null);
+  if (!payload || typeof payload !== 'object') throw new Error(`活动列表响应非 JSON（HTTP ${res.status}）`);
   return {
     uid: typeof payload?.uid === 'string' ? payload.uid : null,
     campaigns: Array.isArray(payload?.campaigns) ? payload.campaigns : [],

package/src/quotaRefresh.js

@@ -103,6 +103,11 @@ export async function verifyQuotaRefresh({ source, exp, sig }, { nowMs } = {}) {
 const hits = new Map();   // ip → number[]
 export function refreshRateLimited(ip, { limit = 20, windowMs = 60_000, nowMs } = {}) {
   const now = nowMs ?? Date.now();
+  // 顺手清掉整个窗口都没动静的来源：公网/网段扫描器每个 IP 都会占一条，永不回收
+  for (const [k, v] of hits) {
+    const last = v.length ? v[v.length - 1] : 0;
+    if (now - last >= windowMs) hits.delete(k);
+  }
   const arr = (hits.get(ip) || []).filter((t) => now - t < windowMs);
   arr.push(now);
   hits.set(ip, arr);

package/src/store.js

@@ -59,7 +59,14 @@ export async function atomicWrite(file, content, { retries = 6 } = {}) {
     path.dirname(file),
     `.tmp-${path.basename(file)}-${crypto.randomBytes(4).toString('hex')}`
   );
-  await fs.writeFile(tmp, content, { mode: 0o600 });
+  try {
+    await fs.writeFile(tmp, content, { mode: 0o600 });
+  } catch (e) {
+    // 首写就失败（ENOSPC/EPERM）：清掉半截临时文件再上抛，否则数据目录里
+    // 每次失败都多一个 .tmp-* 残骸
+    await fs.unlink(tmp).catch(() => {});
+    throw e;
+  }
   const doRename = renameImpl || ((a, b) => fs.rename(a, b));
   let transientRetries = 0;
   try {
@@ -231,7 +238,7 @@ export function publicAccount(a) {
     qoderWebDead: String(a.provider).startsWith('qoder')
       ? (meta.qoderWebDead?.at || null)
       : null,
-    canSwitch: Boolean(meta.session?.account || meta.credentials || meta.qoderAuth || a.provider === 'catpaw' || a.provider === 'trae'),
+    canSwitch: Boolean(meta.session?.account || meta.credentials || meta.qoderAuth || a.provider === 'catpaw' || a.provider === 'trae' || a.provider === 'loomy'),
     verified: a.verified ?? null,
     createdAt: a.createdAt,
     lastCheckin: a.lastCheckin,

package/src/tenrouter.js

@@ -44,20 +44,37 @@ const SOURCES_VERSION = 3;   // 3: 新增 10Router 本机实例来源（10r）
 
 export function loadConfig() {
   try {
-    const c = JSON.parse(fs.readFileSync(FILE(), 'utf8'));
-    const sync = { ...DEFAULT_CONFIG.sync, ...(c.sync || {}) };
-    const quotaPush = { ...DEFAULT_CONFIG.quotaPush, ...(c.quotaPush || {}) };
-    const accountSync = { ...DEFAULT_CONFIG.accountSync, ...(c.accountSync || {}) };
-    // 旧配置里的 sources 是保存时的快照，会盖掉新增来源（妙手因此被静默关掉）；
-    // 只把此后新增的来源默认并入，用户手动关掉的保持关闭。
-    const savedVersion = Number(c.sync?.sourcesVersion) || 1;
-    if (savedVersion < SOURCES_VERSION) {
-      sync.sources = (Array.isArray(sync.sources) ? [...sync.sources] : [...SOURCES]);
-      for (const s of SOURCES) if (!LEGACY_SOURCES.includes(s) && !sync.sources.includes(s)) sync.sources.push(s);
-      sync.sourcesVersion = SOURCES_VERSION;
+    return normalizeLoaded(JSON.parse(fs.readFileSync(FILE(), 'utf8')));
+  } catch (e) {
+    // 只有「文件不存在」才回默认值。EPERM/EBUSY（杀软/同步盘瞬时占用）或 JSON 损坏时
+    // 返回默认对象，下一个 withConfig 会把「默认值 + 本轮改动」整份写回——端点、key、
+    // 同步水位全部被静默抹掉，且 catpaw 的 sentTotals 清零会让历史用量整段重发。宁可报错。
+    if (e.code === 'ENOENT') return structuredClone(DEFAULT_CONFIG);
+    if (e instanceof SyntaxError) {
+      try {
+        const bak = JSON.parse(fs.readFileSync(FILE() + '.bak', 'utf8'));
+        console.error('tenrouter: 配置文件损坏,已用备份恢复 ' + FILE() + '.bak');
+        return normalizeLoaded(bak);
+      } catch { /* 备份也没有/同坏——按原错误上抛，禁止用默认值覆盖现场 */ }
     }
-    return { ...DEFAULT_CONFIG, ...c, sync, quotaPush, accountSync, syncState: c.syncState || {} };
-  } catch { return structuredClone(DEFAULT_CONFIG); }
+    throw new Error(`读取 ${FILE()} 失败: ${e.message}`);
+  }
+}
+
+// loadConfig 的归一化（旧配置 sources 快照迁移等，主文件与 .bak 同一形状）
+function normalizeLoaded(c) {
+  const sync = { ...DEFAULT_CONFIG.sync, ...(c.sync || {}) };
+  const quotaPush = { ...DEFAULT_CONFIG.quotaPush, ...(c.quotaPush || {}) };
+  const accountSync = { ...DEFAULT_CONFIG.accountSync, ...(c.accountSync || {}) };
+  // 旧配置里的 sources 是保存时的快照，会盖掉新增来源（妙手因此被静默关掉）；
+  // 只把此后新增的来源默认并入，用户手动关掉的保持关闭。
+  const savedVersion = Number(c.sync?.sourcesVersion) || 1;
+  if (savedVersion < SOURCES_VERSION) {
+    sync.sources = (Array.isArray(sync.sources) ? [...sync.sources] : [...SOURCES]);
+    for (const s of SOURCES) if (!LEGACY_SOURCES.includes(s) && !sync.sources.includes(s)) sync.sources.push(s);
+    sync.sourcesVersion = SOURCES_VERSION;
+  }
+  return { ...DEFAULT_CONFIG, ...c, sync, quotaPush, accountSync, syncState: c.syncState || {} };
 }
 
 // 配置落盘走 store.atomicWrite：Windows 上杀软/同步盘瞬时占文件会直接 EPERM，
@@ -65,7 +82,13 @@ export function loadConfig() {
 async function saveConfig(c) {
   fs.mkdirSync(dataDir(), { recursive: true, mode: 0o700 });
   const { atomicWrite } = await import('./store.js');
-  await atomicWrite(FILE(), JSON.stringify(c, null, 2));
+  const file = FILE();
+  // 同 saveAccounts：写前留一份 .bak，主文件损坏（断电半写/杀软截断）时 loadConfig 有路可回
+  try {
+    const existing = fs.readFileSync(file, 'utf8');
+    if (existing.trim().length > 2) await atomicWrite(file + '.bak', existing);
+  } catch { /* 主文件不存在/读不了就没有可备份的 */ }
+  await atomicWrite(file, JSON.stringify(c, null, 2));
 }
 
 // 读改写串行，避免面板保存与后台同步互相覆盖

package/src/tenrouterAccounts.js

@@ -22,6 +22,7 @@ export const TENROUTER_PROVIDER_MAP = {
   workbuddy: 'codebuddy-cn',
   'workbuddy-intl': 'codebuddy-intl',
   tokenharbor: 'tokenharbor-free',   // #23：会话 cookie 只喂「额度监控卡」(freeTier,不走路由);tokenharbor 钱包卡留给 sk- 运输 key
+  loomy: 'loomy',
   // zcode → glm：等 zcode 反代就绪后补一行（同步流程已就绪，无需改代码）
 };
 

package/src/traeClient.js

@@ -53,8 +53,24 @@ function seeded(uid, salt, n) {
 }
 
 export function traeDevice(uid, storedDeviceId, attempt = 0) {
-  // attempt 参数：9074 重试时轮换派生设备号（issue #31 报告者实测——派生号被服务端一律拒 9074、
-  // 同一时刻真机号可领，说明服务端大概率只认登录时注册的设备号，换号重试才有机会过）。
+  // 首选**登录时注册的真机号**（meta.deviceId，本机导入时从 storage.json 抓的）：
+  // 服务端大概率把「号-设备」绑在登录时注册的那台上——陌生设备号打接口吃 9074
+  //（issue #31 报告者实测派生号一律被拒、同一时刻真机号可领；本机实测同现象：
+  // 导入首日派生号签到成功，之后每天 9074，重试换派生号 3 轮也全拒）。
+  // attempt>0 才走派生：多账号同机时真机号只有一个，第二个账号起服务端按设备限
+  // 每日一领会拒（issue #28，TraeTools 的「设备码切换」本质就是给每号换独立设备码），
+  // 此时轮换派生号，至少有一个号能落在服务端风控放行的窗口里。
+  if (attempt === 0 && storedDeviceId && /^\d{8,}$/.test(String(storedDeviceId))) {
+    const m = seeded(`${uid}`, 'market:0', 16);
+    m[6] = (m[6] & 0x0f) | 0x40;
+    m[8] = (m[8] & 0x3f) | 0x80;
+    const h = m.map((b) => b.toString(16).padStart(2, '0')).join('');
+    return {
+      deviceId: String(storedDeviceId),
+      marketUserId: `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`,
+      sessionId: seeded(uid, 'sess', 32).map((b) => b.toString(16).padStart(2, '0')).join(''),
+    };
+  }
   // attempt=0 为默认指纹（跨天稳定恒定）；attempt>0 派生结果互异但同样确定（同 attempt 重放一致）。
   const d = seeded(`${uid}`, `devid:${attempt}`, 15).map((b) => String(48 + (b % 10)));
   const m = seeded(`${uid}`, `market:${attempt}`, 16);
@@ -62,9 +78,6 @@ export function traeDevice(uid, storedDeviceId, attempt = 0) {
   m[8] = (m[8] & 0x3f) | 0x80;
   const h = m.map((b) => b.toString(16).padStart(2, '0')).join('');
   return {
-    // x-device-id 按 uid 派生（每号独立且稳定）：本机导入的 N 个账号若共用客户端自报的
-    // 同一设备号，服务端按设备限每日一领——第二个账号起签到必吃 9074（issue #28，
-    // TraeTools 的「设备码切换」本质就是给每个账号换独立设备码）。这里不落 storedDeviceId。
     deviceId: d.join(''),
     marketUserId: `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`,
     sessionId: seeded(uid, 'sess', 32).map((b) => b.toString(16).padStart(2, '0')).join(''),

package/src/traeGateway.js

@@ -45,6 +45,21 @@ export async function setGatewayEnabled(v) {
   }
 }
 
+/** 丢弃错误响应的 body：不读不取消的 undici body 会把连接钉住到服务端关闭或 ~300s 超时
+ *  （429 风暴时每个失败尝试泄漏一条 socket）。cancel 即可，错误体不需要内容。 */
+function drainErr(res) {
+  try { res?.body?.cancel?.()?.catch?.(() => {}); } catch { /* 已读/已取消 */ }
+}
+
+/** 账号被删除时清掉它在各轮换 Map 里的残留（daemon DELETE /api/accounts/:id 调用） */
+export function forgetAccount(id) {
+  cooling.delete(id);
+  coolingStreak.delete(id);
+  dead.delete(id);
+  weights.delete(id);
+  swrr.delete(id);
+}
+
 // ── 账号轮换状态（进程内） ──
 
 const cooling = new Map();  // accountId → 冷却截止(ms)
@@ -53,6 +68,8 @@ const coolingStreak = new Map();
 const dead = new Map();     // accountId → 拉黑时的凭据指纹（指纹变化 = 已重新授权/导入，自动复活）
 const weights = new Map();  // accountId → { w: 剩余积分权重, at: 查询时刻 }
 const WEIGHT_TTL_MS = 10 * 60_000;  // 超过 10 分钟重查额度，让积分变化反映到分流上
+const WEIGHT_REFRESH_CAP_MS = 2_000;   // 请求路径等新权重的上限；超时先用旧快照，刷新转后台
+const weightInflight = new Map();      // accountId → 刷新中 Promise（并发请求共用一次查询）
 
 export const stats = {
   lastCallAt: null,
@@ -107,6 +124,7 @@ export function __resetForTests() {
   coolingStreak.clear();
   dead.clear();
   weights.clear();
+  weightInflight.clear();
   swrr.clear();
   stats.lastCallAt = null;
   stats.calls = 0;
@@ -116,15 +134,40 @@ export function __resetForTests() {
 async function accountWeight(a) {
   const hit = weights.get(a.id);
   if (hit && Date.now() - hit.at < WEIGHT_TTL_MS) return hit.w;
-  let w = hit?.w ?? MIN_WEIGHT;
+  const fallback = hit?.w ?? MIN_WEIGHT;
+  // 请求路径只等一个很短的上限：额度接口健康时（通常亚秒）照常拿到新权重精准分流；
+  // 上游黑洞时最多等这么久就先用旧快照——刷新仍在后台继续，下一个请求就有新值。
+  // 此前是完整等待额度查询（两个 POST，各 15s 上限）且逐号串行，一个黑洞的上游
+  // 能让权重过期后的第一个补全请求卡 1-2 分钟
+  const refresh = weightRefresh(a);
+  let timer;
+  const capped = new Promise((r) => { timer = setTimeout(() => r(fallback), WEIGHT_REFRESH_CAP_MS); });
   try {
-    const q = await fetchTraeQuota(a);
-    w = Math.max(MIN_WEIGHT, Number(q?.remaining) || 0);
-  } catch {
-    // 额度查询失败保留上次快照权重（网络抖动不该把主力踢成保底权重）
+    return await Promise.race([refresh, capped]);
+  } finally {
+    clearTimeout(timer);
   }
-  weights.set(a.id, { w, at: Date.now() });
-  return w;
+}
+
+/** 去重后的权重刷新：并发请求共用同一次额度查询；查询失败保留旧快照权重（时间戳仍刷新，避免每请求都撞同一坏接口） */
+function weightRefresh(a) {
+  const existing = weightInflight.get(a.id);
+  if (existing) return existing;
+  const run = (async () => {
+    const hit = weights.get(a.id);
+    let w = hit?.w ?? MIN_WEIGHT;
+    try {
+      const q = await fetchTraeQuota(a);
+      w = Math.max(MIN_WEIGHT, Number(q?.remaining) || 0);
+    } catch {
+      // 额度查询失败保留上次快照权重（网络抖动不该把主力踢成保底权重）
+    }
+    weights.set(a.id, { w, at: Date.now() });
+    return w;
+  })();
+  weightInflight.set(a.id, run);
+  run.finally(() => { if (weightInflight.get(a.id) === run) weightInflight.delete(a.id); }).catch(() => {});
+  return run;
 }
 
 const swrr = new Map();
@@ -133,16 +176,20 @@ function ensureSwrr(id) { if (!swrr.has(id)) swrr.set(id, 0); }
 async function rotationQueue() {
   const all = (await loadAccounts()).filter((a) => a.provider === 'trae');
   const now = Date.now();
-  const ready = [];
+  const candidates = [];
   for (const a of all) {
     if (isDead(a)) continue;
     if ((cooling.get(a.id) || 0) > now) continue;
     if (!a.token) continue;
     ensureSwrr(a.id);
-    const w = await accountWeight(a);
-    swrr.set(a.id, (swrr.get(a.id) || 0) + w);
-    ready.push({ account: a, weight: w });
+    candidates.push(a);
   }
+  // 权重并行取（各自 2s 封顶），不再逐号串行等——N 个账号的最坏停顿从 N×上限变成 1 个上限
+  const ws = await Promise.all(candidates.map((a) => accountWeight(a)));
+  const ready = candidates.map((a, i) => {
+    swrr.set(a.id, (swrr.get(a.id) || 0) + ws[i]);
+    return { account: a, weight: ws[i] };
+  });
   if (!ready.length) return [];
 
   let pick = ready[0];
@@ -323,6 +370,9 @@ export async function handleGateway(req, res) {
   const attempted = [];
   const clientAbort = new AbortController();
   req.once('close', () => { if (!res.writableEnded) clientAbort.abort(); });
+  // 优雅断开（客户端 fetch abort 在上游响应前）只触发 res 'close'，不触发 req 'close'
+  // ——少这一个钩子，取消后还会真的创建 SOLO 会话烧掉额度
+  res.once('close', () => { if (!res.writableEnded) clientAbort.abort(); });
 
   for (let i = 0; i < Math.min(MAX_ATTEMPTS, queue.length); i++) {
     const account = queue[i];
@@ -414,6 +464,7 @@ export async function handleGateway(req, res) {
     }
 
     if (sessionRes.status === 401) {
+      drainErr(sessionRes);
       markDead(account);
       attempted.push({ account: label, ok: false, error: 'Token 彻底失效 (401)，拉黑' });
       logger.info('TRAE-GW', '{label} 凭据失效,拉黑', { label });
@@ -421,6 +472,7 @@ export async function handleGateway(req, res) {
     }
 
     if (sessionRes.status === 429) {
+      drainErr(sessionRes);
       const ms = markRateLimited(account.id);
       const dur = formatDurationMs(ms);
       const streak = coolingStreak.get(account.id);
@@ -431,6 +483,7 @@ export async function handleGateway(req, res) {
 
     const sessionData = await sessionRes.json().catch(() => null);
     if (!sessionRes.ok || sessionData?.code !== 0 || !sessionData?.data?.chat_session_id) {
+      drainErr(sessionRes);
       const errMsg = sessionData?.message || `HTTP ${sessionRes.status}`;
       attempted.push({ account: label, ok: false, error: `会话创建失败: ${errMsg}` });
       continue;
@@ -439,11 +492,13 @@ export async function handleGateway(req, res) {
     const chatSessionId = sessionData.data.chat_session_id;
     const messageId = sessionData.data.message_id;
 
-    // 清理 session 的辅助函数
+    // 清理 session 的辅助函数。不挂 clientAbort 信号——客户端取消时恰恰要执行这里的
+    // 清理；DELETE 也走 fetchJsonRace 限时，裸 fetch 黑洞时会吊住 socket 约 5 分钟
     const cleanupSession = () => {
-      fetch(`${TRAE_SOLO_BASE}/chat_sessions/${chatSessionId}`, {
+      fetchJsonRace(`${TRAE_SOLO_BASE}/chat_sessions/${chatSessionId}`, {
         method: 'DELETE',
         headers: makeHeaders(token),
+        timeoutMs: 10_000,
       }).catch(() => {});
     };
 
@@ -471,6 +526,7 @@ export async function handleGateway(req, res) {
     }
 
     if (!eventsRes.ok || !eventsRes.body) {
+      drainErr(eventsRes);
       cleanupSession();
       // 事件流被 429（会话建好了、拉流被限流）同样按阶梯冷却——不判的话这个号
       // 下一轮会话创建仍从 30 秒档起算，继续撞限流

package/src/transfer.js

@@ -111,6 +111,9 @@ export function buildExportPayload(accounts, { provider, product } = {}) {
       refreshToken: a.refreshToken || null,
       expiresAt: a.expiresAt || null,
       createdAt: a.createdAt,
+      // 10Router 原生 Loomy 行是 authType:'apikey'（apiKey=session，sms-login 路由同款）；
+      // 不带这个字段，10R 导入端按默认 oauth 落库、不写 apiKey 字段，loomy 运行时读不到凭据
+      ...(a.provider === 'loomy' ? { authType: 'apikey' } : {}),
       providerSpecificData: {
         authMethod: a.token.startsWith('pt-') ? 'pat' : 'device',
         userId: a.uid || null,

package/src/usageSync.js

@@ -287,7 +287,17 @@ async function collectCatpaw(accounts, modelLabel, sentTotals = {}) {
   if (failed && !out.length) throw lastErr;
   if (failed) notes.push(`${failed} 个妙手账号用量拉取失败：${lastErr && lastErr.message}`);
   out.sort((x, y) => (x.timestamp < y.timestamp ? -1 : 1));
-  return { entries: out, notes, nextSentTotals: { ...sentTotals, ...nextSent } };
+  // 水位只服务 400 天回溯窗的差量记账：窗口外的桶永远不会再被读到，
+  // 留着只是让 tenrouter.json 每小时白白重写几千条死账（多留 10 天余量，
+  // 不剪回溯窗边界附近的活水位——剪早了那桶会被当新差量整段重发）
+  const minDate = localDateKey(new Date(now - 410 * 86400e3));
+  const merged = {};
+  for (const [key, v] of Object.entries({ ...sentTotals, ...nextSent })) {
+    const date = String(key).split('|')[1];
+    if (date && date < minDate) continue;
+    merged[key] = v;
+  }
+  return { entries: out, notes, nextSentTotals: merged };
 }
 
 /** 本机 10Router/9Router 的 usageHistory 行 → 导入行（同 10router-sync 插件 --source 10r）。

package/src/zcodeAutoClaim.js

@@ -13,7 +13,7 @@
 
 import { logger } from './logger.js';
 import { t } from './i18n.js';
-import { fetchClaimPlans, claimPlan, fetchCaptchaConfig } from './zcodeClient.js';
+import { fetchClaimPlans, claimPlan, fetchCaptchaConfig, ZCODE_KNOWN_CLAIM_PLANS } from './zcodeClient.js';
 import { withAccounts } from './store.js';
 
 // 额满（1005）时消费服务端 nextAt（plan.ends_at）：
@@ -33,6 +33,9 @@ export function setZcodeCaptchaProvider(fn) { captchaProvider = typeof fn === 'f
 export function hasZcodeCaptchaProvider() { return Boolean(captchaProvider); }
 export function getZcodeCaptchaProvider() { return captchaProvider; }
 
+/** 账号被删除时清掉额满暂休缓存（daemon DELETE /api/accounts/:id 调用；落盘份随账号一起删） */
+export function forgetAccount(id) { snoozeUntil.delete(id); }
+
 const grantsText = (plan) => (plan.grants && plan.grants.length ? plan.grants.join('；') : '');
 
 /**
@@ -55,7 +58,12 @@ export async function zcodeAutoClaim(account) {
         logger.debug('ZCODE-CLAIM', '{label} 活动查询失败:{err}', { label, err: e.message });
     return null;
   }
-  if (!plans.length) return null;
+  if (!plans.length) {
+    // preview 为空 ≠ 无事可做：服务端偶尔把活动从列表里藏起来（2026-10-30 WEEKEND BUILD
+    // 实测 preview 返回空但 claim 按 planId 直接可领）。把已知清单合成伪 plan 走同一条
+    // 领取链路：1001/1002（不存在/已结束）在 catch 里静默跳过，不进卡片。
+    plans = ZCODE_KNOWN_CLAIM_PLANS.map((k) => ({ planId: k.planId, name: k.name || k.planId, description: '', priority: 0, grants: [], known: true }));
+  }
 
   const claims = [];
   let anySuccess = false;
@@ -84,6 +92,9 @@ export async function zcodeAutoClaim(account) {
         snoozeAt = Math.max(snoozeAt, Number(new Date(e.nextAt)) || 0);
       }
       if (e.code !== 3007 && e.code !== 3001) {
+        // 1001/1002 = 已知清单兜底里的活动不存在/已结束：静默跳过（不进卡片、不算失败）。
+        // 只对 known 兜底项生效——preview 列表里的真实活动若返回 1002 仍要如实记失败
+        if ((e.code === 1001 || e.code === 1002) && plan.known === true) continue;
         claims.push({ plan: planName, ok: false, message: e.message });
                 logger.warn('ZCODE-CLAIM', '{label} 领取「{plan}」失败:{err}', { label, plan: planName, err: e.message });
         continue;
@@ -127,6 +138,8 @@ export async function zcodeAutoClaim(account) {
     } catch {}
   }
 
+  // 已知清单全部不可领（1001/1002 静默跳过）时 claims 为空：无事发生，不留痕迹
+  if (!claims.length) return null;
   const names = claims.filter((c) => c.ok && !c.already).map((c) => c.plan);
   const status = names.length ? 'checked-in'
     : claims.every((c) => c.already) ? 'already'

package/src/zcodeClient.js

@@ -21,6 +21,7 @@ import https from 'node:https';
 import os from 'node:os';
 import path from 'node:path';
 import tls from 'node:tls';
+import { PassThrough } from 'node:stream';
 import { execFile } from 'node:child_process';
 import { FETCH_TIMEOUT_MS } from './constants.js';
 import { defaultSecret, safeDecrypt } from './zcrypto.js';
@@ -237,10 +238,20 @@ async function fetchViaProxy(url, { method = 'GET', headers = {}, body = null, t
     }
     const done = (fn, arg) => { clearTimeout(deadline); signal?.removeEventListener('abort', onAbort); fn(arg); };
     const req = (isHttps ? https : http).request(requestOpts, (res) => {
-      const chunks = [];
-      res.on('data', (c) => chunks.push(c));
-      res.on('end', () => done(resolve, new Response(Buffer.concat(chunks), { status: res.statusCode, headers: res.headers })));
-      res.on('error', (e) => done(reject, e));
+      // 流式转发：经代理的响应（含网关 SSE 补全）逐块到达，而不是整包收完才 resolve——
+      // 此前代理优先模式下客户端在整个生成期间一个字节都收不到，首 token 超时必然误报
+      const pass = new PassThrough();
+      res.pipe(pass);
+      res.on('error', (e) => pass.destroy(e));
+      // close 在正常收尾与异常中断时都会触发；complete=false = 没收完就被掐
+      // （abort/超时销毁 socket 后 res 不一定发 'error'）。deadline 也在这里才清：
+      // 墙钟上限必须继续管住流式 body，与直连路径（AbortSignal 管到 body 结束）同口径
+      res.on('close', () => {
+        clearTimeout(deadline);
+        signal?.removeEventListener('abort', onAbort);
+        if (!res.complete) pass.destroy(new Error('连接中断'));
+      });
+      resolve(new Response(pass, { status: res.statusCode, headers: res.headers }));
     });
     req.on('error', (e) => done(reject, e));
     req.on('timeout', () => req.destroy(new Error('请求超时')));
@@ -332,9 +343,21 @@ export async function fetchJsonRace(url, { method = 'GET', headers = {}, body =
   if (errs.length > 1) {
     const detail = errs.map(([w, e]) => `${w === 'direct' ? '直连' : '代理'}: ${e?.message || e}`).join('；');
     const last = errs[errs.length - 1][1];
-    // 在最后一条错误上改写 message（保留 err.code / instanceof，调用方判定不受影响）
-    last.message = detail;
-    throw last;
+    // 优先在最后一条错误上改写 message（保留 err.code / instanceof，调用方判定不受影响）。
+    // 但 AbortSignal.timeout / fetch 的 abort reason 是 DOMException——message 只有 getter，
+    // 赋值会抛 TypeError 把真实网络错误整个吞掉（2026-10-30 ZCode 活动查询报
+    // 「Cannot set property message」即此，真因被掩盖）。descriptor 不可写时退回包一层
+    // 普通 Error，原始错误挂 cause、code 透传。
+    try {
+      last.message = detail;
+      throw last;
+    } catch (e) {
+      if (e === last) throw last;                       // 赋值成功，原样上抛
+      const wrapped = new Error(detail);                // 赋值抛错（getter-only message）
+      wrapped.cause = last;
+      if (last?.code) wrapped.code = last.code;
+      throw wrapped;
+    }
   }
   throw errs[0]?.[1] || new Error('fetch failed');
 }
@@ -353,6 +376,16 @@ const CLAIM_FAIL = {
 
 const platform = () => `${process.platform}-${process.arch === 'arm64' ? 'arm64' : process.arch === 'x64' ? 'x64' : process.arch}`;
 
+/**
+ * 已知活动兜底清单：服务端偶尔把活动从 billing/preview 里藏起来（2026-10-30 WEEKEND BUILD
+ * 实测 preview 返回空 plans，但 claim 按 planId 直接可领、免验证码）。preview 查不到时
+ * 逐个试这里的 planId：1001/1002（不存在/已结束）当没有，1003 按已领口径，0 即领取成功。
+ * 活动过期后条目留在表里无害（claim 返回 1002 跳过）；新活动出现时在此追加一行。
+ */
+export const ZCODE_KNOWN_CLAIM_PLANS = [
+  { planId: 'zcode-v3-start-plan-1030-wk', name: 'ZCODE WEEKEND BUILD' },
+];
+
 export async function zaiHeaders(token, deviceMid) {
   const ver = await zcodeAppVersion();
   return {

package/src/zcodeGateway.js

@@ -108,6 +108,18 @@ function markRateLimited(id) {
 /** 账号补全成功：清零连续 429 计数（下次 429 重新从 30 秒起算） */
 function resetCoolingStreak(id) { coolingStreak.delete(id); }
 
+/**
+ * 账号被删除时清掉它在各轮换 Map 里的残留（daemon DELETE /api/accounts/:id 调用）。
+ * 账号 id 每次导入都是新 UUID，删了不清理的话这些条目永远不会被任何人再触碰。
+ */
+export function forgetAccount(id) {
+  cooling.delete(id);
+  coolingStreak.delete(id);
+  dead.delete(id);
+  quotaCache.delete(id);
+  for (const [k, v] of sessionSticky) if (v?.accountId === id) sessionSticky.delete(k);
+}
+
 /**
  * 测试专用：把某账号的冷却截止拨到指定时间戳（0 = 立即到期，用于快进冷却窗口）。
  * 生产不走这里——冷却窗口只能自然到期。
@@ -402,6 +414,12 @@ function stickyFor(sessionId) {
 /** 会话粘住的号仍可用才粘；否则落到轮转队首，由调用方重新绑定 */
 function touchSticky(sessionId, accountId) {
   if (!sessionId) return;
+  // 每段对话一个新 session id，安静会话的条目只有等它自己再被查到才会过期——
+  // 长期运行的网关上单调增长。超阈值时整表清一遍过期项。
+  if (sessionSticky.size > 500) {
+    const now = Date.now();
+    for (const [k, v] of sessionSticky) if (now - (v?.at || 0) >= SESSION_STICKY_TTL_MS) sessionSticky.delete(k);
+  }
   sessionSticky.set(sessionId, { accountId, at: Date.now() });
 }
 /** 从上游 JSON 信封里取业务码；字符串数字（"3007"）也认，取不到返回 null */
@@ -563,6 +581,9 @@ export async function handleGateway(req, res) {
   // （MaxListenersExceededWarning + 泄漏）。
   const clientAbort = new AbortController();
   req.once('close', () => { if (!res.writableEnded) clientAbort.abort(); });
+  // 优雅断开（客户端 fetch abort 在上游响应前）只触发 res 'close'，不触发 req 'close'
+  // ——少这一个钩子，Ctrl+C 后整个重试循环（含验证码求解、账号轮换）还在为已死的客户端空跑
+  res.once('close', () => { if (!res.writableEnded) clientAbort.abort(); });
   // 首发不带验证码（客户端真实流量多数直过）；上游 3007/403 时求解并在此后的
   // 尝试上挂新 token（zcode-api 同策略）。provider 为 null（NAS/CLI）时首过路径依然可用。
   let captcha = null;
@@ -680,8 +701,17 @@ export async function handleGateway(req, res) {
           }
         }
       } catch (e) {
-        // 客户端主动断开（点停止/换一句）就会在这里结束——属正常收尾，不是故障，降为 debug
-        logger.debug('ZCODE-GW', '流式转发中断:{err}', { err: e.message });
+        if (clientAbort.signal.aborted) {
+          // 客户端主动断开（点停止/换一句）就会在这里结束——属正常收尾，不是故障，降为 debug
+          logger.debug('ZCODE-GW', '流式转发中断:{err}', { err: e.message });
+        } else {
+          // 上游中途断了：直接 res.end() 是无 message_stop 的裸 EOF，客户端只会报
+          // 「流意外结束」——按 Anthropic 协议补一帧 error 事件，把原因带出去
+          logger.warn('ZCODE-GW', '上游流中断:{err}', { err: e.message });
+          try {
+            res.write(`event: error\ndata: ${JSON.stringify({ type: 'error', error: { type: 'api_error', message: `上游流中断：${e.message}` } })}\n\n`);
+          } catch { /* 客户端已不在 */ }
+        }
       }
       res.end();
       return true;