mingdao-harness 0.4.4 → 0.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mingdao-harness",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "description": "MingDao Harness —— 开源智能体框架（Agent Harness）。零依赖、开箱即用，针对 DeepSeek-V4 系列优化，开放主流模型接入。",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -27,7 +27,7 @@ const SUBAGENT_MAX_STEPS = 24;
  * 创建 Agent 循环（调用方只需传 provider/permission/io/modelName/workingDir，其余可选）
  * @param {{ provider: any, permission: any, io: any, modelName: any, workingDir: any,
  *   cfg?: any, undoStore?: any, maxSteps?: number, mcp?: any, onCompact?: any, sessionRef?: any,
- *   onUsage?: (usage: any) => void }} params
+ *   onUsage?: (modelName: string, usage: any) => void }} params
  */
 export function createAgent({ provider, permission, io, modelName, workingDir, cfg = {}, undoStore, maxSteps, mcp, onCompact, sessionRef, onUsage }) {
   const preset = modelPreset(modelName) || {};
@@ -112,6 +112,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       maxSteps: SUBAGENT_MAX_STEPS,
       mcp,
       sessionRef, // 子代理的审计记录归入主会话
+      onUsage, // P1-5（v0.4.5）：透传逐轮入账回调——子代理消耗计入今日费用（子代理内部 activeModel=subModel 正确归属）
     });
     const sys =
       `你是主智能体 MingDao 派出的子代理，独立完成一项子任务。` +
@@ -194,7 +195,10 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
     const inFlightCost = () => estimateCost(activeModel, usage.prompt_tokens, usage.completion_tokens, null, new Date());
     const usedTodayWithInflight = () => {
       const today = todayCost();
-      return today == null ? null : today + inFlightCost();
+      if (today == null) return null;
+      const inflight = inFlightCost();
+      // P0-4（v0.4.5）：无价模型在途费用为 null（未知）——整体视为「无法判断」而非 +null→today 的静默忽略
+      return inflight == null ? null : today + inflight;
     };
     // 省钱 B1：本回合只读阶段判定——最新用户消息无写意图则先只发只读工具，
     // 模型明确表达写意图后（下一轮）注入全量。cfg.schemaTier=false 可关。
@@ -305,8 +309,9 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           for (const m of sanitized) promptTokens += messageTokens(m, count);
           const worst = estimateCost(activeModel, promptTokens, maxOutput, null, new Date());
           const used = usedTodayWithInflight(); // 含本回合在途费用（防长回合烧穿）
