mingdao-harness 0.4.4 → 0.4.6

package/src/cachestats.js

@@ -5,7 +5,6 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { mingdaoHome, ensureHome } from './config.js';
 import { estimateCost, cacheSplit, beijingDayStart, beijingParts } from './pricing.js';
-import { modelPreset } from './models.js';
 import { withFileLockSync, atomicWriteFileSync } from './atomic-write.js';
 
 export function cacheStatsFile() {
@@ -48,8 +47,28 @@ export function recordCacheStats(/** @type {any} */ entry) {
         const raw = fs.readFileSync(cacheStatsFile(), 'utf8');
         const lines = raw.split('\n').filter(Boolean);
         if (lines.length > MAX_LINES) {
-          atomicWriteFileSync(cacheStatsFile(), lines.slice(-KEEP_LINES).join('\n') + '\n');
-          cacheStatsCount = KEEP_LINES;
+          // v0.4.6 P2 修复：轮转必须保留**当天全部**记录。此前只保留最后 KEEP_LINES 行——
+          // 单进程写满 2 万条后，当天早先的费用会被裁掉，todayCost() 随之变小，
+          // 日费用护栏被静默重置（用户可再次超支而不自知）。当天行（最多 MAX_LINES 条）
+          // 与最近 KEEP_LINES 行取并集，去重且保持原顺序。
+          const dayStart = beijingDayStart().getTime();
+          const todayLines = lines.filter((/** @type {string} */ l) => {
+            try {
+              return (JSON.parse(l).at || 0) >= dayStart;
+            } catch {
+              return false;
+            }
+          });
+          const tail = lines.slice(-KEEP_LINES);
+          const tailSet = new Set(tail);
+          const todayCapped = todayLines.length > MAX_LINES ? todayLines.slice(-MAX_LINES) : todayLines;
+          const todaySet = new Set(todayCapped);
+          const merged = [...todayCapped, ...tail.filter((l) => !todaySet.has(l))];
+          // 顺序按原文件恢复（避免打乱 byDay 折线的时间序）
+          const order = new Map(lines.map((l, i) => [l, i]));
+          merged.sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
+          atomicWriteFileSync(cacheStatsFile(), merged.join('\n') + '\n');
+          cacheStatsCount = merged.length;
         }
       });
     } catch {}
