mingdao-harness 0.4.3 → 0.4.5

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,26 +195,32 @@ 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;
   });
 }
 
 export function resumeSchedule(/** @type {any} */ home, /** @type {any} */ id) {
-  const job = readSchedule(home, id);
-  if (!job || job.status !== 'paused') return false;
-  let next = job.nextRunAt;
-  if (job.kind === 'every') {
-    next = job.anchor ? nextAnchorAfter(job.anchor, job.interval) || Date.now() + job.interval : Date.now() + job.interval;
-  } else if (job.kind === 'once') {
-    if (next && next <= Date.now()) next = Date.now() + 30000; // 已过期的一次性任务恢复后 30s 执行
-  } else next = Date.now();
-  const nextJob = { ...job, status: 'pending', nextRunAt: next };
-  writeSchedule(home, nextJob);
-  // 审计修复：守护进程在时只更新状态交给 daemon 接管；否则旧式 sleeper 兜底（避免双跑）
-  if (process.env.MINGDAO_NO_DAEMON === '1' || !daemonAlive(home)) spawnSleeper(home, nextJob);
-  return true;
+  // 评估 6.3（v0.4.3）：读-改-写序列加锁，与 remove/pause 及 sleeper 状态写互斥（防丢更新）
+  return withFileLockSync(path.join(scheduleDir(home), '.lock'), () => {
+    const job = readSchedule(home, id);
+    if (!job || job.status !== 'paused') return false;
+    let next = job.nextRunAt;
+    if (job.kind === 'every') {
+      next = job.anchor ? nextAnchorAfter(job.anchor, job.interval) || Date.now() + job.interval : Date.now() + job.interval;
+    } else if (job.kind === 'once') {
+      if (next && next <= Date.now()) next = Date.now() + 30000; // 已过期的一次性任务恢复后 30s 执行
+    } else next = Date.now();
+    const nextJob = { ...job, status: 'pending', nextRunAt: next };
+    writeSchedule(home, nextJob);
+    // 审计修复：守护进程在时只更新状态交给 daemon 接管；否则旧式 sleeper 兜底（避免双跑）
+    if (process.env.MINGDAO_NO_DAEMON === '1' || !daemonAlive(home)) spawnSleeper(home, nextJob);
+    return true;
+  });
 }
 
 // 每日锚点：锚点时刻（HH:MM）对齐到 now 之后的最近一次
@@ -351,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) {
@@ -373,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) {
@@ -403,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;
   };
 
@@ -435,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'), () => {
@@ -453,10 +480,15 @@ 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();
-      const cur2 = readSchedule(home, id);
-      if (cur2) writeSchedule(home, { ...cur2, status: result });
+      // 评估 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 || cur2.status === 'paused') return;
+        writeSchedule(home, { ...cur2, status: result });
+      });
       return;
     } else {
       // after：轮询依赖，满足即执行一次后结束；任一依赖失败则跳过
@@ -466,13 +498,22 @@ 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();
-      const cur2 = readSchedule(home, id);
-      if (cur2) writeSchedule(home, { ...cur2, status: result });
+      // 评估 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 || 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

@@ -68,7 +68,7 @@ export async function runWorkerTask(id, question, { permission, model, offpeak }
           if (mcpManager) mcpManager.stop();
         },
       };
-      startMcpServers(cfg.mcpServers, workingDir).then((m) => (mcpManager = m)).catch(() => {});
+      startMcpServers(cfg.mcpServers, workingDir, cfg).then((m) => (mcpManager = m)).catch(() => {});
     }
     const sessionRef = /** @type {{name: any}} */ ({ name: null });
     let persistedCount = 0;
@@ -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/app.js

@@ -399,10 +399,14 @@ async function send(){
       else if(ev.type==='done'){ console.log('[MingDao] done 事件：session=' + ev.session); onActivity(); if(ev.budget){ const b=ev.budget; if(hintTextEl) hintTextEl.textContent='预算 '+Math.round(b.used/1000)+'K/'+Math.round(b.total/1000)+'K（'+Math.round(b.used/b.total*100)+'%）· 本轮完成 · 提示栏右侧为今日费用与命中率'; } refreshStatusBar(); if(ev.stats&&ev.stats.deliverables&&ev.stats.deliverables.length){ const card=document.createElement('div'); card.className='deliver'; card.innerHTML='<div class="t">📦 交付物（'+ev.stats.deliverables.length+' 个文件）</div>'+ev.stats.deliverables.map(f=>'<div class="i">'+esc(f)+(f.toLowerCase().endsWith('.html')?' <span style="color:var(--accent2)">— 浏览器打开即可运行</span>':'')+'</div>').join(''); msg.appendChild(card); } if(ev.note){ const d=document.createElement('div'); d.className='errline'; d.style.color='var(--warn)'; d.textContent=ev.note; msg.appendChild(d); } currentSession=ev.session; update(); refreshSessions(); updateTasksPanel(); }
     });
   }catch(e){ onActivity(); // 诊断（v0.4.2 network error 排查）：静默中断此前无任何日志，无法区分
-    // 「手点停止 / 看门狗 / fetch 流静默断裂」。补记完整错误形态 + 回合状态，下次失败可定位。
-    console.error('[MingDao] chat 流异常', { name: e && e.name, message: e && e.message, err: String(e), taskId, rawLen: raw.length, steps: stepsCount, elapsedS: Math.round((Date.now() - workT0) / 1000) });
+    // 「手点停止 / 看门狗 / fetch 流静默断裂」。v0.4.3 修：第二参改 JSON 字符串——Electron 日志
+    // 对对象只会落 [object Object]，异常细节丢失。
+    const diag = { name: e && e.name, message: e && e.message, err: String(e), taskId, rawLen: raw.length, steps: stepsCount, elapsedS: Math.round((Date.now() - workT0) / 1000) };
+    console.error('[MingDao] chat 流异常 ' + JSON.stringify(diag));
     const d=document.createElement('div'); d.className='errline';
-    d.textContent=(e&&e.name==='AbortError')?(killedByWatchdog?'响应超时已中断（120 秒无任何响应），请重试':'已中断'):((e&&e.message)||('连接中断，本轮未完成。已执行的工作已保存检查点——直接发送「继续」即可从断点续跑（' + Math.round((Date.now() - workT0) / 1000) + 's · ' + stepsCount + ' 步）。'));
+    // 统一 catch 文案（v0.4.3）：非用户中断/看门狗时，无论有无 e.message 都优先给「可续跑」的友好提示，
+    // 具体错误形态已进日志（fetch failed 等不再绕开续跑提示）。
+    d.textContent=(e&&e.name==='AbortError')?(killedByWatchdog?'响应超时已中断（120 秒无任何响应），请重试':'已中断'):('连接中断，本轮未完成。已执行的工作已保存检查点——直接发送「继续」即可从断点续跑（' + Math.round((Date.now() - workT0) / 1000) + 's · ' + stepsCount + ' 步）。');
     msg.appendChild(d); scroll(); }
   finally{ clearInterval(hintTimer); disarm(); generating=false; setBtn(); curTaskId=null; curPhase='模型推理中'; console.log('[MingDao] 回合收尾：generating=false，按钮恢复发送'); hintEl.classList.remove('working'); if(hintTextEl) hintTextEl.textContent=defaultHint; pending=false; content.innerHTML=renderMarkdown(raw); attachTrajMeta(msg); activeAiMsg=null; curWorkT0=0; renderWorkStatus(); scroll(); updateTasksPanel(); }
 }
