creditdaddy 1.2.0 → 1.3.2

package/src/zcodeGateway.js

@@ -1,7 +1,7 @@
 /**
  * ZCode 免费额度网关 — Start Plan 体验包（GLM-5.3-Flash）的本地补全代理。
  *
- * 数据面：POST /gateway/v1/messages（Anthropic /v1/messages 形态，10router
+ * 数据面：POST /gateway/zcode/v1/messages（Anthropic /v1/messages 形态，10router
  * 建一个 anthropic-compatible 自定义节点指向这里即可）。
  *
  * 链路：账号轮换（store 里 provider=zcode、可解析出 zcodejwttoken 的账号）
@@ -16,13 +16,14 @@
  * daemon 加绑定/密钥，见 README）。NAS/纯 CLI 环境没有验证码提供者，网关开不了。
  */
 
-import { claimToken, zaiHeaders, fetchCaptchaConfig, fetchJsonRace, fetchZcodeQuota } from './zcodeClient.js';
+import { claimToken, fetchCaptchaConfig, fetchJsonRace, fetchZcodeQuota } from './zcodeClient.js';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 // ZCode 客户端 plan 请求形状（从本机客户端真实流量捕获的载荷模板：系统提示词数组 +
-// currentDate 提醒块 + metadata 会话形状）。网关请求镜像此形状——这就是 405 风控的通过票。
+// currentDate 提醒块 + metadata 会话形状）。网关请求镜像此形状——这就是 405/3012 风控的通过票。
+// 提示词已脱敏（去掉抓包来源的用户路径/会话 id），避免把第三方隐私随请求外发（见 issue #16）。
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 let PLAN_SHAPE = null;
 try { PLAN_SHAPE = JSON.parse(readFileSync(path.join(__dirname, 'zcodePlanShape.json'), 'utf8')); } catch {}
@@ -35,16 +36,20 @@ import { gatewayHostSuggestion } from './tenrouter.js';
 let completionProvider = null;
 export function setZcodeCompletionProvider(fn) { completionProvider = typeof fn === 'function' ? fn : null; }
 export function getZcodeCompletionProvider() { return completionProvider; }
-import { loadAccounts, loadSettings, saveSettings, loadState, saveState } from './store.js';
+import { loadAccounts, loadSettings, saveSettings, loadState, withState } from './store.js';
 import crypto from 'node:crypto';
 import os from 'node:os';
-import { logger } from './logger.js';
+import { logger, summarizeAttempts } from './logger.js';
 
 const PLAN_MESSAGES_URL = 'https://zcode.z.ai/api/v1/zcode-plan/anthropic/v1/messages';
 const CAPTCHA_CACHE_TTL_MS = 30_000;
 const ACCOUNT_COOLING_MS = 5 * 60_000;
 const MAX_ATTEMPTS = 6;
+// 上游补全墙钟上限（响应头到齐后 body 仍可流式跑这么久）
 const UPSTREAM_TIMEOUT_MS = 600_000;
+// 连接段（DNS/TCP/TLS/首字节）限时：上游黑洞挂死时几秒内换下一条路 / 代理兜底，
+// 而不是吊满 10 分钟——这是「网关很慢 / 卡住」体感的主要来源
+const UPSTREAM_CONNECT_MS = 15_000;
 
 // ── 开关（持久化在 settings.zcodeGateway） ──
 
@@ -53,14 +58,21 @@ export async function gatewayEnabled() {
 }
 
 export async function setGatewayEnabled(v) {
-  await saveSettings({ zcodeGateway: v === true });
+  const on = v === true;
+  await saveSettings({ zcodeGateway: on });
+  // 开启网关视为「重新开始」：清掉进程内的拉黑/冷却状态，
+  // 否则重新登录导入后旧黑名单仍会把账号挡在轮换队列外（与 MiniMax 网关同款 bug）。
+  if (on) {
+    dead.clear();
+    cooling.clear();
+  }
 }
 
 // ── 账号轮换状态（进程内；重启即清零） ──
 
 let rrIndex = 0;
 const cooling = new Map();  // accountId → 冷却截止(ms)