-          if (used == null) {
-            // todayCost 读取失败：无法判断，跳过前置拦截（护栏主检查同样跳过并告警）
+          if (used == null || worst == null) {
+            // P0-4（v0.4.5）：统计不可读 或 无价格数据（最坏成本未知）→ 无法判断，跳过前置拦截
+            // （护栏主检查 checkCostGuard 会显式告警「无价格数据」，此处不重复误拦也不静默放行）
           } else if (used + worst >= Number(g.dailyLimitYuan)) {
             stripOrphanCalls();
             return {
@@ -321,7 +326,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       // 费用护栏（A2/B4）：每轮开始前按今日实际费用检查；block 暂停本轮；
       // downgrade 自动切换便宜模型继续执行（每回合只切一次，切换即粘滞）
       if (cfg.costGuard) {
-        const guard = checkCostGuard();
+        const guard = checkCostGuard(activeModel);
         if (guard) {
           if (guard.blocked) {
             stripOrphanCalls();
@@ -410,6 +415,24 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           stripOrphanCalls();
           return { text: null, reasoning: '', usage, steps, finish, truncated: false, aborted: true, durationMs: Date.now() - startedAt, perf: perf() };
         }
+        // MacBook 本地 507 memory_refusal 根因（v0.4.5）：服务端内存拒绝不是「空输出」——
+        // 直接终结合合并透出降级提示，不计入空轮、不注入续写重试（内存未释放必再 507，空烧请求）。
+        const e = /** @type {any} */ (err);
+        if (e?.status === 507 || /memory_refusal|内存不足|内存拒绝/i.test(String(e?.message || ''))) {
+          stripOrphanCalls();
+          return {
+            text: null,
+            reasoning: '',
+            usage,
+            steps,
+            finish,
+            truncated: false,
+            aborted: false,
+            note: '本地模型内存不足（507 memory_refusal）——请压缩上下文（减小 config.contextBudget 或 /compact）、减少并发子任务，或重启模型服务释放内存后再继续。',
+            durationMs: Date.now() - startedAt,
+            perf: perf(),
+          };
+        }
         throw err;
       }
 
@@ -523,6 +546,9 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           let allowed = false;
           if (isMcp && mcp?.isReadonly(name)) {
             allowed = true; // MCP 工具的只读标注自动放行
+          } else if (name === 'task' && args.readOnly === true) {
+            allowed = true; // P2-2（v0.4.5）：只读子代理自动放行——它本身只读（readOnly 子代理只能读），
+            // 与 release note「可派 readOnly 子代理」意图一致；非 readOnly 的 task 仍走权限询问
           } else {
             try {
               allowed = await permission.check(name, args);
@@ -740,9 +766,10 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
     }
     // v0.3.1 自动续跑（长程执行）：还有剩余轮次且未中断 → 注入进度摘要直接续跑，不落收尾总结
     if (round < maxRounds - 1 && !aborted) {
-      // 每轮结束：回调本轮增量 usage（含缓存命中拆分），供调用方逐轮入账
+      // 每轮结束：回调本轮增量 usage（含缓存命中拆分），供调用方逐轮入账。activeModel 为本轮实际模型
+      // （护栏降级/子代理都据此正确归属——P2-5 模型名一致性 + P1-5 子代理费用入账）。
       try {
-        onUsage?.({
+        onUsage?.(activeModel, {
           prompt_tokens: usage.prompt_tokens - roundUsageStart.prompt_tokens,
           completion_tokens: usage.completion_tokens - roundUsageStart.completion_tokens,
           prompt_cache_hit_tokens: (usage.prompt_cache_hit_tokens || 0) - roundUsageStart.prompt_cache_hit_tokens,

package/src/atomic-write.js

@@ -31,10 +31,17 @@ export function atomicWriteJsonSync(/** @type {string} */ target, /** @type {any
 
 // 极简互斥锁：O_EXCL 创建 lockfile；持锁期间执行 fn（同步）；异常/完成释放。
 // 进程崩溃遗留的陈旧锁（> staleMs 未更新）自动回收，避免永久卡死。
+// 可重入（P0-1 修复，v0.4.5）：本进程已持该锁时直接执行 fn——O_EXCL 锁不可重入，此前
+// killTask 持锁内调 patchTask 二次抢同一把锁自死锁 5s（tasks kill/pause/remove 全失效）。
 const sleepBuf = new Int32Array(new SharedArrayBuffer(4));
 const sleepMs = (/** @type {number} */ ms) => Atomics.wait(sleepBuf, 0, 0, ms);
+const heldLocks = new Set(); // 本进程当前持有的锁路径（可重入判定）
 
 export function withFileLockSync(/** @type {string} */ lockPath, /** @type {() => any} */ fn, { timeoutMs = 5000, staleMs = 15000 } = {}) {
+  // 可重入：同一调用栈内已持该锁 → 直接执行，不再二次抢锁
+  if (heldLocks.has(lockPath)) {
+    return fn();
+  }
   fs.mkdirSync(path.dirname(lockPath), { recursive: true });
   const t0 = Date.now();
   for (;;) {
@@ -45,9 +52,11 @@ export function withFileLockSync(/** @type {string} */ lockPath, /** @type {() =
       } finally {
         fs.closeSync(fd);
       }
+      heldLocks.add(lockPath);
       try {
         return fn();
       } finally {
+        heldLocks.delete(lockPath);
         try {
           fs.unlinkSync(lockPath);
         } catch {}

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() {
@@ -114,10 +113,12 @@ export function recordUsage(/** @type {any} */ modelName, /** @type {any} */ usa
   let cost = null;
   let saved = null;
   if (split) {
+    const base = estimateCost(modelName, prompt, completion, null);
     cost = estimateCost(modelName, prompt, completion, split);
-    saved = estimateCost(modelName, prompt, completion, null) - cost;
-  } else if (modelPreset(modelName)?.pricing) {
-    // 审计 B10：无缓存字段时按全未命中估算（不再计 0 元，费用护栏口径更真实）
+    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);
   }
   recordCacheStats({

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/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/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;
   }
@@ -41,7 +77,10 @@ export function resolveModelCaps(/** @type {any} */ cfg, /** @type {any} */ mode
   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)

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 内费用估算/护栏/避峰自动跟随'] };
@@ -214,6 +215,13 @@ 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;
@@ -250,7 +258,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 +278,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

@@ -92,14 +92,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 +131,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 +142,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 +156,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/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/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;
       }

package/src/tasks/worker.js

@@ -104,7 +104,10 @@ export async function runWorkerTask(id, question, { permission, model, offpeak }
         if (title) renameSessionFile(fs, path, home, session, title);
       } catch {}
     }
-    const finalStatus = res.truncated ? 'failed' : res.aborted ? 'killed' : 'done';
+    // P1-3（v0.4.5）：capHit（跑满步数上限后收尾）语义是「未真正完成、可续跑」——此前 worker 不判
+    // capHit 直接判 done，后台任务/链式编排把未完成任务当成功（假完成）。
+    const finalStatus = res.capHit ? 'failed' : res.truncated ? 'failed' : res.aborted ? 'killed' : 'done';
+    if (res.capHit && !note) note = '达到步数上限，任务未完成（可续跑）。';
     recordUsage(res.perf?.usedModel || modelName, res.usage, /** @type {any} */ (res.perf));
     finish({
       status: finalStatus,

package/src/tasks.js

@@ -115,7 +115,10 @@ function killTaskInner(/** @type {any} */ home, /** @type {any} */ id) {
     try {
       owned = fs.readFileSync(`/proc/${t.pid}/cmdline`, 'utf8').includes(id);
     } catch {}
-    if (owned === true) { // 非 Linux/无法校验（null）不盲杀（CodeBuddy 报告：PID 复用误杀风险）
+    // P0-3（v0.4.5）：owned===null（非 Linux 无 /proc，或无法读取）时降级为「按 pid 存活即杀」——
+    // 此前 null 直接跳过，导致 macOS/Windows 上 kill 只改状态不杀进程、worker 继续跑完覆盖状态。
+    // 任务 id 含随机 + 启动时 pid，PID 复用误杀概率极低，且任务 id 本就是用户显式指定的目标。
+    if (owned === true || owned === null) {
       try {
         // worker 是 detached 进程（自成进程组）：优先杀整组，避免工具子进程成孤儿
         process.kill(-t.pid, 'SIGTERM');

package/src/tools/fetch.js

@@ -49,7 +49,6 @@ export async function runFetch(/** @type {any} */ args, /** @type {any} */ _ctx)
     let cur = u;
     let res = /** @type {any} */ (null);
     for (let hop = 0; hop <= 5; hop++) {
-      if (hop > 5) return { ok: false, error: '重定向次数超过上限（5 跳）。' };
       const ch = String(cur.hostname || '').toLowerCase();
       let hopBlocked = isPrivateHost(ch);
       if (!hopBlocked && ch && ch !== 'localhost' && !/^\d{1,3}(\.\d{1,3}){3}$/.test(ch)) {
@@ -63,6 +62,8 @@ export async function runFetch(/** @type {any} */ args, /** @type {any} */ _ctx)
       if (hopBlocked) return { ok: false, error: `拒绝访问内网/本机地址（${ch}）——SSRF 重定向防护。` };
       res = await fetch(cur, { signal: ac.signal, redirect: 'manual' });
       if (res.status >= 300 && res.status < 400) {
+        // P2-3（v0.4.5）：原 `if(hop>5)` 死代码（hop 最大 5 永不触发）——超限应在 3xx 分支内判定
+        if (hop >= 5) return { ok: false, error: '重定向次数超过上限（5 跳）。' };
         const loc = res.headers.get('location');
         if (!loc) break; // 无 Location：按最终响应处理
         try {

package/src/tools/git.js

@@ -3,6 +3,9 @@
 import { execFile } from 'node:child_process';
 
 const GIT_READONLY = new Set(['status', 'log', 'diff', 'show', 'blame', 'rev-parse', 'branch', 'tag', 'ls-files', 'shortlog']);
+// P1-8（v0.4.5）：参数级过滤——此前只校验子命令首词，`diff --no-index` 可越界读任意文件（git∈
+// READONLY_TOOLS 免权限确认）、`branch -D`/`tag -f/-d` 破坏元数据、`--output` 写文件全部放行。
+const BANNED_FLAGS = new Set(['--no-index', '--output', '-o', '--delete', '-D', '-d', '--force', '-f', '-m', '--move', '-M', '--rename']);
 
 export async function runGit(/** @type {any} */ args, /** @type {any} */ ctx) {
   const command = String(args.command ?? '').trim();
@@ -14,6 +17,11 @@ export async function runGit(/** @type {any} */ args, /** @type {any} */ ctx) {
   if (!GIT_READONLY.has(sub)) {
     return { ok: false, error: `git ${sub} 不是只读子命令（仅支持 ${[...GIT_READONLY].join(' / ')}）。写操作请用 bash 并注意授权。` };
   }
+  // P1-8（v0.4.5）：拒绝破坏性/越界 flag——`--no-index` 越界读、`--output` 写、`-D/-d/-f/-m` 破坏元数据
+  const banned = argv.find((/** @type {string} */ a) => BANNED_FLAGS.has(a) || a.startsWith('--output='));
+  if (banned) {
+    return { ok: false, error: `git ${sub} 含被禁止的参数 ${banned}——只读工具不允许写文件/越界读/破坏元数据（写操作请用 bash）。` };
+  }
   // 追加默认防超大输出：log/diff 限量（除非模型显式给了 -n/--max-count）——
   // v0.4.1 P2 修复：此前注释声明限量但无实现，git log -p 在大型仓库会撞 maxBuffer 4MB 报 ENOBUFS。
   let effectiveArgv = argv;

package/src/web/server.js

@@ -85,15 +85,30 @@ function readBody(req, limit = 40 * 1024 * 1024) {
     /** @type {any[]} */
     const chunks = [];
     let size = 0;
+    let settled = false;
+    const settle = (/** @type {any} */ fn, /** @type {any} */ v) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(slowTimer);
+      fn(v);
+    };
     // 审计 P2-6：慢速连接防护——60s 未传完请求体即断开，防占满 socket
     const slowTimer = setTimeout(() => {
       const err = /** @type {Error & { status?: number }} */ (new Error('请求体上传超时（60s）'));
       err.status = 408;
       req.destroy();
-      reject(err);
+      settle(reject, err);
     }, 60000);
-    req.on('end', () => clearTimeout(slowTimer));
-    req.on('close', () => clearTimeout(slowTimer));
+    // P1-6（v0.4.5）：body 上传中断（客户端刷新/abort）时 Node 通常只触发 close 不发 error/end——
+    // 此前 close 仅 clearTimeout 不 reject → Promise 永久 pending → /api/chat 的 inflight 槽永久泄漏，
+    // 重复 N 次后服务对所有会话 429。close 且未 settle 时 reject（status 499）。
+    req.on('close', () => {
+      if (!settled) {
+        const err = /** @type {Error & { status?: number }} */ (new Error('请求体上传中断（客户端断开）'));
+        err.status = 499;
+        settle(reject, err);
+      }
+    });
     req.on('data', (/** @type {any} */ d) => {
       size += d.length;
       if (size > MAX_BODY) {
@@ -102,7 +117,7 @@ function readBody(req, limit = 40 * 1024 * 1024) {
         // 排空残余数据但保留连接：让上层 catch 返回真 413（此前 destroy 导致客户端只收到连接重置）
         req.pause();
         req.resume();
-        reject(err);
+        settle(reject, err);
         return;
       }
       chunks.push(d);
@@ -110,12 +125,12 @@ function readBody(req, limit = 40 * 1024 * 1024) {
     req.on('end', () => {
       const raw = Buffer.concat(chunks).toString('utf8');
       try {
-        resolve(raw ? JSON.parse(raw) : {});
+        settle(resolve, raw ? JSON.parse(raw) : {});
       } catch {
-        resolve({});
+        settle(resolve, {});
       }
     });
-    req.on('error', reject);
+    req.on('error', (/** @type {any} */ e) => settle(reject, e));
   });
 }
 
@@ -513,14 +528,15 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
       return;
     }
     // v0.4.4：长任务费用逐轮入账——记录已按轮入账的累计 usage，最终补记最后一轮 + 兜底总结的剩余。
+    // v0.4.5：onUsage 收 (modelName, delta)——主/子代理各自按实际模型归属（子代理经 spawnTask 透传，费用不漏计）。
     const recorded = { prompt_tokens: 0, completion_tokens: 0, prompt_cache_hit_tokens: 0, prompt_cache_miss_tokens: 0 };
-    const onUsage = (/** @type {any} */ delta) => {
+    const onUsage = (/** @type {string} */ modelName, /** @type {any} */ delta) => {
       recorded.prompt_tokens += delta?.prompt_tokens || 0;
       recorded.completion_tokens += delta?.completion_tokens || 0;
       recorded.prompt_cache_hit_tokens += delta?.prompt_cache_hit_tokens || 0;
       recorded.prompt_cache_miss_tokens += delta?.prompt_cache_miss_tokens || 0;
       try {
-        recordUsage(runModel, delta, null);
+        recordUsage(modelName, delta, null);
       } catch {}
     };
     const agent = createAgent({