@@ -583,10 +587,17 @@ setInterval(updateTasksPanel, 2000);
 async function refreshCostBadge(){
   const r=await fetch('/api/cache-stats',{cache:'no-store'}).catch(()=>null); if(!r) return;
   const j=await r.json().catch(()=>null); if(!j) return;
-  const bd=j.breakdown||{}; const gd=j.guard||null;
-  let t='📊 今日 ≈¥'+(bd.today||0).toFixed(4);
-  if(bd.rate!=null) t+=' · 命中 '+(bd.rate*100).toFixed(0)+'%';
-  if(gd&&gd.limit>0&&gd.cost!=null) t+=' · 护栏 '+(gd.cost/gd.limit*100).toFixed(0)+'%';
+  const bd=j.breakdown||{}; const gd=j.guard||null; const sm=j.summary||{};
+  // v0.4.3：本地/自定义模型无定价时费用恒 0——此前显示「¥0.0000」被误读为「无统计」。
+  // 有用量但累计费用为 0 即判定为无计价模型，明确标注而非含糊 ¥0。
+  let t;
+  if ((sm.turns||0) > 0 && (bd.totalCost||0) === 0) {
+    t='📊 本地模型不计费 · 累计 ↑'+(sm.prompt||0)+' ↓'+(sm.completion||0)+' tokens';
+  } else {
+    t='📊 今日 ≈¥'+(bd.today||0).toFixed(4);
+    if(bd.rate!=null) t+=' · 命中 '+(bd.rate*100).toFixed(0)+'%';
+    if(gd&&gd.limit>0&&gd.cost!=null) t+=' · 护栏 '+(gd.cost/gd.limit*100).toFixed(0)+'%';
+  }
   $('#costBadge').textContent=t;
   if($('#dashPanel').style.display==='flex') renderDashboard(j);
 }

package/src/web/attachments.js

@@ -30,7 +30,8 @@ export function buildUserContent(/** @type {any} */ message, /** @type {any} */
     } else if (a.type === 'text') {
       const content = String(a.content ?? '');
       if (!content.trim()) continue;
-      if (content.length > MAX_TEXT_BYTES) {
+      // 评估 6.7（v0.4.3）：上限按字节数而非字符数（中文每字 3 字节，字符数口径会放大到声明值 3 倍）
+      if (Buffer.byteLength(content, 'utf8') > MAX_TEXT_BYTES) {
         return { error: `文本文件过大：${a.name || '未命名'}（≤200KB）` };
       }
       finalText += `${finalText ? '\n\n' : ''}[文件 ${a.name || '未命名'}]\n${content}`;

package/src/web/routes/domains/workspace.js

@@ -85,6 +85,9 @@ export async function handle({ req, res, method, p, url }, deps, shared) {
   if (method === 'GET' && p === '/api/fs-browse') {
     let dir = String(url.searchParams.get('dir') || '').trim();
     if (!path.isAbsolute(dir)) return json(res, 400, { error: '需要绝对路径' });
+    // 评估 6.1（v0.4.3）：先 path.resolve 消解 .. 段，再做前缀比较与 stat/readdir——此前字符串
+    // 前缀比较用未规范化的 dir，`/home/u/../../etc` 能通过 startsWith('/home/u/') 但 stat 解析到 /etc。
+    dir = path.resolve(dir);
     // 质检 A3：目录浏览限定基目录，拒绝越界。Windows（CodeArts 报告）：家目录覆盖整个用户配置树
     // （AppData 等）——收紧为 桌面/文档/下载 三常用目录 + 启动目录 + 工作目录 + web.browseRoots 显式授权；
     // 路径比较在 win32 下大小写归一（D:\\ vs d:\\ 不再误拒）。