-const dead = new Set();     // JWT 失效的账号
+const dead = new Map();     // accountId → 拉黑时的凭据指纹（指纹变化 = 已重新登录导入，自动复活）
 
 function markCooling(id, ms = ACCOUNT_COOLING_MS) { cooling.set(id, Date.now() + ms); }
 
@@ -76,7 +88,29 @@ export function __resetForTests() {
   stats.calls = 0;
   stats.lastAccount = null;
 }
-function markDead(id) { dead.add(id); cooling.set(id, Number.MAX_SAFE_INTEGER); }
+function markDead(account) {
+  dead.set(account.id, credFingerprint(account));
+  cooling.set(account.id, Number.MAX_SAFE_INTEGER);
+}
+
+/** 拉黑时的凭据指纹：重新登录/重新导入会整体替换 meta.credentials，指纹变化即可复活 */
+function credFingerprint(a) {
+  return `${a.meta?.credentials?.zcodejwttoken || ''}|${a.token || ''}`;
+}
+
+/**
+ * 账号是否仍处于拉黑状态。拉黑记的是「当时那份凭据」的指纹：
+ * 重新登录导入换了 JWT 后指纹不匹配 → 自动复活（清黑名单与冷却）。
+ */
+function isDead(account) {
+  const fp = dead.get(account.id);
+  if (fp === undefined) return false;
+  if (fp === credFingerprint(account)) return true;
+  dead.delete(account.id);
+  cooling.delete(account.id);
+  logger.info('ZCODE-GW', `${account.name || account.uid || account.id} 凭据已更新，解除拉黑`);
+  return false;
+}
 
 /** 可参与轮换的账号（有可解析 plan JWT、未冷却/未拉黑），按轮转序排列 */
 async function rotationQueue() {
@@ -85,7 +119,7 @@ async function rotationQueue() {
   const now = Date.now();
   const ready = [];
   for (const a of all) {
-    if (dead.has(a.id)) continue;
+    if (isDead(a)) continue;
     if (isQuotaExhausted(a.id)) continue; // 0 额度打标，不再轮换
     if ((cooling.get(a.id) || 0) > now) continue;
     try { claimToken(a); ready.push(a); } catch { /* 快照里没有 plan JWT，跳过 */ }
@@ -102,7 +136,7 @@ async function unavailableReason() {
   const now = Date.now();
   const n = { dead: 0, exhausted: 0, cooling: 0, noJwt: 0 };
   for (const a of all) {
-    if (dead.has(a.id)) n.dead++;
+    if (isDead(a)) n.dead++;
     else if (isQuotaExhausted(a.id)) n.exhausted++;
     else if ((cooling.get(a.id) || 0) > now) n.cooling++;
     else n.noJwt++; // 未拉黑/未打标/未冷却却不在队列 → 快照里没有可解析的 plan JWT
@@ -145,10 +179,9 @@ async function hydrateMarks() {
 
 async function persistMark(accountId, entry) {
   try {
-    const st = await loadState();
-    const saved = st?.zcodeGatewayExhausted || {};
-    saved[accountId] = entry;
-    await saveState({ ...st, zcodeGatewayExhausted: saved });
+    await withState((st) => {
+      st.zcodeGatewayExhausted = { ...(st.zcodeGatewayExhausted || {}), [accountId]: entry };
+    });
   } catch { /* 持久化失败不影响内存态 */ }
 }
 
@@ -160,12 +193,9 @@ export async function clearQuotaMark(accountId) {
   quotaCache.delete(accountId);
   if (!dead.has(accountId)) cooling.delete(accountId);
   try {
-    const st = await loadState();
-    const saved = st?.zcodeGatewayExhausted;
-    if (saved && saved[accountId]) {
-      delete saved[accountId];
-      await saveState({ ...st, zcodeGatewayExhausted: saved });
-    }
+    await withState((st) => {
+      if (st?.zcodeGatewayExhausted?.[accountId]) delete st.zcodeGatewayExhausted[accountId];
+    });
   } catch { /* 持久化失败不影响内存态 */ }
 }
 
@@ -234,7 +264,14 @@ function readRawBody(req, limitBytes = 20 * 1024 * 1024) {
     let size = 0;
     req.on('data', (c) => {
       size += c.length;
-      if (size > limitBytes) { reject(Object.assign(new Error('request body too large'), { status: 413 })); req.destroy(); return; }
+      if (size > limitBytes) {
+        // 只 pause 不 destroy：destroy 会把 socket 打死，调用方随后写的 413 就发不出去，
+        // 客户端只看到 ECONNRESET，分不清「自己请求体写太大」和「网络断了」。
+        // 响应写完（res 'finish'）再由调用方收尾断开。
+        req.pause();
+        reject(Object.assign(new Error(`request body too large (limit ${Math.floor(limitBytes / 1024 / 1024)}MB)`), { status: 413 }));
+        return;
+      }
       chunks.push(c);
     });
     req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
@@ -242,16 +279,26 @@ function readRawBody(req, limitBytes = 20 * 1024 * 1024) {
   });
 }
 
-// 业务码可能包在 HTTP 200 里（上游对部分错误回 200 + {code}），两类都要看
+// 业务码可能包在 HTTP 200 里（上游对部分错误回 200 + {code}），两类都要看。
+// 裸数字必须加 \b 词边界：否则 "code":4010 会被当成 401 认证失败（→ 账号被永久拉黑），
+// 耗时 10050ms / request-id=11137 / 30071 也会被当成额度耗尽或验证码（→ 冷却 30 分钟 / 空跑一次验证码）。
 const isCaptchaError = (status, text) =>
-  status === 405 || /"code"\s*:\s*(3007|3012)|3007|3012|captcha|unusual activity/i.test(text);
+  status === 405 || /"code"\s*:\s*(3007|3012)\b|\b(3007|3012)\b|captcha|unusual activity/i.test(text);
 
 const isAuthError = (status, text) =>
-  status === 401 || /"code"\s*:\s*401|令牌已过期|验证不正确/.test(text);
+  status === 401 || /"code"\s*:\s*401\b|\b401\b|令牌已过期|验证不正确/.test(text);
 
 const isExhausted = (status, text) =>
-  status === 402 || /"code"\s*:\s*(1005|1113)|1113|1005|余额不足|无可用资源包|exceed quota|insufficient/i.test(text);
-
+  status === 402 || /"code"\s*:\s*(1005|1113)\b|\b(1113|1005)\b|余额不足|无可用资源包|exceed quota|insufficient/i.test(text);
+
+// 上游成功也会带 code（0 / 200），别把它们当业务错误——与 zcodeClient.businessOk 同一口径
+const BUSINESS_OK = new Set([0, 200]);
+/** 从上游 JSON 信封里取业务码；字符串数字（"3007"）也认，取不到返回 null */
+function businessCode(v) {
+  if (!v || typeof v !== 'object' || v.code === undefined || v.code === null) return null;
+  const n = Number(v.code);
+  return Number.isFinite(n) ? n : null;
+}
 // 组装与 ZCode 客户端真实流量一致的 plan 请求（镜像 R1 捕获，2026-09-29）
 function buildPlanRequest(rawBody, { token, userId }) {
   const ver = '3.14.3';
@@ -335,9 +382,11 @@ export function remoteAllowed(remote, allowList) {
 export async function handleGateway(req, res) {
   if (req.method !== 'POST') {
     res.writeHead(405, { 'Content-Type': 'application/json' });
-    return res.end(JSON.stringify({ error: 'POST /gateway/v1/messages（Anthropic /v1/messages 形态）' }));
+    return res.end(JSON.stringify({ error: 'POST /gateway/zcode/v1/messages（Anthropic /v1/messages 形态）' }));
   }
-  if (!(await gatewayEnabled())) {
+  // settings 一次读齐：开关 + 局域网鉴权共用，省掉一次 settings.json 磁盘读（热路径每请求都走）
+  const settings = await loadSettings();
+  if (settings.zcodeGateway !== true) {
     res.writeHead(503, { 'Content-Type': 'application/json' });
     return res.end(JSON.stringify({ error: 'ZCode 免费额度网关未开启（面板 → ZCode → 网关开关）' }));
   }
@@ -347,7 +396,6 @@ export async function handleGateway(req, res) {
   // 鉴权：本机回环免密；开局域网后仅白名单内 IP 免密直连（如 10Router 所在机器——zcode-free 本就是免授权供应商）
   const remote = (req.socket && req.socket.remoteAddress) || '';
   if (!isLoopbackRemote(remote)) {
-    const settings = await loadSettings();
     if (settings.zcodeGatewayLan !== true) {
       res.writeHead(403, { 'Content-Type': 'application/json' });
       return res.end(JSON.stringify({ error: '网关未允许局域网访问（面板 → ZCode → 接口设置）' }));
@@ -361,6 +409,8 @@ export async function handleGateway(req, res) {
   let rawBody;
   try { rawBody = await readRawBody(req); } catch (e) {
     res.writeHead(e.status || 400, { 'Content-Type': 'application/json' });
+    // 超限时请求体还没读完：先把 413 发出去，发完再断开，避免客户端继续往这灌数据
+    res.on('finish', () => req.destroy());
     return res.end(JSON.stringify({ error: e.message }));
   }
 
@@ -374,24 +424,27 @@ export async function handleGateway(req, res) {
   stats.calls += 1;
 
   const attempted = [];
+  // 客户端断开 → 取消当前上游请求。整个重试循环共用一个 controller/listener：
+  // 放在循环里每轮 new + req.on('close') 会在同一 req 上累积最多 MAX_ATTEMPTS 个监听器
+  // （MaxListenersExceededWarning + 泄漏）。
+  const clientAbort = new AbortController();
+  req.once('close', () => { if (!res.writableEnded) clientAbort.abort(); });
   // 首发不带验证码（客户端真实流量多数直过）；上游 3007/403 时求解并在此后的
   // 尝试上挂新 token（zcode-api 同策略）。provider 为 null（NAS/CLI）时首过路径依然可用。
   let captcha = null;
   for (let i = 0; i < Math.min(MAX_ATTEMPTS, queue.length * 2); i++) {
     const account = queue[i % queue.length];
     // 本轮已被打标/冷却/拉黑的号不再重打（第二圈只为验证码重试准备）
-    if (dead.has(account.id) || isQuotaExhausted(account.id) || (cooling.get(account.id) || 0) > Date.now()) continue;
+    if (isDead(account) || isQuotaExhausted(account.id) || (cooling.get(account.id) || 0) > Date.now()) continue;
     const label = account.name || account.uid || account.id;
     let token;
     try { token = claimToken(account); } catch (e) {
       attempted.push({ account: label, ok: false, error: e.message });
-      markDead(account.id);
+      markDead(account);
       continue;
     }
 
     let upstream;
-    const controller = new AbortController();
-    req.on('close', () => controller.abort());
     try {
       // 请求面完全镜像 ZCode 客户端真实流量（R1 捕获）：全套 identity 头 + 客户端
       // 系统提示词/提醒块/metadata 形状。验证码不预挂——服务端未风控时直过；
@@ -405,10 +458,11 @@ export async function handleGateway(req, res) {
         headers,
         body: built.body,
         timeoutMs: UPSTREAM_TIMEOUT_MS,
-        signal: controller.signal,
+        connectMs: UPSTREAM_CONNECT_MS,
+        signal: clientAbort.signal,
       });
     } catch (e) {
-      if (controller.signal.aborted) return; // 客户端先断了
+      if (clientAbort.signal.aborted) return; // 客户端先断了
       attempted.push({ account: label, ok: false, error: e.message });
       continue;
     }
@@ -421,7 +475,9 @@ export async function handleGateway(req, res) {
         const text = await upstream.text().catch(() => '');
         let v;
         try { v = JSON.parse(text); } catch { v = null; }
-        if (v && typeof v.code === 'number') {
+        const code = businessCode(v);
+        // 上游成功信封也可能带 code（0 / 200），那不是业务错误；字符串数字（"3007"）同样要拦
+        if (code !== null && !BUSINESS_OK.has(code)) {
           if (isCaptchaError(200, text)) {
             invalidateCaptcha();
             attempted.push({ account: label, ok: false, error: '验证码被拒（200 业务码）', captcha: true });
@@ -429,9 +485,9 @@ export async function handleGateway(req, res) {
             continue;
           }
           if (isAuthError(200, text)) {
-            markDead(account.id);
+            markDead(account);
             attempted.push({ account: label, ok: false, error: 'JWT 已失效，账号拉黑' });
-            logger.info('ZCODE-GW', `${label} JWT 失效（200 业务码）`);
+            logger.warn('ZCODE-GW', `${label} JWT 失效（200 业务码）`);
             continue;
           }
           if (isExhausted(200, text)) {
@@ -486,7 +542,8 @@ export async function handleGateway(req, res) {
           }
         }
       } catch (e) {
-        logger.warn('ZCODE-GW', `流式转发中断：${e.message}`);
+        // 客户端主动断开（点停止/换一句）就会在这里结束——属正常收尾，不是故障，降为 debug
+        logger.debug('ZCODE-GW', `流式转发中断：${e.message}`);
       }
       res.end();
       return true;
@@ -497,15 +554,15 @@ export async function handleGateway(req, res) {
     if (isCaptchaError(upstream.status, text)) {
       invalidateCaptcha();
       attempted.push({ account: label, ok: false, error: `验证码被拒（${upstream.status}）`, captcha: true });
-      logger.info('ZCODE-GW', `${label} 验证码被拒 (${formatUpstreamError(upstream.status, text)})`);
+      logger.warn('ZCODE-GW', `${label} 验证码被拒 (${formatUpstreamError(upstream.status, text)})`);
       try { captcha = await ensureCaptcha(true); } catch (e) {
-        logger.info('ZCODE-GW', `验证码重解失败：${e.message}`);
+        logger.warn('ZCODE-GW', `验证码重解失败：${e.message}`);
         captcha = null;
       }
       continue;
     }
     if (isAuthError(upstream.status, text)) {
-      markDead(account.id);
+      markDead(account);
       attempted.push({ account: label, ok: false, error: 'JWT 已失效，账号拉黑（重新登录后再导入）' });
       logger.debug('ZCODE-GW', `${label} JWT 失效，拉黑`);
       continue;
@@ -530,7 +587,8 @@ export async function handleGateway(req, res) {
     return true;
   }
 
-  logger.warn('ZCODE-GW', `全部 ${attempted.length} 次尝试失败`);
+  const failedDetail = summarizeAttempts(attempted);
+  logger.warn('ZCODE-GW', `全部 ${attempted.length} 次尝试失败${failedDetail ? '：' + failedDetail : ''}（下一请求自动重试）`);
   res.writeHead(502, { 'Content-Type': 'application/json' });
   res.end(JSON.stringify({ error: 'ZCode 网关：所有账号尝试均失败', attempts: attempted }));
   return true;
@@ -562,9 +620,9 @@ export async function gatewayStatus() {
       .map((a) => ({ id: a.id, name: a.name || a.uid || a.id, remaining: quotaCache.get(a.id)?.remaining ?? 0 })),
     accounts: all.length,
     accountsWithJwt: withJwt,
-    cooling: all.filter((a) => (cooling.get(a.id) || 0) > now).map((a) => a.name || a.uid || a.id),
-    dead: [...dead],
-    endpoint: '/gateway/v1/messages',
+    cooling: all.filter((a) => !isDead(a) && (cooling.get(a.id) || 0) > now).map((a) => a.name || a.uid || a.id),
+    dead: all.filter((a) => isDead(a)).map((a) => a.name || a.uid || a.id),
+    endpoint: '/gateway/zcode/v1/messages',
     note: hasCaptcha ? null : '需要桌面版 CreditDaddy（隐藏窗口验证码），纯 CLI / NAS 环境不可用',
   };
 }

package/src/zcodePlanShape.json

@@ -16,14 +16,14 @@
   },
   {
    "type": "text",
-   "text": "\n\n# Communicating with the user\n\nYour text output is what the user reads; they usually can't see your thinking or the raw tool results. Write it for a teammate who stepped away and is catching up, not for a log file: they don't know the codenames or shorthand you created along the way, and they didn't watch your process unfold. Before your first tool call, say in a sentence what you're about to do; while working, give brief updates when you find something load-bearing or change direction.\n\nText you write between tool calls may not be shown to the user. Everything the user needs from this turn — answers, summaries, findings, conclusions, deliverables — must be in the final text message of your turn, with no tool calls after it. Keep text between tool calls to brief status notes. If something important appeared only mid-turn or in your thinking, restate it in that final message.\n\nLead with the outcome. Your first sentence after finishing should answer \"what happened\" or \"what did you find\" — the thing the user would ask for if they said \"just give me the TLDR.\" Supporting detail and reasoning come after, for readers who want them.\n\nBeing readable and being concise are different things, and readable matters more. If the user has to reread your summary or ask you to explain, any time saved by brevity is gone. The way to keep output short is to be selective about what you include (drop details that don't change what the reader would do next), not to compress the writing into fragments, abbreviations, arrow chains like `A → B → fails`, or jargon. What you do include, write in complete sentences with the technical terms spelled out. Don't make the reader cross-reference labels or numbering you invented earlier; say what you mean in place.\n\nMatch the response to the question: a simple question gets a direct answer in prose, not headers and sections. Use tables only for short enumerable facts, with explanations in the surrounding prose rather than the cells. Calibrate to the user — a bit tighter for an expert, more explanatory for someone newer.\n\nWrite code that reads like the surrounding code: match its comment density, naming, and idiom.\nOnly write a code comment to state a constraint the code itself can't show — never to say where it came from, what the next line does, or why your change is correct; that's you talking to the reviewer, not the next reader, and it's noise the moment the PR merges.\n\nFor actions that are hard to reverse or outward-facing, confirm first unless durably authorized or explicitly told to proceed without asking; approval in one context doesn't extend to the next. Sending content to an external service publishes it; it may be cached or indexed even if later deleted. Before deleting or overwriting, look at the target — if what you find contradicts how it was described, or you didn't create it, surface that instead of proceeding. Report outcomes faithfully: if tests fail, say so with the output; if a step was skipped, say that; when something is done and verified, state it plainly without hedging.\n\n# Environment\nYou have been invoked in the following environment:\n- Primary working directory: C:\\Users\\YangYu\\zproxy-test\n- Is a git repository: no\n- Platform: win32\n- Shell: bash.exe\n- OS Version: win32 10.0.19045 x64\n- You are powered by the model named bigmodel-api/glm-5.3-flash.\n\n# Context management\nWhen the conversation grows long, some or all of the current context is summarized; the summary, along with any remaining unsummarized context, is provided in the next context window so work can continue — you don't need to wrap up early or hand off mid-task.\n\nWhen you have enough information to act, act. Do not re-derive facts already established in the conversation, re-litigate a decision the user has already made, or narrate options you will not pursue. If you are weighing a choice, give a recommendation, not an exhaustive survey\n\nYou are operating autonomously. The user is not watching in real time and cannot answer questions mid-task, so asking 'Want me to…?' or 'Shall I…?' will block the work. For reversible actions that follow from the original request, proceed without asking. Stop only for destructive actions or genuine scope changes the user must decide. Offering follow-ups after the task is done is fine; asking permission before doing the work is not.\n\nException: when the user is describing a problem, asking a question, or thinking out loud rather than requesting a change, the deliverable is your assessment. Report your findings and stop. Don't apply a fix until they ask for one.\n\nBefore ending your turn, check your last paragraph. If it is a plan, an analysis, a question, a list of next steps, or a promise about work you have not done ('I'll…', 'let me know when…'), do that work now with tool calls. That includes retrying after errors and gathering missing information yourself. Do not stop because the context or session is long. End your turn only when the task is complete or you are blocked on input only the user can provide.\n\nBefore running a command that changes system state — restarts, deletes, config edits — check that the evidence actually supports that specific action. A signal that pattern-matches to a known failure may have a different cause.",
+   "text": "\n\n# Communicating with the user\n\nYour text output is what the user reads; they usually can't see your thinking or the raw tool results. Write it for a teammate who stepped away and is catching up, not for a log file: they don't know the codenames or shorthand you created along the way, and they didn't watch your process unfold. Before your first tool call, say in a sentence what you're about to do; while working, give brief updates when you find something load-bearing or change direction.\n\nText you write between tool calls may not be shown to the user. Everything the user needs from this turn — answers, summaries, findings, conclusions, deliverables — must be in the final text message of your turn, with no tool calls after it. Keep text between tool calls to brief status notes. If something important appeared only mid-turn or in your thinking, restate it in that final message.\n\nLead with the outcome. Your first sentence after finishing should answer \"what happened\" or \"what did you find\" — the thing the user would ask for if they said \"just give me the TLDR.\" Supporting detail and reasoning come after, for readers who want them.\n\nBeing readable and being concise are different things, and readable matters more. If the user has to reread your summary or ask you to explain, any time saved by brevity is gone. The way to keep output short is to be selective about what you include (drop details that don't change what the reader would do next), not to compress the writing into fragments, abbreviations, arrow chains like `A → B → fails`, or jargon. What you do include, write in complete sentences with the technical terms spelled out. Don't make the reader cross-reference labels or numbering you invented earlier; say what you mean in place.\n\nMatch the response to the question: a simple question gets a direct answer in prose, not headers and sections. Use tables only for short enumerable facts, with explanations in the surrounding prose rather than the cells. Calibrate to the user — a bit tighter for an expert, more explanatory for someone newer.\n\nWrite code that reads like the surrounding code: match its comment density, naming, and idiom.\nOnly write a code comment to state a constraint the code itself can't show — never to say where it came from, what the next line does, or why your change is correct; that's you talking to the reviewer, not the next reader, and it's noise the moment the PR merges.\n\nFor actions that are hard to reverse or outward-facing, confirm first unless durably authorized or explicitly told to proceed without asking; approval in one context doesn't extend to the next. Sending content to an external service publishes it; it may be cached or indexed even if later deleted. Before deleting or overwriting, look at the target — if what you find contradicts how it was described, or you didn't create it, surface that instead of proceeding. Report outcomes faithfully: if tests fail, say so with the output; if a step was skipped, say that; when something is done and verified, state it plainly without hedging.\n\n# Environment\nYou have been invoked in the following environment:\n- Primary working directory: C:\\Users\\<user>\\<workspace>\n- Is a git repository: no\n- Platform: win32\n- Shell: bash.exe\n- OS Version: win32 10.0.19045 x64\n- You are powered by the model named bigmodel-api/glm-5.3-flash.\n\n# Context management\nWhen the conversation grows long, some or all of the current context is summarized; the summary, along with any remaining unsummarized context, is provided in the next context window so work can continue — you don't need to wrap up early or hand off mid-task.\n\nWhen you have enough information to act, act. Do not re-derive facts already established in the conversation, re-litigate a decision the user has already made, or narrate options you will not pursue. If you are weighing a choice, give a recommendation, not an exhaustive survey\n\nYou are operating autonomously. The user is not watching in real time and cannot answer questions mid-task, so asking 'Want me to…?' or 'Shall I…?' will block the work. For reversible actions that follow from the original request, proceed without asking. Stop only for destructive actions or genuine scope changes the user must decide. Offering follow-ups after the task is done is fine; asking permission before doing the work is not.\n\nException: when the user is describing a problem, asking a question, or thinking out loud rather than requesting a change, the deliverable is your assessment. Report your findings and stop. Don't apply a fix until they ask for one.\n\nBefore ending your turn, check your last paragraph. If it is a plan, an analysis, a question, a list of next steps, or a promise about work you have not done ('I'll…', 'let me know when…'), do that work now with tool calls. That includes retrying after errors and gathering missing information yourself. Do not stop because the context or session is long. End your turn only when the task is complete or you are blocked on input only the user can provide.\n\nBefore running a command that changes system state — restarts, deletes, config edits — check that the evidence actually supports that specific action. A signal that pattern-matches to a known failure may have a different cause.",
    "cache_control": {
     "type": "ephemeral"
    }
   }
  ],
- "reminderText": "<system-reminder>As you answer the user's questions, you can use the following context:\n# currentDate\nToday's date is 2026-09-29.\n\n      IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task.</system-reminder>",
+ "reminderText": "<system-reminder>As you answer the user's questions, you can use the following context:\n# currentDate\nToday's date is YYYY-MM-DD.\n\n      IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task.</system-reminder>",
  "metadata": {
-  "user_id": "{\"account_uuid\":\"\",\"session_id\":\"ses_f0a670f7b1f1\"}"
+  "user_id": "{\"account_uuid\":\"\",\"session_id\":\"ses_\"}"
  }
 }