@@ -109,16 +128,21 @@ export function summarizeCacheStats(/** @type {any} */ entries) {
 // 记录一次用量（agent 侧调用）：自动计算命中拆分与节省额；perf 为回合性能指标（状态栏）
 export function recordUsage(/** @type {any} */ modelName, /** @type {any} */ usage, /** @type {any} */ perf = null) {
   const split = cacheSplit(usage);
+  // v0.4.6：峰谷单价按「请求发起时刻」判定。响应落地与发起可能跨 12:00/18:00 边界，
+  // 用 new Date()（落账时刻）会把高峰调用记成闲时价（或少记一半），日累计与护栏随之偏移。
+  const priceAt = Number(perf?.requestStartAt) > 0 ? new Date(Number(perf.requestStartAt)) : undefined;
   const prompt = usage?.prompt_tokens || 0;
   const completion = usage?.completion_tokens || 0;
   let cost = null;
   let saved = null;
   if (split) {
-    cost = estimateCost(modelName, prompt, completion, split);
-    saved = estimateCost(modelName, prompt, completion, null) - cost;
-  } else if (modelPreset(modelName)?.pricing) {
-    // 审计 B10：无缓存字段时按全未命中估算（不再计 0 元，费用护栏口径更真实）
-    cost = estimateCost(modelName, prompt, completion, null);
+    const base = estimateCost(modelName, prompt, completion, null, priceAt);
+    cost = estimateCost(modelName, prompt, completion, split, priceAt);
+    if (base != null && cost != null) saved = base - cost;
+  } else {
+    // P0-4（v0.4.5）：estimateCost 无价返 null，直接记录 null（未知）而非 0（免费）——
+    // 覆盖内置定价 + 外部定价 + config.pricing.overrides 三条来源，不再依赖 modelPreset 单一判断。
+    cost = estimateCost(modelName, prompt, completion, null, priceAt);
   }
   recordCacheStats({
     model: modelName,

package/src/cli.js

@@ -32,6 +32,7 @@ import {
   reconcileSchedules,
   runSleeper,
   formatScheduleRow,
+  postRunStatus,
 } from './schedule.js';
 import { createAgent } from './agent.js';
 import { saveTaskStateMerge, clearTaskState } from './task-state.js';
@@ -120,21 +121,28 @@ function printHelpLines(/** @type {any} */ out) {
 
 function parseArgs(/** @type {any} */ argv) {
   const opts = /** @type {Record<string, any>} */ ({ prompt: [], model: null, continueSession: false, resume: false, format: 'text' });
+  // P1-2 / P2-24（v0.4.5）：遇第一个位置参数后停止解析全局 flag——此前贪婪匹配任意位置的 --model/init，
+  // 导致 `mingdao run "任务" --model X` 的 --model 被顶层剥除（后台/定时指定模型静默失效），
+  // 且提问文本含「init」即误触发初始化向导。此后子命令 flag 原样收入 prompt 交子命令解析。
+  let seenArg = false;
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
-    if (a === '-h' || a === '--help') opts.help = true;
-    else if (a === '-v' || a === '--version') opts.version = true;
-    else if (a === '-c' || a === '--continue') opts.continueSession = true;
-    else if (a === '--journal') opts.journal = true;
-    else if (a === '-p' || a === '--preset') opts.preset = argv[++i];
-    else if (a.startsWith('--preset=')) opts.preset = a.slice(9);
-    else if (a === '-r' || a === '--resume') opts.resume = true;
-    else if (a === '--init' || a === 'init') opts.init = true;
-    else if (a === '-m' || a === '--model') opts.model = argv[++i];
-    else if (a.startsWith('--model=')) opts.model = a.slice(8);
-    else if (a === '-f' || a === '--format') opts.format = argv[++i] || 'text';
-    else if (a.startsWith('--format=')) opts.format = a.slice(9);
-    else opts.prompt.push(a);
+    if (!seenArg) {
+      if (a === '-h' || a === '--help') { opts.help = true; continue; }
+      else if (a === '-v' || a === '--version') { opts.version = true; continue; }
+      else if (a === '-c' || a === '--continue') { opts.continueSession = true; continue; }
+      else if (a === '--journal') { opts.journal = true; continue; }
+      else if (a === '-p' || a === '--preset') { opts.preset = argv[++i]; continue; }
+      else if (a.startsWith('--preset=')) { opts.preset = a.slice(9); continue; }
+      else if (a === '-r' || a === '--resume') { opts.resume = true; continue; }
+      else if (a === '--init' || a === 'init') { opts.init = true; continue; }
+      else if (a === '-m' || a === '--model') { opts.model = argv[++i]; continue; }
+      else if (a.startsWith('--model=')) { opts.model = a.slice(8); continue; }
+      else if (a === '-f' || a === '--format') { opts.format = argv[++i] || 'text'; continue; }
+      else if (a.startsWith('--format=')) { opts.format = a.slice(9); continue; }
+    }
+    seenArg = true;
+    opts.prompt.push(a);
   }
   if (!['text', 'json'].includes(opts.format)) opts.format = 'text';
   return opts;
@@ -289,7 +297,14 @@ async function main() {
             }
             if (t.status !== 'running') {
               const result = t.status === 'done' ? 'done' : t.status === 'timedout' ? 'timedout' : 'failed';
-              await writeSchedule(home0, { ...j, status: result, lastRunAt: t.startedAt || j.lastRunAt, runs: (j.runs || 0) + 1 });
+              // P1-4（v0.4.5）：every 周期任务崩溃恢复不能终态化——复用 postRunStatus 重排下一期回 pending，
+              // 否则周期任务静默永停（此前与 once/after 一视同仁写成 done/failed，reconcile 永远跳过）。
+              if (j.kind === 'every') {
+                const ns = postRunStatus(j, result);
+                await writeSchedule(home0, { ...j, ...(ns || { status: result }), lastRunAt: t.startedAt || j.lastRunAt, runs: (j.runs || 0) + 1 });
+              } else {
+                await writeSchedule(home0, { ...j, status: result, lastRunAt: t.startedAt || j.lastRunAt, runs: (j.runs || 0) + 1 });
+              }
               continue;
             }
             continue; // worker 仍在跑：等它（外层 2s 轮询）

package/src/commands/repl.js

@@ -617,13 +617,14 @@ export async function runRepl(ctx) {
           );
         } else io.print('尚无用量记录。');
       } else if (cmd === '/status') {
+        const sc = estimateCost(modelName, stats.promptTokens, stats.completionTokens);
         io.box('会话状态', [
           `模型  ${modelName} · 权限 ${permission.mode}`,
           `沙箱  ${cfg.sandbox || 'off'}${routing ? ` · 自动路由  ${routingEnabled ? '开' : '关'}（${routing.planner}⇄${routing.executor}）` : ''}`,
           `会话  ${path.basename(session.file)}`,
           `轮次  ${stats.turns} · 消息 ${messages.length} 条`,
           `Tokens  ↑${stats.promptTokens} ↓${stats.completionTokens}`,
-          `费用  ≈¥${estimateCost(modelName, stats.promptTokens, stats.completionTokens).toFixed(5)}（累计·按当前模型计价）`,
+          `费用  ${sc == null ? '≈¥—（无价格数据）' : '≈¥' + sc.toFixed(5)}（累计·按当前模型计价）`,
           `计划模式  ${planMode ? '开' : '关'} · 思考显示  ${io.showReasoning ? '开' : '关'} · 任务 ${agent.getTodos().length} 项`,
         ]);
       } else if (cmd === '/cost') {
@@ -634,7 +635,7 @@ export async function runRepl(ctx) {
           `缓存命中率  ${bd.rate != null ? (bd.rate * 100).toFixed(0) + '%' : '暂无缓存数据'}${bd.batchCost > 0 ? ` · Batch 半价任务 ≈¥${bd.batchCost.toFixed(5)}` : ''}`,
           ...bd.byModel.slice(0, 8).map((m) => `  ${m.model}：${m.turns} 轮（${m.batchTurns ? m.batchTurns + ' 批' : ''}）· ↑${m.prompt} ↓${m.completion} · ≈¥${m.cost.toFixed(5)}${m.saved > 0 ? ` · 省 ¥${m.saved.toFixed(5)}` : ''}`),
         ]);
-        const guard = costGuardStatus();
+        const guard = costGuardStatus(modelName);
         if (guard) {
           io.print(
             style(
@@ -643,7 +644,8 @@ export async function runRepl(ctx) {
             )
           );
         }
-        io.print(style('会话内累计（本次）≈¥' + estimateCost(modelName, stats.promptTokens, stats.completionTokens).toFixed(5), C.dim));
+        const sc2 = estimateCost(modelName, stats.promptTokens, stats.completionTokens);
+        io.print(style('会话内累计（本次）' + (sc2 == null ? '≈¥—（无价格数据）' : '≈¥' + sc2.toFixed(5)), C.dim));
       } else if (cmd === '/cache') {
         const entries = listCacheStats();
         if (!entries.length) {

package/src/commands/update.js

@@ -93,7 +93,7 @@ export async function handleUpdateFamily(/** @type {any} */ cmd, /** @type {any}
       return true;
     }
     const rr = /** @type {any} */ (r);
-    console.log(`✓ 完成 ${rr.results.length} 条 · ↑${rr.usage.prompt_tokens} ↓${rr.usage.completion_tokens} tokens · 费用 ≈¥${rr.cost.toFixed(5)}（已按半价）`);
+    console.log(`✓ 完成 ${rr.results.length} 条 · ↑${rr.usage.prompt_tokens} ↓${rr.usage.completion_tokens} tokens · 费用 ${rr.cost == null ? '未知（该模型无价格数据，已记为「未知」而非免费；可配 config.pricing.overrides）' : `≈¥${rr.cost.toFixed(5)}（已按半价）`}`);
     if (r.deduped) console.log(`  （去重合并 ${r.deduped} 条重复问题，结果已回填全部位置）`);
     console.log(`  结果文件：${r.outputFile}`);
     console.log(`  任务 ID：${r.batchId}（结果已计入 /cost 分账）`);

package/src/compact.js

@@ -64,7 +64,12 @@ export async function compactConversation(/** @type {any} */ { messages, budget,
     sizes.push(t);
     total += t;
   }
-  const trigger = Number.isFinite(Number(triggerRatio)) ? Number(triggerRatio) : DEFAULT_TRIGGER_RATIO;
+  // P1 修复（v0.4.6）：触发线不得低于目标保留比。若 trigger < TARGET_RATIO，会出现
+  // 「total 已越过触发线、却仍 ≤ budget×TARGET_RATIO」的区间——此时下面的保留循环不会 break，
+  // boundary 保持 messages.length，于是除 system 外整段会话（含最新用户指令）被全部压成摘要，
+  // 且 WebUI 的 onCompact 会把结果 rewriteSession 永久写回会话文件（真·失忆）。
+  // config.compactTrigger 是文档化的 0–1 可调项，「想更早压缩」的自然用法正好命中。
+  const trigger = Number.isFinite(Number(triggerRatio)) ? Math.max(Number(triggerRatio), TARGET_RATIO) : DEFAULT_TRIGGER_RATIO;
   // force（v0.3.2 边缘检测）：逼近窗口时即便启发式计数低估（total 未达触发线）也强制压缩——
   // 非 DeepSeek 模型启发式计数误差可达 ±2 倍，等它越过触发线时真实 prompt 可能已到窗口边缘。
   if (total <= budget * trigger && !force) return null;
@@ -78,6 +83,16 @@ export async function compactConversation(/** @type {any} */ { messages, budget,
     }
     keepTokens += sizes[i];
   }
+  // 兜底（v0.4.6）：保留循环没 break = 除 system 外的消息在计数上都装得进保留区
+  // （system 提示词通常占绝对多数，容易走到这里）。此时若沿用 boundary=messages.length，
+  // 结果就是「system + 摘要」——除 system 外整段会话（含最新用户指令）全部消失，
+  // WebUI 的 onCompact 还会把它 rewriteSession 永久写回会话文件。改为保留最后一段原文
+  // （MIN_KEEP_TAIL 条，至少覆盖最近一轮问答），只压缩更早的部分。
+  const MIN_KEEP_TAIL = 2;
+  if (boundary >= messages.length) {
+    boundary = messages.length - MIN_KEEP_TAIL;
+  }
+  if (boundary <= 1) return null; // 没有可压缩的前缀（会话太短）：放弃，交回普通裁剪
   const droppedCount = boundary - 1; // 不含 system
   if (!force && droppedCount < MIN_DROP_MESSAGES) return null;
   let droppedTokens = 0;

package/src/context.js

@@ -15,6 +15,14 @@ function partTokens(/** @type {any} */ msg, /** @type {any} */ count) {
   for (const tc of msg.tool_calls || []) {
     total += count(JSON.stringify(tc));
   }
+  // P1 修复（v0.4.6）：reasoning_content 必须计入预算。带 tool_calls 的 assistant 消息会把
+  // 完整 reasoning 原样回传（DeepSeek thinking 模式硬要求，缺/截断即 400，见 agent.js），
+  // 而此前这里只算 content + tool_calls——实测单条 4400 字 reasoning = 2000 token，
+  // messageTokens 只算 33（低估 61 倍）。后果：预算/压缩触发/护栏前置预估同源低估，
+  // 思考型长会话会在「显示还有余量」时把请求顶到窗口边缘。
+  if (typeof msg.reasoning_content === 'string') {
+    total += count(msg.reasoning_content);
+  }
   return total;
 }
 

package/src/cost-guard.js

@@ -6,7 +6,7 @@
 
 import fs from 'node:fs';
 import { listCacheStats, cacheStatsFile } from './cachestats.js';
-import { beijingDayStart } from './pricing.js';
+import { beijingDayStart, hasPricing } from './pricing.js';
 import { loadConfig } from './config.js';
 
 export function costGuardConfig() {
@@ -44,13 +44,22 @@ export function todayCost() {
   }
 }
 
-export function costGuardStatus() {
+/**
+ * @param {any} [modelName] 实际使用模型；缺省回退 config.model（仪表盘/无会话上下文）
+ */
+export function costGuardStatus(modelName) {
   const g = costGuardConfig();
   if (!g) return null;
   const cost = todayCost();
   const limit = Number(g.dailyLimitYuan) || 0;
   const warnAt = Number(g.warnAtYuan) || (limit > 0 ? limit * 0.8 : 0);
   const action = g.action === 'block' || g.action === 'downgrade' ? g.action : 'warn';
+  // P0-4（v0.4.5）：当前模型无价格数据时费用护栏静默失效（estimateCost 恒 0、overLimit 恒 false）。
+  // 显式标记 noPricing，调用方据此告警而非静默放行。modelName 优先取「实际使用模型」（agent 传 activeModel），
+  // 缺省回退 config.model（仪表盘/无会话上下文）；两者都无则无法判断，不误标 noPricing。
+  const cfg = loadConfig();
+  const model = modelName ?? cfg?.model ?? null;
+  const noPricing = limit > 0 && model != null && !hasPricing(model);
   return {
     cost,
     limit,
@@ -58,16 +67,27 @@ export function costGuardStatus() {
     action,
     downgradeModel: String(g.downgradeModel || 'deepseek-v4-flash'),
     degraded: cost === null, // 统计不可读：护栏降级为「无法判断」
-    overWarn: cost !== null && limit > 0 && cost >= warnAt,
-    overLimit: cost !== null && limit > 0 && cost >= limit,
+    noPricing, // 无价格数据：费用护栏无法累计，需显式告警
+    overWarn: cost !== null && !noPricing && limit > 0 && cost >= warnAt,
+    overLimit: cost !== null && !noPricing && limit > 0 && cost >= limit,
   };
 }
 
 // Agent 每轮开始前调用：返回 null 放行；blocked=true 应暂停本轮；downgrade=true 应切换便宜模型
-export function checkCostGuard() {
-  const st = costGuardStatus();
+/**
+ * @param {any} [modelName] 实际使用模型；缺省回退 config.model
+ */
+export function checkCostGuard(modelName) {
+  const st = costGuardStatus(modelName);
   if (!st) return null;
   if (st.degraded) return null; // 统计不可读：不误拦也不放水（已告警），按无法判断处理
+  if (st.noPricing) {
+    // P0-4（v0.4.5）：无价格数据时护栏无法累计——显式告警而非静默放行（绝不当「没花钱」）
+    return {
+      blocked: false,
+      message: '⚠ 费用护栏：当前模型无价格数据，今日费用无法累计、dailyLimitYuan 不生效——请在 config.pricing.overrides 为模型补充定价，或改用有价的 DeepSeek 模型（deepseek-v4-pro/flash）。',
+    };
+  }
   if (st.overLimit && st.action === 'block') {
     return {
       blocked: true,

package/src/hooks.js

@@ -19,8 +19,12 @@ function normalize(/** @type {any} */ list) {
 function match(/** @type {any} */ hook, /** @type {any} */ toolName) {
   const m = String(hook.matcher || '*').trim();
   if (!m || m === '*') return true;
-  return m.split(',').some((part) => {
+  // P2 修复（v0.4.6）：同时支持 `,` 与 `|` 分隔。docs/CONFIG.md 的官方示例写的是
+  // `"matcher": "write|edit|bash"` 并明文声明支持 `|`，而实现只按 `,` 切分——按文档写的
+  // PreToolUse 策略钩子永不触发（fail-open），且没有任何日志，一个本该拦写操作的合规钩子静默失效。
+  return m.split(/[,|]/).some((part) => {
     const p = part.trim();
+    if (!p) return false;
     if (p.endsWith('*')) return toolName.startsWith(p.slice(0, -1));
     return p === toolName;
   });
@@ -43,12 +47,18 @@ export function createHooks(hooksCfg = {}, /** @type {any} */ workingDir, /** @t
 
   function run(/** @type {any} */ hook, /** @type {any} */ payload) {
     return new Promise((resolve) => {
+      // 评估 6.5（v0.4.4）+ Windows 回归修复（v0.4.5）：POSIX 上 detached 自成进程组，
+      // 超时 process.kill(-pid) 整组清理（否则只杀 shell，孙进程孤儿）；但 Windows 无进程组语义，
+      // detached 反而新建控制台、打断 stdio 管道——hook 子进程收不到 stdin EOF 卡 10s 超时，
+      // 使 Windows CI 自 v0.4.4 起冒烟测试恒红。改为 Windows 用 windowsHide（不闪窗）且直接 kill child。
+      const isWin = process.platform === 'win32';
       const child = spawn(hook.cmd, {
         shell: true,
         cwd: workingDir,
         env: childEnv,
         stdio: ['pipe', 'pipe', 'pipe'],
-        detached: true, // 评估 6.5：自成进程组，超时 process.kill(-pid) 整组清理（否则只杀 shell，孙进程孤儿）
+        detached: !isWin,
+        windowsHide: isWin,
       });
       let out = '';
       let err = '';
@@ -64,9 +74,10 @@ export function createHooks(hooksCfg = {}, /** @type {any} */ workingDir, /** @t
         resolve(result);
       };
       const timer = setTimeout(() => {
-        // 审计质量项：超时杀整组（shell:true 的孙进程不成孤儿）
+        // 审计质量项：超时杀整组（shell:true 的孙进程不成孤儿）；Windows 无进程组，直接 kill child
         try {
-          process.kill(-(/** @type {any} */ (child)).pid, 'SIGKILL');
+          if (!isWin) process.kill(-(/** @type {any} */ (child)).pid, 'SIGKILL');
+          else child.kill('SIGKILL');
         } catch {
           child.kill('SIGKILL');
         }
@@ -74,6 +85,11 @@ export function createHooks(hooksCfg = {}, /** @type {any} */ workingDir, /** @t
       }, 10000);
       child.stdout.on('data', (d) => (out = cap(out, d)));
       child.stderr.on('data', (d) => (err = cap(err, d)));
+      // P1 修复（v0.4.6）：stdin 必须有 error 监听。hook 若「不读 stdin 就退出」（如
+      // cmd:'true' / echo 形式的策略脚本）且载荷超过管道缓冲（约 64KB，write 大文件时必然发生），
+      // write 的 EPIPE 会作为异步 error 事件抛出——无人监听即未捕获异常，整个进程崩溃
+      // （WebUI 场景下所有并发会话一起死）。write() 本身的 try/catch 捕不到异步事件。
+      child.stdin.on('error', () => {});
       child.on('error', (e) => {
         clearTimeout(timer);
         finish({ ok: false, error: `hook 启动失败：${e.message}` });

package/src/log-writer.js

@@ -5,19 +5,31 @@ import path from 'node:path';
 import crypto from 'node:crypto';
 
 export function createLogWriter(/** @type {string} */ file, { maxBytes = 512 * 1024 } = {}) {
+  // 轮转低水位（v0.4.6 P2 修复）：保留到 maxBytes/2 而不是刚好卡在上限。
+  // 此前 `cut = raw.length - maxBytes` 让保留区恰好等于上限，文件在轮转后立刻又超限，
+  // 于是**每次追加都整文件重写**（实测：上限之后 2000 次追加 = 2000 次全量读写 ≈1GB I/O）。
+  // 另外 raw.length 是 UTF-16 码元数、st.size 是字节数，中文日志下 cut 直接变负 → 只砍掉一行。
+  // 改为按字节定位行边界（Buffer.lastIndexOf(0x0a)），并留出一半余量。
+  const keepBytes = Math.max(1, Math.floor(maxBytes / 2));
   return (/** @type {string} */ msg) => {
     try {
       fs.mkdirSync(path.dirname(file), { recursive: true });
       const line = new Date().toISOString() + ' ' + String(msg) + '\n';
-      // 自查 #5：日志可能含工具参数等敏感信息——创建与轮转一律 600（多用户机器防同机读取）
-      if (!fs.existsSync(file)) fs.appendFileSync(file, line, { mode: 0o600 });
-      else fs.appendFileSync(file, line);
+      // 自查 #5：日志可能含工具参数等敏感信息——创建与轮转一律 600（多用户机器防同机读取）。
+      // v0.4.6 P3：已存在的 644 日志也要收权——mode 只在创建时生效，此前只在轮转时才 chmod。
+      if (!fs.existsSync(file)) {
+        fs.appendFileSync(file, line, { mode: 0o600 });
+      } else {
+        fs.appendFileSync(file, line);
+        try { fs.chmodSync(file, 0o600); } catch {}
+      }
       const st = fs.statSync(file);
       if (st.size > maxBytes) {
-        const raw = fs.readFileSync(file, 'utf8');
-        const cut = raw.length - maxBytes;
-        const nl = raw.indexOf('\n', cut);
-        const keep = nl === -1 ? raw.slice(cut) : raw.slice(nl + 1); // 行对齐保留尾部
+        const buf = fs.readFileSync(file);
+        // 从「字节位置 st.size - keepBytes」起找下一个换行，保证不在行/多字节字符中间切开
+        const from = Math.max(0, buf.length - keepBytes);
+        const nl = buf.indexOf(0x0a, from);
+        const keep = nl === -1 ? buf.subarray(from) : buf.subarray(nl + 1);
         const tmp = file + '.' + process.pid + '.' + crypto.randomBytes(3).toString('hex') + '.tmp';
         fs.writeFileSync(tmp, keep, { mode: 0o600 }); // 轮转重建保持 600
         fs.renameSync(tmp, file);

package/src/mcp.js

@@ -65,6 +65,10 @@ export class McpClient {
     this.child.stderr.on('data', (d) => {
       this.stderrTail = (this.stderrTail + d.toString()).slice(-2000);
     });
+    // P1 修复（v0.4.6）：stdin 必须有 error 监听。MCP 服务器若在调用途中退出（或某帧超过管道
+    // 缓冲，约 64KB 的 tools/call 参数），stdin.write 的 EPIPE 会作为异步 error 事件抛出；
+    // 无人监听即未捕获异常 → 整个进程崩溃（WebUI 下所有并发会话一起死）。try/catch 捕不到异步事件。
+    this.child.stdin.on('error', () => {});
     this.child.on('error', (err) => {
       this.error = `启动失败：${err.message}`;
       this._failAll(this.error);

package/src/memory.js

@@ -9,6 +9,7 @@ import path from 'node:path';
 import { mingdaoHome, ensureHome } from './config.js';
 import { beijingParts } from './pricing.js';
 import { tokenize } from './session-index.js';
+import { atomicWriteFileSync } from './atomic-write.js';
 
 export function memoryFile() {
   return path.join(mingdaoHome(), 'AGENTS.md');
@@ -47,7 +48,7 @@ function backupMemory() {
 export function writeMemory(/** @type {any} */ content) {
   backupMemory();
   ensureHome();
-  fs.writeFileSync(memoryFile(), String(content ?? ''));
+  atomicWriteFileSync(memoryFile(), String(content ?? ''));
 }
 
 // 去重：忽略日期前缀后内容相同的条目只保留第一条
@@ -70,7 +71,7 @@ export function dedupeMemory() {
   }
   if (removed > 0) {
     backupMemory();
-    fs.writeFileSync(memoryFile(), kept.join('\n') + '\n');
+    atomicWriteFileSync(memoryFile(), kept.join('\n') + '\n');
   }
   return removed;
 }
@@ -91,7 +92,7 @@ export function removeMemoryLines(/** @type {any} */ keyword) {
   }
   if (removed > 0) {
     backupMemory();
-    fs.writeFileSync(memoryFile(), kept.join('\n'));
+    atomicWriteFileSync(memoryFile(), kept.join('\n'));
   }
   return removed;
 }
@@ -117,7 +118,7 @@ export function appendJournal(/** @type {any} */ home, /** @type {any} */ entry)
       const raw = fs.readFileSync(journalFile(), 'utf8');
       const lines = raw.split('\n').filter(Boolean);
       if (lines.length > 600) {
-        fs.writeFileSync(journalFile(), lines.slice(-500).join('\n') + '\n');
+        atomicWriteFileSync(journalFile(), lines.slice(-500).join('\n') + '\n');
         journalCount = 500;
       }
     } catch {}
@@ -294,7 +295,7 @@ export function dedupeProjectMemory(/** @type {any} */ workingDir) {
     kept.push(t);
   }
   if (removed > 0) {
-    try { fs.writeFileSync(projectMemoryFile(workingDir), kept.join('\n') + '\n'); } catch {}
+    try { atomicWriteFileSync(projectMemoryFile(workingDir), kept.join('\n') + '\n'); } catch {}
   }
   return removed;
 }

package/src/model-caps.js

@@ -7,6 +7,8 @@ import { modelPreset } from './models.js';
 // fc00::/7、fe80::/10、::、::1、IPv4-mapped）——此前只查 IPv4 与 ::1，IPv6 本地模型被误判远程
 // （超时档位错），且与 fetch 工具/SSRF 判定各维护一份、口径漂移。
 import { isPrivateHost } from './tools/fetch.js';
+import fs from 'node:fs';
+import path from 'node:path';
 
 // 兜底：未知模型默认上下文窗口。本地小模型宁可保守（不撑爆）也不乐观。
 export const UNKNOWN_LOCAL_WINDOW = 32768;
@@ -21,11 +23,45 @@ export const COMFORT_RATIO = 0.75;
 export const EDGE_RATIO = 0.85;
 
 /** 判断 baseUrl 是否指向本机/内网（本地推理框架部署）。 */
+// MacBook 本地 507 根因（v0.4.5）：自定义主机名（如 mtplx.server.openai 经 /etc/hosts 指向 127.0.0.1）
+// 的字面量判定抓不到——isPrivateHost(hostname) 对非 IP/非 localhost 恒 false，导致本地模型被误判远程：
+// 只读子代理不串行（9 路大 prefill 并发击穿内存）、压缩触发线用远程档（0.8 而非 0.6）、超时档位错。
+// 同步查 /etc/hosts（含 Windows）复检「主机名 → 私网/回环 IP」的映射，命中即视为本地。
+const hostsCache = /** @type {Map<string, boolean>} */ (new Map()); // hostname → 是否 /etc/hosts 映射私网
+function hostsMapsToPrivate(/** @type {string} */ hostname) {
+  if (hostsCache.has(hostname)) return Boolean(hostsCache.get(hostname));
+  let mapped = false;
+  try {
+    const file = process.platform === 'win32'
+      ? path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'drivers', 'etc', 'hosts')
+      : '/etc/hosts';
+    const text = fs.readFileSync(file, 'utf8');
+    for (const line of text.split(/\r?\n/)) {
+      const clean = line.replace(/#.*/, '').trim();
+      if (!clean) continue;
+      const parts = clean.split(/\s+/);
+      const ip = parts[0];
+      if (!ip || !isPrivateHost(ip)) continue;
+      if (parts.slice(1).some((h) => h.toLowerCase() === hostname)) {
+        mapped = true;
+        break;
+      }
+    }
+  } catch {
+    mapped = false; // 无 /etc/hosts 或不可读：维持字面量判定
+  }
+  hostsCache.set(hostname, mapped);
+  return mapped;
+}
+
 export function isLocalBaseUrl(/** @type {any} */ baseUrl) {
   try {
     const u = new URL(String(baseUrl || ''));
     if (!u.hostname) return false;
-    return isPrivateHost(u.hostname);
+    const host = u.hostname.toLowerCase();
+    if (isPrivateHost(host)) return true;
+    // 自定义主机名（经 /etc/hosts 指向 127.0.0.1 等私网地址）复检；否则维持「远程」
+    return hostsMapsToPrivate(host);
   } catch {
     return false;
   }
@@ -35,13 +71,16 @@ export function isLocalBaseUrl(/** @type {any} */ baseUrl) {
  * 解析模型能力。优先级：customModels.<name>.contextWindow/maxOutputTokens > 内置 preset > 兜底。
  * @param {any} cfg
  * @param {string} modelName
- * @returns {{ contextWindow: number, maxOutputTokens: number, isLocal: boolean, budgetTokens: number|null, preset: any }}
+ * @returns {{ contextWindow: number, maxOutputTokens: number, maxOutputCeiling: number, isLocal: boolean, budgetTokens: number|null, preset: any }}
  */
 export function resolveModelCaps(/** @type {any} */ cfg, /** @type {any} */ modelName) {
   const preset = modelPreset(modelName);
   const cm = (cfg?.customModels || {})[modelName] || {};
   const baseUrl = cm.baseUrl || cfg?.baseUrl || '';
-  const isLocal = isLocalBaseUrl(baseUrl);
+  // 显式声明优先：customModels.<name>.local=true/isLocal=true 强制按本地模型处理（压缩/串行/超时走本地档），
+  // 覆盖 baseUrl 字面量/hosts 判定不到的场景（如经公网反代回本机、特殊主机名）。
+  const explicitLocal = cm.local === true || cm.isLocal === true;
+  const isLocal = explicitLocal || isLocalBaseUrl(baseUrl);
   const contextWindow =
     Number(cm.contextWindow) > 0
       ? Number(cm.contextWindow)
@@ -51,7 +90,12 @@ export function resolveModelCaps(/** @type {any} */ cfg, /** @type {any} */ mode
       ? Number(cm.maxOutputTokens)
       : preset?.maxOutputTokens || Math.min(DEFAULT_MAX_OUTPUT, Math.max(1024, Math.floor(contextWindow / 8)));
   const budgetTokens = preset?.budgetTokens || null;
-  return { contextWindow, maxOutputTokens, isLocal, budgetTokens, preset };
+  // v0.4.6：把 models.js 的 maxOutputCeiling（官方单次最大输出规格，如 DeepSeek 384K）纳入能力面。
+  // 此前该字段只定义、源码零引用——README 宣称「单次输出上限 384K」在框架里拿不到
+  // （pro 实际被 maxOutputTokens=65536 封顶，用户显式调大也无处生效）。现在它作为
+  // 「用户显式配置 maxOutputTokens 时的硬上限」，让文档承诺可用且仍受窗口约束。
+  const maxOutputCeiling = Number(cm.maxOutputCeiling) > 0 ? Number(cm.maxOutputCeiling) : preset?.maxOutputCeiling || maxOutputTokens;
+  return { contextWindow, maxOutputTokens, maxOutputCeiling, isLocal, budgetTokens, preset };
 }
 
 /**

package/src/permissions.js

@@ -23,8 +23,8 @@ function summarize(name, args) {
   }
 }
 
-/** @param {any} rule @param {any} name @param {any} args */
-function ruleMatches(rule, name, args) {
+/** @param {any} rule @param {any} name @param {any} args @param {boolean} [forDeny] */
+function ruleMatches(rule, name, args, forDeny = false) {
   const idx = rule.indexOf(':');
   if (idx > 0) {
     const ruleName = rule.slice(0, idx);
@@ -34,7 +34,13 @@ function ruleMatches(rule, name, args) {
     // bash 前缀规则防链式命令绕过（P0 安全，v0.4.1）：白名单字符法——前缀规则仅匹配
     // 单条简单命令（字母数字/空格/下划线/./-/），任何 shell 元字符（&&/||/;|&<>`$()\n\r）都不匹配，
     // 回落权限确认。黑名单枚举永远追不上绕过手法（单 & 后台串联、重定向、\r 等），白名单才可靠。
-    if (name === 'bash' && !/^[A-Za-z0-9_ ./\\:-]+$/.test(have)) return false;
+    //
+    // P1 修复（v0.4.6）：该白名单只适用于 **allow** 规则（目的正是防止 `git status && rm -rf /`
+    // 借前缀匹配提权）。deny 是「硬拦截」，方向相反——失配 = 不拦 = fail-open：命令里只要出现
+    // & ; | $ @ = ' " Tab 等元字符，deny 规则就失配并回落到 mode，而 auto 档下 deny 是唯一防线，
+    // 等于形同不存在（实测 deny:['bash:rm *'] 拦得住 `rm -rf /x`，却放过 `cd /tmp && rm -rf /x`）。
+    // 故 deny 一律按命令原文匹配，不设字符白名单。
+    if (!forDeny && name === 'bash' && !/^[A-Za-z0-9_ ./\\:-]+$/.test(have)) return false;
     if (want.endsWith('*')) return have.startsWith(want.slice(0, -1));
     return have === want;
   }
@@ -69,7 +75,7 @@ export function createPermission(rawMode, io) {
       };
       // 需要特殊授权时弹出对话框与用户交互，而不是静默拒绝：
       // 1) 被 deny 规则拦截 → 询问是否本次强制放行
-      if (deny.some((/** @type {any} */ r) => ruleMatches(r, name, args))) {
+      if (deny.some((/** @type {any} */ r) => ruleMatches(r, name, args, true))) {
         return askOverride(`规则拦截了 ${name}${summarize(name, args)}，是否本次强制放行？[y/N] `);
       }
       if (allow.some((/** @type {any} */ r) => ruleMatches(r, name, args))) return true;

package/src/presets.js

@@ -157,10 +157,20 @@ const PERM_RANK = /** @type {Record<string, number>} */ ({ readonly: 0, ask: 1,
 export function presetPermissionOverride(/** @type {any} */ preset, /** @type {any} */ currentPermission) {
   const want = preset && preset.permission !== undefined ? String(preset.permission) : null;
   if (!want || !(want in PERM_RANK)) return { permission: currentPermission, escalated: false };
-  const cur = currentPermission in PERM_RANK ? currentPermission : 'ask';
+  // P2 修复（v0.4.6）：currentPermission 也可能是**对象形态**（docs/CONFIG.md 推荐的
+  // {mode, allow, deny}，且 cli/repl/web 三个入口传的都是 cfg.permission 对象）——对象做 `in`
+  // 运算时键名变成 "[object Object]"，不入 PERM_RANK，于是 cur 被当成 'ask'：
+  // 当前 {mode:'readonly'} 时，预设声明 permission:'ask' 不判为提权，只读档被静默放宽为 ask
+  // （写操作从「禁止」变成「逐次确认」），且无 banner、无 escalated 标记。现先归一化 mode。
+  const curMode =
+    currentPermission && typeof currentPermission === 'object'
+      ? String(currentPermission.mode ?? '')
+      : String(currentPermission ?? '');
+  // 识别不出时取最保守的 readonly（fail-closed），而不是 ask
+  const cur = curMode in PERM_RANK ? curMode : 'readonly';
   if (PERM_RANK[want] > PERM_RANK[cur]) {
-    // 提权：忽略预设值，保持当前更保守的权限
-    return { permission: cur, escalated: true };
+    // 提权：忽略预设值，保持当前更保守的权限（对象形态保留其 allow/deny）
+    return { permission: curMode in PERM_RANK ? currentPermission : cur, escalated: true };
   }
   return { permission: want, escalated: false };
 }