mingdao-harness 0.4.4 → 0.4.6

package/src/pricing.js

@@ -7,6 +7,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { modelPreset } from './models.js';
+import { atomicWriteFileSync } from './atomic-write.js';
 import { mingdaoHome } from './config.js';
 
 // 内置价格表的数据时点（定价可能调整，配置覆盖可随时更新）
@@ -63,7 +64,7 @@ export async function refreshPricingFromSource(cfg) {
   }
   const file = pricingFilePath();
   fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, JSON.stringify({ fetchedAt: Date.now(), source: src, models }, null, 2));
+  atomicWriteFileSync(file, JSON.stringify({ fetchedAt: Date.now(), source: src, models }, null, 2));
   extCache = { mtime: -1, ttlDays: 7, data: null, stale: false };
   const names = Object.keys(models).join('、');
   return { ok: true, lines: ['✓ 价格表已刷新（' + names + '），TTL 内费用估算/护栏/避峰自动跟随'] };
@@ -114,15 +115,37 @@ export function isPeakHour(date = new Date()) {
   }
 }
 
-// —— 北京时间墙钟工具（避峰调度/费用护栏按天统计用，零依赖 Intl） ——
-export function beijingParts(date = new Date()) {
-  let tz = 'Asia/Shanghai';
+// —— 计价时区墙钟工具（避峰调度/费用护栏按天统计用，零依赖 Intl） ——
+// v0.4.6：抽出「生效时区」解析（坏配置回退 Asia/Shanghai，绝不让计费/护栏崩溃）。
+function activeTimezone() {
   try {
-    tz = peakCfg().timezone;
+    const tz = peakCfg().timezone;
     new Intl.DateTimeFormat('en-US', { timeZone: tz }).format(); // 非法时区在此抛错
+    return tz;
   } catch {
-    tz = 'Asia/Shanghai'; // 审计 B1：坏时区配置回退北京时间，绝不让计费/护栏崩溃
+    return 'Asia/Shanghai';
   }
+}
+
+/** @param {Date} date @param {string} tz 该时刻在 tz 的墙钟与 UTC 的偏移（毫秒） */
+function tzOffsetMs(date, tz) {
+  const parts = new Intl.DateTimeFormat('en-US', {
+    timeZone: tz,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    hourCycle: 'h23',
+  }).formatToParts(date);
+  const g = (/** @type {any} */ t) => Number(parts.find((/** @type {any} */ p) => p.type === t)?.value);
+  const asUtc = Date.UTC(g('year'), g('month') - 1, g('day'), g('hour'), g('minute'), g('second'));
+  return asUtc - Math.floor(date.getTime() / 1000) * 1000;
+}
+
+export function beijingParts(date = new Date()) {
+  const tz = activeTimezone();
   const parts = new Intl.DateTimeFormat('en-US', {
     timeZone: tz,
     year: 'numeric',
@@ -137,12 +160,24 @@ export function beijingParts(date = new Date()) {
   return { year: g('year'), month: g('month'), day: g('day'), hour: g('hour'), minute: g('minute'), second: g('second') };
 }
 
-// 北京时间墙钟 → Date（UTC+8）
+// 时区墙钟 → Date。
+// v0.4.6 P3 修复：此前硬编码 `- 8h`（只管 Asia/Shanghai），而 beijingParts() 用的是可配置的
+// `pricing.timezone`——用户按文档覆盖时区后，日界（费用护栏按自然日累计）与 --offpeak 顺延
+// 会同时算错（美东实测错 12 小时：日界落在当地中午、避峰时刻整体偏移）。
+// 现按目标时区真实偏移换算，用「两遍法」处理含夏令时的时区。
 /**
  * @param {any} parts
  */
 export function beijingToDate(parts) {
-  return new Date(Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second) - 8 * 3600 * 1000);
+  const tz = activeTimezone();
+  const guessMs = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+  let ts = guessMs;
+  for (let i = 0; i < 3; i++) {
+    const next = guessMs - tzOffsetMs(new Date(ts), tz);
+    if (next === ts) break;
+    ts = next;
+  }
+  return new Date(ts);
 }
 
 // 避峰顺延：当前处于高峰 → 顺延到该高峰段的结束整点（即最近一个闲时起点）
@@ -180,7 +215,10 @@ export const BATCH_DISCOUNT = 0.5;
  */
 export function estimateBatchCost(modelName, promptTokens, completionTokens) {
   const pricing = effectivePricing(modelName);
-  if (!pricing) return 0;
+  // P0-4 同口径（v0.4.6）：无价模型返 null 而非 0。Batch 路径此前恒返 0，导致
+  // ① `--max-cost` 预算拦截对「无内置/外部/覆盖价格」的模型静默失效（0 > maxCost 恒 false），
+  // ② /cost 把未知费用显示成 ≈¥0.00000 冒充免费。与 estimateCost 的语义保持一致。
+  if (!pricing) return null;
   return ((promptTokens * pricing.offpeak.input + completionTokens * pricing.offpeak.output) / 1e6) * BATCH_DISCOUNT;
 }
 
@@ -214,13 +252,32 @@ function pricingOverrides() {
 /**
  * @param {any} modelName
  */
+// P0-4（v0.4.5）：判断模型是否有价格数据（内置定价或外部定价或 overrides）——
+// 无价模型 estimateCost 恒 0，费用护栏/仪表盘/分账静默失真，必须显式暴露给调用方告警。
+export function hasPricing(/** @type {any} */ modelName) {
+  return Boolean(modelName && effectivePricing(modelName));
+}
+
+/** @param {any} modelName */
 function effectivePricing(modelName) {
   const preset = modelPreset(modelName);
   const ext = externalPricing().data?.models?.[modelName] || null;
-  if (!preset?.pricing && !ext) return null;
-  const base = ext || preset?.pricing || null;
-  if (!base) return null;
   const over = pricingOverrides()[modelName] || {}; // 审计 Q3：mtime 缓存替代每轮读盘
+  const base = ext || preset?.pricing || null;
+  // P0 修复（v0.4.6）：overrides 本身就是一条价格来源，必须与 ext/preset 等价对待。
+  // 此前「先判 base 是否存在」就 return null，导致用户按护栏提示给 gpt-5 / 本地模型配的
+  // config.pricing.overrides 完全不生效：hasPricing=false → estimateCost=null →
+  // cache-stats 记 cost=null（当 0 累计）→ todayCost 看不到这些消费 → 护栏永不拦截。
+  // 内置 12 个模型里只有 3 个 DeepSeek 带 pricing，即「每日上限防超支」对另外 9 个
+  // 以及全部动态发现/自定义模型形同虚设，而护栏给出的补救办法恰是这条不生效的路径。
+  const hasOver = Object.keys(over).length > 0;
+  if (!base && !hasOver) return null;
+  // 仅靠 overrides 供价时，要求 input 与 output 都是有限正数：半张价格表会把缺失的一侧
+  // 静默当成 0（输出免费 / 命中免费），比「未知（null）」更危险——宁可报无价并告警。
+  if (!base) {
+    const ok = (/** @type {any} */ v) => Number.isFinite(Number(v)) && Number(v) > 0;
+    if (!ok(over.input) || !ok(over.output)) return null;
+  }
   /** @type {(b: any, o?: any) => { input: number, output: number, cacheHit: number }} */
   const merge = (b, o = {}) => ({
     input: Number(o.input ?? b?.input ?? 0),
@@ -236,8 +293,8 @@ function effectivePricing(modelName) {
     cacheHit: over.peak?.cacheHit ?? over.cacheHit,
   };
   return {
-    offpeak: merge(base.offpeak || base, over),
-    peak: merge(base.peak || base.offpeak || base, peakOver),
+    offpeak: merge(base?.offpeak || base || {}, over),
+    peak: merge(base?.peak || base?.offpeak || base || {}, peakOver),
   };
 }
 
@@ -250,7 +307,9 @@ function effectivePricing(modelName) {
  */
 export function estimateCost(modelName, promptTokens, completionTokens, cache = null, date = new Date()) {
   const pricing = effectivePricing(modelName);
-  if (!pricing) return 0;
+  // P0-4（v0.4.5）：无价返 null 而非 0——0 与「未知」语义完全混淆（0 被当作「免费/没花钱」），
+  // 下游护栏/分账/仪表盘据此静默失真。返回 null 强制调用方显式区分「未知」与「免费（0）」（技术评估 P0-4）。
+  if (!pricing) return null;
   const price = isPeakHour(date) ? pricing.peak : pricing.offpeak;
   if (cache && Number.isFinite(cache.hit) && Number.isFinite(cache.miss)) {
     const hitPrice = price.cacheHit ?? 0;
@@ -268,10 +327,11 @@ export function estimateCost(modelName, promptTokens, completionTokens, cache =
  * @param {any} [usage]
  */
 export function estimateCostLabel(modelName, promptTokens, completionTokens, usage = null) {
-  const pricing = effectivePricing(modelName);
-  if (!pricing) return '';
   const cache = cacheSplit(usage);
-  const yuan = estimateCost(modelName, promptTokens, completionTokens, cache).toFixed(5);
+  const c = estimateCost(modelName, promptTokens, completionTokens, cache);
+  // P0-4（v0.4.5）：无价返 null → 标签置空（不显示「≈¥0.0000」冒充免费）
+  if (c == null) return '';
+  const yuan = c.toFixed(5);
   const hitPart =
     cache && cache.hit + cache.miss > 0 ? ` · 缓存命中 ${(cache.rate * 100).toFixed(0)}%` : ' · 未计缓存折扣';
   return ` ≈¥${yuan}（${isPeakHour() ? '高峰' : '闲时'}${hitPart}）${pricingDataStale() ? ' · ⚠ 价格表过期，运行 mingdao update --pricing 刷新' : ''}`;

package/src/providers/index.js

@@ -14,21 +14,42 @@ import { pathToFileURL } from 'node:url';
 import { chat as openaiChat } from './openai-compatible.js';
 import { modelPreset, providerPreset } from '../models.js';
 import { mingdaoHome } from '../config.js';
-import { resolveApiKey } from '../credentials.js';
+import { resolveApiKey, getStoredKey } from '../credentials.js';
 import { isLocalBaseUrl } from '../model-caps.js';
 
 export function resolveProviderConfig(/** @type {any} */ cfg, /** @type {any} */ modelName) {
   // 自定义模型（config.customModels，WebUI 可增删改）：优先于内置预设
   const cm = cfg?.customModels?.[modelName];
   if (cm) {
-    const envKeys = [cm.envKey, 'MINGDAO_API_KEY'].filter(Boolean);
-    const apiKey = resolveApiKey(cfg, `custom:${modelName}`, envKeys[0]) || resolveApiKey(cfg, 'custom', envKeys[0]);
+    // P1 修复（v0.4.6）：自定义模型的密钥解析不得成为「任意环境变量外泄」通道。
+    // 此前 envKeys = [cm.envKey, 'MINGDAO_API_KEY']，而 envKey 与 baseUrl 都完全由调用方指定
+    // （WebUI 的 addCustom 接受任意输入）——于是任何能加一个自定义模型的人，都能把宿主环境里的
+    // 任意变量（AWS_SECRET_ACCESS_KEY / GITHUB_TOKEN / …）当作 Bearer 发到自己的端点；
+    // 即使不填 envKey 也会回落 MINGDAO_API_KEY，把用户的主密钥送出去。两条路一起封：
+    //   ① envKey 必须是「像模型密钥」的名字（大写、以 _API_KEY/_KEY 结尾、不含 SECRET/TOKEN/…）；
+    //   ② 未声明（或被拒）时不读任何环境变量，只认凭证库——环境变量必须被显式点名才可用。
+    const rawEnvKey = String(cm.envKey || '').trim();
+    const safeEnvKey =
+      /^[A-Z][A-Z0-9_]{2,63}$/.test(rawEnvKey) &&
+      /(_API_KEY|_KEY)$/.test(rawEnvKey) &&
+      !/(SECRET|TOKEN|PASSWORD|CREDENTIAL|PRIVATE|PASSWD)/.test(rawEnvKey)
+        ? rawEnvKey
+        : '';
+    if (rawEnvKey && !safeEnvKey) {
+      console.warn(
+        `[MingDao] 自定义模型 ${modelName} 的 envKey「${rawEnvKey}」不是合法的模型密钥变量名，已忽略。` +
+          `如需用环境变量提供密钥，请用形如 MY_GATEWAY_API_KEY 的名字；否则请用 mingdao key set custom:${modelName} 存入凭证库。`
+      );
+    }
+    const envVal = safeEnvKey ? process.env[safeEnvKey] || '' : '';
+    const storedKey = getStoredKey(`custom:${modelName}`) || getStoredKey('custom') || '';
+    const apiKey = envVal || storedKey || '';
     return {
       name: `custom:${modelName}`,
       kind: 'openai-compatible',
       baseUrl: cm.baseUrl || cfg?.baseUrl || '',
       apiKey,
-      envHint: envKeys[0] || 'MINGDAO_API_KEY',
+      envHint: safeEnvKey || `custom:${modelName}`,
       isCustom: true,
       modelName,
     };
@@ -92,14 +113,20 @@ export async function createProvider(/** @type {any} */ cfg, /** @type {any} */
     config: pc,
     async chat(/** @type {any} */ opts) {
       let attempt = 0;
+      // P1-7（v0.4.5）：总量护栏提到重试循环外层——此前每 attempt 重建 totalTimer，重试序列最坏
+      // 放大 retries+1 倍（本地 3×30min=90min）。总时长覆盖整个重试序列，单次首 token/流式空闲仍按 attempt 计。
+      let totalExpired = false;
+      let currentAc = /** @type {AbortController | null} */ (null);
+      const totalTimer = setTimeout(() => {
+        totalExpired = true;
+        try {
+          currentAc?.abort(new Error(`请求总时长超限（${Math.round(totalMs / 1000)}s），已中断`));
+        } catch {}
+      }, totalMs);
       for (;;) {
         const ac = new AbortController();
-        let timedOut = false; // 审计 P2-6：用标志而非 name/字符串匹配识别内部超时
-        // 总量护栏：整次请求（prefill+生成）的绝对上限
-        const totalTimer = setTimeout(() => {
-          timedOut = true;
-          ac.abort(new Error(`请求总时长超限（${Math.round(totalMs / 1000)}s），已中断`));
-        }, totalMs);
+        currentAc = ac;
+        let timedOut = false; // 审计 P2-6：用标志而非 name/字符串匹配识别内部超时（首 token/流式空闲）
         // 首 token 等待：prefill 阶段无任何帧到达即断（覆盖长上下文慢 prefill）
         let firstTokenTimer = /** @type {ReturnType<typeof setTimeout> | null} */ (setTimeout(() => {
           timedOut = true;
@@ -125,6 +152,7 @@ export async function createProvider(/** @type {any} */ cfg, /** @type {any} */
         const onUserAbort = () => ac.abort(opts.signal?.reason);
         if (opts.signal?.aborted) onUserAbort();
         else opts.signal?.addEventListener('abort', onUserAbort, { once: true });
+        let leaving = true; // 本次 attempt 是否退出（成功/不再重试）；将重试则置 false，总量计时器保留覆盖下一 attempt
         try {
           return await openaiChat({
             ...opts,
@@ -135,9 +163,11 @@ export async function createProvider(/** @type {any} */ cfg, /** @type {any} */
             onActivity,
           });
         } catch (err) {
-          // 内部超时经 abort 抛出，用标志识别（审计 P2-6）；用户 Ctrl+C 的中断不算超时、不重试
-          const transient = (timedOut && !opts.signal?.aborted) || isTransient(err);
+          // 内部超时经 abort 抛出，用标志识别（审计 P2-6）；用户 Ctrl+C 的中断不算超时、不重试。
+          // 总量超时（totalExpired）覆盖整个序列，超了直接抛不再重试。
+          const transient = !totalExpired && ((timedOut && !opts.signal?.aborted) || isTransient(err));
           if (!transient || attempt >= retries) throw err;
+          leaving = false; // 将重试：本次不退出，总量计时器继续覆盖下一 attempt
           attempt += 1;
           // 首 token 等待超时通常不是偶发网络抖动（是模型/上下文慢），重试价值低但保留一次机会；
           // 其余瞬态错误指数退避 + 尊重 Retry-After（评估 P3-1）：基础 1s/2s，封顶 30s
@@ -147,7 +177,7 @@ export async function createProvider(/** @type {any} */ cfg, /** @type {any} */
           backoff = Math.min(backoff, 30000);
           await sleep(backoff);
         } finally {
-          clearTimeout(totalTimer);
+          if (leaving) clearTimeout(totalTimer); // 成功/最终失败即清——避免悬挂 totalMs 计时器（每请求一个）
           if (firstTokenTimer) clearTimeout(firstTokenTimer);
           if (idleTimer) clearTimeout(idleTimer);
           opts.signal?.removeEventListener('abort', onUserAbort);

package/src/providers/openai-compatible.js

@@ -6,6 +6,20 @@
  * @typedef {Error & { status?: number, headers?: Headers }} ApiError
  */
 
+// 部分网关/本地推理框架在拒绝请求（如 507 memory_refusal）时不回非 2xx，而是回
+// 200 + {"error":{"code":507,"message":"memory_refusal"}}，或 SSE 首帧夹带 error 对象。
+// 若不识别，会被当作「空输出」吞掉，误报成「模型本轮没有输出正文。」（MacBook 本地 mtplx 507 根因）。
+function extractStreamError(/** @type {any} */ json) {
+  const err = json?.error;
+  if (!err) return null;
+  const code = Number(err?.code || err?.status_code || err?.status || 0);
+  const msg = String(err?.message || err?.type || '模型返回错误');
+  /** @type {ApiError} */
+  const e = new Error(`[流式响应错误${code ? ' ' + code : ''}] ${msg}`);
+  if (code) e.status = code;
+  return e;
+}
+
 export async function chat(/** @type {any} */ { baseUrl, apiKey, model, messages, tools, temperature, maxTokens, signal, onDelta, onActivity, includeUsage = true, responseFormat, reasoningEffort }) {
   const url = String(baseUrl).replace(/\/+$/, '') + '/chat/completions';
   const payload = /** @type {Record<string, any>} */ ({ model, messages });
@@ -68,6 +82,8 @@ export async function chat(/** @type {any} */ { baseUrl, apiKey, model, messages
 }
 
 export function parseNonStream(/** @type {any} */ json, /** @type {any} */ onDelta) {
+  const se = extractStreamError(json);
+  if (se) throw se;
   const choice = json?.choices?.[0];
   const msg = choice?.message ?? {};
   if (msg.content) onDelta?.({ text: msg.content });
@@ -113,6 +129,9 @@ export async function parseStream(/** @type {any} */ body, /** @type {any} */ on
     } catch {
       return;
     }
+    // 200 流里夹带 error 帧（本地内存拒绝等）：立即上抛，不当作空输出吞掉
+    const se = extractStreamError(json);
+    if (se) throw se;
     // 注意：DeepSeek/OpenAI 流式最后一块常是 usage-only（choices 为空），必须先取 usage 再判 choices
     if (json.usage) usage = json.usage;
     const choice = json?.choices?.[0];
@@ -147,9 +166,31 @@ export async function parseStream(/** @type {any} */ body, /** @type {any} */ on
     if (choice.finish_reason) finish = choice.finish_reason;
   };
 
+  // P1-6（v0.4.5）：[DONE] 后不再无限等待网关关流——此前外层 for 继续 read 至流关闭，
+  // 部分网关/代理在 [DONE] 后不主动断开会挂到 streamIdleMs(120s)。但部分网关在 [DONE] 之后
+  // 才发 usage-only 终包（且末帧常不带换行），直接退出会丢 usage。因此进入「有界排空」：
+  // 继续读残余帧，每次 read 用短超时兜底，超时或流关闭即停止——usage 尾帧仍被捕获，
+  // 正常流在 [DONE] 后立即关流，Promise.race 随即以 done 返回，不增加延迟。
+  const DRAIN_TIMEOUT_MS = 500;
+  const readDrain = async () => {
+    let t;
+    const timer = new Promise((resolve) => {
+      t = setTimeout(() => resolve({ done: false, value: null, timedOut: true }), DRAIN_TIMEOUT_MS);
+    });
+    try {
+      return await Promise.race([reader.read(), timer]);
+    } finally {
+      clearTimeout(t);
+    }
+  };
   for (;;) {
-    const { done, value } = await reader.read();
+    const { done, value } = await (doneFlag ? readDrain() : reader.read());
     if (done) break;
+    if (value == null) {
+      // 排空超时：不再等，取消 reader 释放连接（防火墙/网关持流不关的场景）
+      reader.cancel().catch(() => {});
+      break;
+    }
     buf += decoder.decode(value, { stream: true });
     let nl;
     while ((nl = buf.indexOf('\n')) >= 0) {

package/src/redact.js

@@ -13,6 +13,11 @@ export function redactSecrets(/** @type {any} */ text) {
   s = s.replace(/(Authorization\s*:\s*Bearer\s+)[^\s"',}]+/gi, '$1***');
   s = s.replace(/((?:api[_-]?key|token|secret|password|passwd|access_token)\s*[=:]\s*["']?)[^\s"',}]+/gi, '$1***');
   s = s.replace(/([?&](?:key|token|secret|api_key|access_token)=)[^&\s"']+/gi, '$1***');
+  // P2 修复（v0.4.6）：URL 内嵌凭据（scheme://user:pass@host）——本文件头注释一直声称覆盖，
+  // 但规则里从来没有这一条：`git clone https://oauth2:glpat-xxx@host/repo`、
+  // `postgres://user:pw@host/db` 这类命令行会**原样**落入 ~/.mingdao/audit.jsonl
+  // （bash/fetch 的完整参数写审计）与 diagnose 诊断包。只掩码密码段，保留用户名与主机便于排查。
+  s = s.replace(/(:\/\/[^/\s:@]{1,64}:)[^/\s@]{1,256}@/g, '$1***@');
   return s;
 }
 

package/src/schedule.js

@@ -171,7 +171,10 @@ export function removeSchedule(/** @type {any} */ home, /** @type {any} */ id) {
       }
     }
     // 正在跑的 worker 同步停止，避免成孤儿继续执行
-    if (job.lastTaskId && isRunningTask(home, job.lastTaskId)) killTask(home, job.lastTaskId);
+    // P0-2（v0.4.5）：killTask 失败不应阻断「删除」这一更强用户意图——包 try/catch 保证删除照常
+    try {
+      if (job.lastTaskId && isRunningTask(home, job.lastTaskId)) killTask(home, job.lastTaskId);
+    } catch {}
     try {
       fs.unlinkSync(path.join(scheduleDir(home), id + '.json'));
     } catch {}
@@ -192,7 +195,10 @@ export function pauseSchedule(/** @type {any} */ home, /** @type {any} */ id) {
         } catch {}
       }
     }
-    if (job.lastTaskId && isRunningTask(home, job.lastTaskId)) killTask(home, job.lastTaskId);
+    // P0-2（v0.4.5）：killTask 失败不应阻断「暂停」的状态写
+    try {
+      if (job.lastTaskId && isRunningTask(home, job.lastTaskId)) killTask(home, job.lastTaskId);
+    } catch {}
     writeSchedule(home, { ...job, status: 'paused', pid: null, lastTaskId: null });
     return true;
   });
@@ -354,6 +360,15 @@ export async function runSleeper(/** @type {any} */ home, /** @type {any} */ id)
 
   const wait = (/** @type {any} */ ms) => new Promise((r) => setTimeout(r, ms));
 
+  // P1-15（v0.4.5）：标记 running 前加锁并复查 paused——此前锁外 writeSchedule({...cur,'running'})
+  // 与 pauseSchedule 锁内写 paused 交错时，running 会覆盖 pause（任务继续触发，pause 语义失效）。
+  const markRunning = () => withFileLockSync(path.join(scheduleDir(home), '.lock'), () => {
+    const c = readSchedule(home, id);
+    if (!c || c.status === 'paused') return false; // 已删除或已暂停：不覆盖、不再触发
+    writeSchedule(home, { ...c, status: 'running' });
+    return true;
+  });
+
   // 依赖检查：支持两种依赖——调度任务 id（chain 编排）或后台任务 id（mingdao run 输出）
   async function depsSatisfied(/** @type {any} */ deps) {
     for (const dep of deps) {
@@ -376,8 +391,11 @@ export async function runSleeper(/** @type {any} */ home, /** @type {any} */ id)
     // 顺延到最近闲时起点（12:00 / 18:00）执行，输入价省 50%
     if (job.offpeak && isPeakHour(new Date())) {
       const defer = deferToOffpeak(new Date());
-      const curN = readSchedule(home, id);
-      if (curN) writeSchedule(home, { ...curN, note: `避峰等待至北京时间 ${defer.toISOString().slice(11, 16)}（闲时起执行）` });
+      // P2-4（v0.4.5）：note 更新同样加锁 + 复查 paused（避免「读 curN 到写回之间 pause」被覆盖）
+      withFileLockSync(path.join(scheduleDir(home), '.lock'), () => {
+        const curN = readSchedule(home, id);
+        if (curN && curN.status !== 'paused') writeSchedule(home, { ...curN, note: `避峰等待至北京时间 ${defer.toISOString().slice(11, 16)}（闲时起执行）` });
+      });
       await wait(defer.getTime() - Date.now() + 2000);
     }
     if (job.after?.length) {
@@ -406,26 +424,32 @@ export async function runSleeper(/** @type {any} */ home, /** @type {any} */ id)
       killTask(home, task.id);
       t = { ...t, status: 'timedout' };
     }
-    const cur0 = readSchedule(home, id);
-    if (!cur0) return 'failed'; // 任务已被删除：停止后续写入
-    const history = [...(cur0?.history || [])];
-    history.push({
-      taskId: task.id,
-      status: t?.status || 'unknown',
-      at: Date.now(),
-      durationMs: t?.durationMs ?? null,
-      text: (t?.text || t?.error || '').slice(0, 200),
-    });
-    if (history.length > 50) history.shift();
     const result = t?.status === 'done' ? 'done' : t?.status === 'timedout' ? 'timedout' : 'failed';
-    writeSchedule(home, {
-      ...cur0,
-      lastRunAt: Date.now(),
-      lastTaskId: task.id,
-      runs: (cur0?.runs || 0) + 1,
-      history,
-      consecutiveFailures: result === 'done' ? 0 : prevFails + 1,
+    // 审计（H3 + 自检 P2）：runOnce 收尾元数据读-改-写加锁——与 pause/remove（锁内写）跨进程互斥，
+    // 杜绝「读 cur0 到写回之间用户 pause」被覆盖（毫秒级窗口，彻底起见与终态写同锁、同复查）。
+    const wrote = withFileLockSync(path.join(scheduleDir(home), '.lock'), () => {
+      const curL = readSchedule(home, id);
+      if (!curL) return false; // 已删除：停止后续写入
+      const historyL = [...(curL?.history || [])];
+      historyL.push({
+        taskId: task.id,
+        status: t?.status || 'unknown',
+        at: Date.now(),
+        durationMs: t?.durationMs ?? null,
+        text: (t?.text || t?.error || '').slice(0, 200),
+      });
+      if (historyL.length > 50) historyL.shift();
+      writeSchedule(home, {
+        ...curL,
+        lastRunAt: Date.now(),
+        lastTaskId: task.id,
+        runs: (curL?.runs || 0) + 1,
+        history: historyL,
+        consecutiveFailures: result === 'done' ? 0 : prevFails + 1,
+      });
+      return true;
     });
+    if (!wrote) return 'failed'; // 任务已被删除
     return result;
   };
 
@@ -438,7 +462,7 @@ export async function runSleeper(/** @type {any} */ home, /** @type {any} */ id)
         await wait(Math.min(Math.max((cur.nextRunAt || now) - now, 1000), 60000));
         continue;
       }
-      writeSchedule(home, { ...cur, status: 'running' });
+      if (!markRunning()) return; // P1-15：标记 running 前复查 paused（被暂停则直接退出）
       const result = await runOnce();
       // 质检 H3：状态读-改-写加锁（与 pause/remove 互斥，防丢更新）
       const nextState = withFileLockSync(path.join(scheduleDir(home), '.lock'), () => {
@@ -456,12 +480,14 @@ export async function runSleeper(/** @type {any} */ home, /** @type {any} */ id)
         await wait(Math.min(cur.nextRunAt - now, 60000));
         continue;
       }
-      writeSchedule(home, { ...cur, status: 'running' });
+      if (!markRunning()) return; // P1-15：标记 running 前复查 paused
       const result = await runOnce();
-      // 评估 6.4（v0.4.3）：once 最终状态读-改-写加锁（与 pause/remove 互斥，防 pause 被 done 覆盖）
+      // 评估 6.4（v0.4.3）+ P2-4（v0.4.5）：once 最终状态读-改-写加锁，且 paused 不覆盖——
+      // 用户执行期间 pause（cur2.status==='paused'）绝不被 done/failed 覆盖（every 经 postRunStatus 有防护，此处补齐）
       withFileLockSync(path.join(scheduleDir(home), '.lock'), () => {
         const cur2 = readSchedule(home, id);
-        if (cur2) writeSchedule(home, { ...cur2, status: result });
+        if (!cur2 || cur2.status === 'paused') return;
+        writeSchedule(home, { ...cur2, status: result });
       });
       return;
     } else {
@@ -472,15 +498,21 @@ export async function runSleeper(/** @type {any} */ home, /** @type {any} */ id)
         continue;
       }
       if (st === 'failed') {
-        writeSchedule(home, { ...cur, status: 'skipped' });
+        // P2-4（v0.4.5）：终态写加锁 + 复查 paused（依赖失败判 skipped 也不得覆盖 pause）
+        withFileLockSync(path.join(scheduleDir(home), '.lock'), () => {
+          const c2 = readSchedule(home, id);
+          if (!c2 || c2.status === 'paused') return;
+          writeSchedule(home, { ...c2, status: 'skipped' });
+        });
         return;
       }
-      writeSchedule(home, { ...cur, status: 'running' });
+      if (!markRunning()) return; // P1-15：标记 running 前复查 paused
       const result = await runOnce();
-      // 评估 6.4（v0.4.3）：after 最终状态读-改-写加锁（同上）
+      // 评估 6.4（v0.4.3）+ P2-4（v0.4.5）：after 最终状态读-改-写加锁，且 paused 不覆盖
       withFileLockSync(path.join(scheduleDir(home), '.lock'), () => {
         const cur2 = readSchedule(home, id);
-        if (cur2) writeSchedule(home, { ...cur2, status: result });
+        if (!cur2 || cur2.status === 'paused') return;
+        writeSchedule(home, { ...cur2, status: result });
       });
       return;
     }

package/src/session.js

@@ -4,13 +4,26 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+// —— 冲突备份名（单一事实来源，v0.4.6）——
+// 同步冲突时写入的备份：<会话名>.server-<时间戳>[-<随机后缀>].jsonl（远端版本）与 .remote-（远端拉取版本）。
+// 教训：producer（sync.js conflictCopyName）带随机后缀，而 consumer 的正则只认 <数字>.jsonl，
+// 导致 listSyncConflicts/resolveSyncConflict 永远匹配不到自己的备份——「冲突三选一」100% 失效；
+// 且这些备份被 listSessions 当成普通会话推出/拉取，在其他设备上变成无法解析的幽灵会话。
+// 现由本模块统一给出「识别 + 排除」，写入 / 冲突面板 / 会话列表与同步三处共用同一判定。
+export const CONFLICT_BACKUP_RE = /^(.+)\.(server|remote)-(\d+)(?:-[a-z0-9]+)?\.jsonl$/;
+/** @param {any} n */
+export function isConflictBackupName(n) {
+  return typeof n === 'string' && CONFLICT_BACKUP_RE.test(n);
+}
+
 /** @param {any} home */
 export function listSessions(home) {
   const dir = path.join(home, 'sessions');
   try {
     return fs
       .readdirSync(dir)
-      .filter((f) => f.endsWith('.jsonl'))
+      // 冲突备份不是会话：排除后不再出现在会话列表/最近会话/搜索/云同步推送集合中
+      .filter((f) => f.endsWith('.jsonl') && !isConflictBackupName(f))
       .map((f) => {
         const file = path.join(dir, f);
         return { file, name: f, mtime: fs.statSync(file).mtimeMs };

package/src/skill-lib.js

@@ -188,10 +188,26 @@ export function validateSkillMarkdown(text, hint) {
   return { ok: true, name, description: desc };
 }
 
-/**
- * @param {any} dir
- * @param {any} hint
- */
+// P1-5（v0.4.5）：检测目录树内是否含符号链接——symlink 可越权读任意本机文件并架空 sha256 指纹检测。
+function containsSymlink(/** @type {string} */ dir) {
+  const stack = [dir];
+  while (stack.length) {
+    const d = /** @type {string} */ (stack.pop());
+    let entries;
+    try {
+      entries = fs.readdirSync(d, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (e.isSymbolicLink()) return true;
+      if (e.isDirectory()) stack.push(path.join(d, e.name));
+    }
+  }
+  return false;
+}
+
+/** @param {any} dir @param {any} hint */
 export function validateSkillDir(dir, hint) {
   const skillMd = path.join(dir, 'SKILL.md');
   let text;
@@ -200,6 +216,9 @@ export function validateSkillDir(dir, hint) {
   } catch {
     return { error: `未找到 SKILL.md：${skillMd}` };
   }
+  if (containsSymlink(dir)) {
+    return { error: '技能目录含符号链接，已拒绝（防越权读取本机文件/绕过篡改检测）' };
+  }
   return validateSkillMarkdown(text, hint);
 }
 

package/src/skills.js

@@ -63,7 +63,7 @@ export function tamperedSkillNames(/** @type {any} */ workingDir) {
     if (!e.isDirectory()) continue;
     const skillDir = path.join(dir, e.name);
     try {
-      if (!fs.statSync(path.join(skillDir, 'SKILL.md')).isFile()) continue;
+      if (!fs.lstatSync(path.join(skillDir, 'SKILL.md')).isFile()) continue;
     } catch {
       continue;
     }
@@ -89,7 +89,7 @@ export function listSkills(/** @type {any} */ workingDir) {
       if (!e.isDirectory() || seen.has(e.name)) continue;
       const skillMd = path.join(dir, e.name, 'SKILL.md');
       try {
-        if (!fs.statSync(skillMd).isFile()) continue;
+        if (!fs.lstatSync(skillMd).isFile()) continue;
       } catch {
         continue;
       }