mingdao-harness 0.2.7 → 0.3.0

package/src/commands/repl.js

@@ -54,6 +54,7 @@ import {
   relativeTime,
   searchSessions,
 } from '../session.js';
+import { loadTaskState, saveTaskState, clearTaskState, resumePrompt } from '../task-state.js';
 
 const pkg = JSON.parse(fs.readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
 
@@ -223,6 +224,12 @@ export async function runRepl(ctx) {
   let messages = hasOldSystem
     ? [{ role: 'system', content: systemPrompt }, ...loadedMsgs.slice(1)]
     : [{ role: 'system', content: systemPrompt }, ...loadedMsgs];
+  // v0.3.0 P0-2：续跑——载入有未完成检查点的会话时注入进度摘要，让模型从断点继续
+  const resumeTs = loadTaskState(path.basename(session.file));
+  if (resumeTs && (resumeTs.status === 'cap' || resumeTs.status === 'interrupted')) {
+    messages.push({ role: 'user', content: resumePrompt(resumeTs) });
+    io.print(style('⚠ 检测到未完成任务，已注入续跑提示（完成后自动清除）。', C.yellow));
+  }
   tuiState.persisted = messages.length;
   let lastUsage = null;
   let lastText = '';
@@ -318,13 +325,16 @@ export async function runRepl(ctx) {
         await switchToModel(target);
       } else if (cmd === '/think') {
         const vals = ['low', 'high', 'max'];
+        const cur = cfg.reasoningByModel?.[modelName] ?? cfg.reasoningEffort ?? '跟随模型默认';
         if (!arg) {
-          io.print(`用法：/think low|high|max|off（当前：${cfg.reasoningEffort || '跟随模型默认 high'}）`);
+          io.print(`用法：/think low|high|max|off（当前：${cur}）`);
           continue;
         }
-        if (arg === 'off') cfg.reasoningEffort = 'off'; // 显式禁用（provider 转 thinking:{type:'disabled'}）
-        else if (vals.includes(arg)) cfg.reasoningEffort = arg;
-        else { io.print(style('无效取值：low|high|max|off', C.red)); continue; }
+        if (arg === 'off' || vals.includes(arg)) {
+          cfg.reasoningByModel = cfg.reasoningByModel || {};
+          cfg.reasoningByModel[modelName] = arg; // 按模型独立：只改当前模型（off 转 thinking:{type:'disabled'}）
+          saveConfig(cfg);
+        } else { io.print(style('无效取值：low|high|max|off', C.red)); continue; }
         agent = createAgent({
           provider, permission, io, modelName, workingDir, cfg,
           undoStore: sessionUndoStore, mcp: mcpFacade, sessionRef,
@@ -333,7 +343,7 @@ export async function runRepl(ctx) {
             tuiState.persisted = msgs.length;
           },
         });
-        io.print(style(`✓ 思考强度：${cfg.reasoningEffort || 'off（模型默认）'}`, C.green));
+        io.print(style(`✓ 思考强度（${modelName}）：${cfg.reasoningByModel[modelName]}`, C.green));
       } else if (cmd === '/plan') {
         planMode = !planMode;
         io.print(style(`✓ 计划模式：${planMode ? '开' : '关'}${planMode ? '（先出计划，确认后执行）' : ''}`, C.green));
@@ -670,6 +680,18 @@ export async function runRepl(ctx) {
           if (renamed) io.print(style(`✓ 会话标题：${path.basename(renamed)}`, C.dim));
         }
       }
+      // v0.3.0 P0-2：跑满步数(capHit)或中断(aborted)落检查点，正常完成清除
+      if (res.capHit || res.aborted) {
+        saveTaskState(path.basename(session.file), {
+          goal: input,
+          progress: res.text || '',
+          artifacts: [],
+          status: res.capHit ? 'cap' : 'interrupted',
+          updatedAt: new Date().toISOString(),
+        });
+      } else {
+        clearTaskState(path.basename(session.file));
+      }
       if (res.aborted) {
         io.print(style('（已中断）', C.dim));
       }

package/src/memory.js

@@ -216,6 +216,126 @@ export async function extractMemory(/** @type {any} */ provider, /** @type {any}
   }
 }
 
+// —— 项目级自动记忆（v0.3.0 P0-3）——
+// 与用户记忆（偏好/约定）区分：项目记忆沉淀「关键决定/事实/结构/教训」，随工作空间走，
+// 换会话/换项目不串。存储：<工作空间>/.mingdao/memory.md（git 可忽略，属本机智能体的项目笔记）。
+export function projectMemoryFile(/** @type {any} */ workingDir) {
+  return path.join(String(workingDir || ''), '.mingdao', 'memory.md');
+}
+
+export function loadProjectMemory(/** @type {any} */ workingDir) {
+  try {
+    return fs.readFileSync(projectMemoryFile(workingDir), 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+export function appendProjectMemory(/** @type {any} */ workingDir, /** @type {any} */ lines) {
+  const add = lines.map((/** @type {any} */ l) => l.trim()).filter(Boolean);
+  if (!add.length || !workingDir) return 0;
+  try {
+    fs.mkdirSync(path.dirname(projectMemoryFile(workingDir)), { recursive: true, mode: 0o700 });
+    const bp = beijingParts(new Date());
+    const date = `${bp.year}-${String(bp.month).padStart(2, '0')}-${String(bp.day).padStart(2, '0')}`;
+    fs.appendFileSync(
+      projectMemoryFile(workingDir),
+      add.map((/** @type {any} */ l) => (l.startsWith('-') ? `- [${date}] ${l.slice(1).trim()}` : `- [${date}] ${l}`)).join('\n') + '\n'
+    );
+    return add.length;
+  } catch {
+    return 0;
+  }
+}
+
+export function dedupeProjectMemory(/** @type {any} */ workingDir) {
+  const raw = loadProjectMemory(workingDir);
+  if (!raw.trim()) return 0;
+  const seen = new Set();
+  const kept = [];
+  let removed = 0;
+  for (const line of raw.split('\n')) {
+    const t = line.trim();
+    if (!t) continue;
+    const norm = t.replace(/^-\s*\[\d{4}-\d{2}-\d{2}\]\s*/, '').trim().toLowerCase();
+    if (seen.has(norm)) { removed += 1; continue; }
+    seen.add(norm);
+    kept.push(t);
+  }
+  if (removed > 0) {
+    try { fs.writeFileSync(projectMemoryFile(workingDir), kept.join('\n') + '\n'); } catch {}
+  }
+  return removed;
+}
+
+// 项目记忆提取：关键决定及其原因、文件/目录结构、依赖与约定、踩过的坑与教训、未完成事项
+export async function extractProjectMemory(/** @type {any} */ provider, /** @type {any} */ model, /** @type {any} */ messages, /** @type {any} */ existing) {
+  try {
+    const convo = messages
+      .filter((/** @type {any} */ m) => m.role === 'user' || m.role === 'assistant')
+      .slice(-20)
+      .map((/** @type {any} */ m) => `${m.role === 'user' ? '用户' : 'MingDao'}：${String(m.content || '').slice(0, 500)}`)
+      .join('\n');
+    const msgs = [
+      {
+        role: 'system',
+        content:
+          '你是 MingDao Harness 的项目记忆提取器。从对话中提取值得长期记住的「项目级事实」：关键决定及其原因、文件/目录结构、依赖与约定、踩过的坑与教训、未完成事项。每条 ≤50 字，只输出新条目（与「已有记忆」重复或对话中未提及的不要输出）。只输出 JSON：{"items": ["条目1", "条目2"]}；没有新增时输出 {"items": []}。\n已有记忆：\n' +
+          (existing || '（空）'),
+      },
+      { role: 'user', content: convo.slice(0, 8000) },
+    ];
+    try {
+      const res = await provider.chat({ model, messages: msgs, tools: [], temperature: 0.2, maxTokens: 250, reasoningEffort: 'low', responseFormat: { type: 'json_object' } });
+      const j = JSON.parse(String(res.text || '').trim());
+      const items = Array.isArray(j?.items) ? j.items : [];
+      const clean = items
+        .map((/** @type {any} */ l) => String(l).trim())
+        .filter(Boolean)
+        .map((/** @type {any} */ l) => (/^[·•]/.test(l) ? '- ' + l.replace(/^[·•]\s*/, '') : l.startsWith('-') ? l : '- ' + l))
+        .slice(0, 10);
+      if (clean.length || items.length === 0) return clean;
+    } catch {}
+    const res = await provider.chat({
+      model,
+      messages: [
+        {
+          role: 'system',
+          content:
+            '你是 MingDao Harness 的项目记忆提取器。从对话中提取值得长期记住的项目级事实（关键决定及原因、结构、依赖约定、教训、未完成事项）。每条一行，以 - 开头，≤50 字，只输出新条目（与「已有记忆」重复或未提及的不要输出）；没有新增就只输出「无新增」。\n已有记忆：\n' +
+            (existing || '（空）'),
+        },
+        { role: 'user', content: convo.slice(0, 8000) },
+      ],
+      tools: [],
+      temperature: 0.2,
+      maxTokens: 300,
+    });
+    const text = String(res.text || '').trim();
+    if (!text || text.includes('无新增')) return [];
+    return text
+      .split('\n')
+      .map((/** @type {any} */ l) => l.trim())
+      .filter((/** @type {any} */ l) => l.startsWith('-') || /^[·•]/.test(l))
+      .map((/** @type {any} */ l) => l.replace(/^[·•]\s*/, '- '))
+      .slice(0, 10);
+  } catch {
+    return [];
+  }
+}
+
+// 项目记忆提取 + 追加（CLI finalizeSession 与 WebUI 收尾共用；配置 autoProjectMemory 默认开）
+export async function extractAndAppendProjectMemory(/** @type {any} */ { cfg, provider, model, messages, workingDir }) {
+  if (!workingDir || cfg?.autoProjectMemory === false) return;
+  try {
+    const existing = loadProjectMemory(workingDir);
+    const { helperProvider } = await import('./providers/index.js');
+    const memProvider = await helperProvider(cfg, model, provider);
+    const lines = await extractProjectMemory(memProvider, model, messages, existing);
+    if (lines.length) appendProjectMemory(workingDir, lines);
+  } catch {}
+}
+
 // 会话收尾：写日志 + 自动记忆（turns 太少的一次性会话只记日志不提取）
 export async function finalizeSession(/** @type {any} */ { cfg, provider, model, home, workingDir, messages, turns, lastText }) {
   const firstUser = messages.find((/** @type {any} */ m) => m.role === 'user')?.content || '';
@@ -239,4 +359,10 @@ export async function finalizeSession(/** @type {any} */ { cfg, provider, model,
       if (lines.length) appendMemory(lines);
     } catch {}
   }
+  // v0.3.0 P0-3：项目级自动记忆（有实际工具工作才提取，避免空话污染项目记忆；
+  // 单轮重型任务也会执行工具，故按「是否有 tool 消息」判定而非 turn 数）
+  const hadToolWork = messages.some((/** @type {any} */ m) => m.role === 'tool');
+  if (workingDir && (hadToolWork || turns >= 2)) {
+    await extractAndAppendProjectMemory({ cfg, provider, model, messages, workingDir });
+  }
 }

package/src/prompts.js

@@ -5,7 +5,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { skillsRegistryBlock } from './skills.js';
 import { mingdaoHome, loadConfig } from './config.js';
-import { recentJournalBlock } from './memory.js';
+import { recentJournalBlock, loadProjectMemory } from './memory.js';
 
 const BASE = `你是 MingDao Harness，一个由 MingDao Harness 驱动的 AI 编程助手。你在用户的电脑上工作：通过工具读写文件、搜索代码、执行命令，帮助用户完成编程、调试与自动化任务。
 
@@ -30,8 +30,8 @@ function loadFile(/** @type {any} */ p, /** @type {any} */ cap) {
   }
 }
 
-/** @param {{ workingDir: any, withJournal?: boolean, [key: string]: any }} opts */
-export function buildSystemPrompt({ workingDir, withJournal = false }) {
+/** @param {{ workingDir: any, withJournal?: boolean, projectMemory?: string, [key: string]: any }} opts */
+export function buildSystemPrompt({ workingDir, withJournal = false, projectMemory }) {
   // 前缀字节稳定性（评估 P1-1/P1-2，四份评估一致的最高价值项）：
   // 系统提示不含「当前模型」「当前日期」等易变字段——DeepSeek 上下文缓存按前缀字节匹配，
   // 路由 pro⇄flash 翻转或跨天会改变前缀 → 整段历史按未命中价重计（命中价的 30 倍）。
@@ -44,6 +44,12 @@ export function buildSystemPrompt({ workingDir, withJournal = false }) {
   const memory = loadFile(path.join(mingdaoHome(), 'AGENTS.md'), 8000);
   if (memory) prompt += `\n\n<user_memory>\n${memory}\n</user_memory>`;
 
+  // 项目级自动记忆（v0.3.0 P0-3）：<工作空间>/.mingdao/memory.md 自动沉淀的决定/事实/教训。
+  // 与 AGENTS.md（手动约定）区分；默认截 4K 保持系统提示前缀稳定，超长可 read 工具按需读。
+  // projectMemory 传入则用「会话内快照」（WebUI 保证同一会话内前缀稳定），否则读文件（CLI/REPL）。
+  const projMem = projectMemory !== undefined ? projectMemory : loadProjectMemory(workingDir);
+  if (projMem) prompt += `\n\n<project_memory>\n${projMem.length > 4000 ? projMem.slice(0, 4000) + '\n…[过长已截断]' : projMem}\n</project_memory>`;
+
   // 最近会话日志（跨会话连续性）：默认不注入——新会话应当全新开始，避免串到
   // 上一次会话的上下文（曾出现「新会话却接着给上个会话的游戏升级」的混淆）。
   // 仅当用户显式开启时注入（WebUI 勾选「带上文」/ CLI --journal）。

package/src/session-index.js

@@ -1,36 +1,71 @@
 // 会话检索索引（P3-2）：词表倒排 + 增量同步，替代每次全量扫描全部会话文件。
-// 索引文件 <mingdao-home>/sessions-index.json：
-//   { files: { "<会话名>": { mtime, size, terms: {词: 次数} } } }
+// 索引分片存储（v0.2.8 B1）：<mingdao-home>/sessions-index/<2位sha1前缀>.json ——
+//   每片 { files: { "<会话名>": { mtime, size, terms: {词: 次数} } } }
+// 分片收益：>1000 会话时不再单次 JSON.parse/stringify 一个巨型索引文件；
+//   同步只重写「变脏」的分片，读/写放大与内存峰值都大幅下降（256 片，每片 ~4 个会话）。
 // 同步策略：查询前对每个会话文件做 mtime/size 对比——未变化直接用缓存词表（O(词表)），
 // 变化/新增才重新分词（增量）；已删除文件自动清理；>8MB 超大文件跳过并移除条目。
 // 分词：英文/数字/路径按词（小写），中文按 bigram + 单字，查询串同口径分词后按 AND 匹配。
 
 import fs from 'node:fs';
 import path from 'node:path';
+import crypto from 'node:crypto';
 import { mingdaoHome, ensureHome } from './config.js';
 import { atomicWriteFileSync } from './atomic-write.js';
 
 const INDEX_MAX_FILE = 8 * 1024 * 1024;
+const SHARD_HEX = 2; // sha1 前 2 个十六进制位 → 256 片
 
-export function sessionIndexFile() {
-  return path.join(mingdaoHome(), 'sessions-index.json');
+/** 分片目录（索引分片统一存放于此） */
+export function shardDir() {
+  return path.join(mingdaoHome(), 'sessions-index');
 }
 
-export function loadSessionIndex() {
+/** 会话名 → 分片名（sha1 前 2 位，稳定且均匀） */
+/** @param {any} name */
+export function shardOf(name) {
+  return crypto.createHash('sha1').update(String(name)).digest('hex').slice(0, SHARD_HEX);
+}
+
+/** @param {any} shard */
+function shardFile(shard) {
+  return path.join(shardDir(), `${shard}.json`);
+}
+
+/** @param {any} shard */
+function loadShard(shard) {
   try {
-    const j = JSON.parse(fs.readFileSync(sessionIndexFile(), 'utf8'));
+    const j = JSON.parse(fs.readFileSync(shardFile(shard), 'utf8'));
     return j && typeof j === 'object' && j.files && typeof j.files === 'object' ? j : { files: {} };
   } catch {
     return { files: {} };
   }
 }
 
-/** @param {any} idx */
-export function saveSessionIndex(idx) {
+/** @param {any} shard @param {any} idx */
+function saveShard(shard, idx) {
   try {
     ensureHome();
-    const target = sessionIndexFile();
-    atomicWriteFileSync(target, JSON.stringify(idx) + '\n'); // 质检 H4：索引原子写
+    const dir = shardDir();
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    atomicWriteFileSync(shardFile(shard), JSON.stringify(idx) + '\n'); // 质检 H4：索引原子写
+  } catch {}
+}
+
+// 一次性迁移：旧版单文件 sessions-index.json → 分片目录（迁移后删除旧文件）
+function migrateLegacyIndex() {
+  const legacy = path.join(mingdaoHome(), 'sessions-index.json');
+  if (!fs.existsSync(legacy)) return;
+  try {
+    const j = JSON.parse(fs.readFileSync(legacy, 'utf8'));
+    const files = j && typeof j === 'object' && j.files && typeof j.files === 'object' ? j.files : {};
+    for (const [name, entry] of Object.entries(files)) {
+      const shard = shardOf(name);
+      const idx = loadShard(shard);
+      idx.files[name] = entry;
+      saveShard(shard, idx);
+    }
+    fs.unlinkSync(legacy);
   } catch {}
 }
 
@@ -81,45 +116,99 @@ export function extractSessionText(file) {
   return parts.join('\n');
 }
 
-// 增量同步索引（对比 mtime/size，只重算变化的文件；清理已删除条目）
-/** @param {any} home @param {any} sessions */
+// 增量同步索引（对比 mtime/size，只重算变化的文件；清理已删除条目）。
+// 返回合并后的 { files: {名称: 词表条目} } 供检索匹配（仍只持有所需词表，不再单次解析巨型文件）。
+/** @param {any} home @param {any} sessions
+ * @returns {{ files: Record<string, any> }} */
 export function syncSessionIndex(home, sessions) {
-  const idx = loadSessionIndex();
+  migrateLegacyIndex();
   const dir = path.join(home, 'sessions');
-  let changed = false;
+  /** @type {{ files: Record<string, any> }} */
+  const combined = { files: {} };
+  const liveShards = new Set();
+
+  // 按分片聚合存活会话：每片只 load 一次，命中/变化只写回该片
+  const byShard = new Map();
   for (const s of sessions) {
-    let st;
-    try {
-      st = fs.statSync(s.file);
-    } catch {
-      delete idx.files[s.name];
+    const k = shardOf(s.name);
+    if (!byShard.has(k)) byShard.set(k, []);
+    byShard.get(k).push(s);
+  }
+
+  for (const [k, group] of byShard) {
+    liveShards.add(k);
+    const idx = loadShard(k);
+    let changed = false;
+    for (const s of group) {
+      let st;
+      try {
+        st = fs.statSync(s.file);
+      } catch {
+        delete idx.files[s.name];
+        changed = true;
+        continue;
+      }
+      const cached = idx.files[s.name];
+      if (cached && cached.mtime === st.mtimeMs && cached.size === st.size) continue; // 未变化：直接用缓存
       changed = true;
-      continue;
+      if (st.size > INDEX_MAX_FILE) {
+        delete idx.files[s.name]; // 超大文件不索引
+        continue;
+      }
+      try {
+        idx.files[s.name] = {
+          mtime: st.mtimeMs,
+          size: st.size,
+          terms: Object.fromEntries(tokenize(extractSessionText(s.file))),
+        };
+      } catch {
+        delete idx.files[s.name];
+      }
     }
-    const cached = idx.files[s.name];
-    if (cached && cached.mtime === st.mtimeMs && cached.size === st.size) continue; // 未变化：直接用缓存
-    changed = true;
-    if (st.size > INDEX_MAX_FILE) {
-      delete idx.files[s.name]; // 超大文件不索引
-      continue;
+    // 清理本片内已删除的会话条目（防索引膨胀）
+    for (const name of Object.keys(idx.files)) {
+      if (!fs.existsSync(path.join(dir, name))) {
+        delete idx.files[name];
+        changed = true;
+      }
     }
-    try {
-      idx.files[s.name] = {
-        mtime: st.mtimeMs,
-        size: st.size,
-        terms: Object.fromEntries(tokenize(extractSessionText(s.file))),
-      };
-    } catch {
-      delete idx.files[s.name];
+    if (changed) saveShard(k, idx);
+    // 合并本片存活条目供检索
+    for (const s of group) {
+      const e = idx.files[s.name];
+      if (e) combined.files[s.name] = e;
     }
   }
-  // 清理已删除的会话条目（防索引无限膨胀）
-  for (const name of Object.keys(idx.files)) {
-    if (!fs.existsSync(path.join(dir, name))) {
-      delete idx.files[name];
-      changed = true;
+
+  // 清理「无存活会话」分片里的陈旧条目（这些片的会话全被删了）：目录扫描逐片检查，
+  // 每片都很小；空片直接删除文件，避免残留索引膨胀
+  let entries = [];
+  try {
+    entries = fs.readdirSync(shardDir());
+  } catch {
+    return combined;
+  }
+  for (const f of entries) {
+    if (!f.endsWith('.json')) continue;
+    const k = f.slice(0, -5);
+    if (liveShards.has(k)) continue;
+    const idx = loadShard(k);
+    let changed = false;
+    for (const name of Object.keys(idx.files)) {
+      if (!fs.existsSync(path.join(dir, name))) {
+        delete idx.files[name];
+        changed = true;
+      }
+    }
+    if (changed) {
+      if (Object.keys(idx.files).length) saveShard(k, idx);
+      else {
+        try {
+          fs.unlinkSync(path.join(shardDir(), f));
+        } catch {}
+      }
     }
   }
-  if (changed) saveSessionIndex(idx);
-  return idx;
+
+  return combined;
 }

package/src/task-state.js

@@ -0,0 +1,59 @@
+// 任务检查点（v0.3.0 P0-2）：把「一轮 24 步跑满即止」升级为「可续跑」。
+// 存储：<mingdao-home>/taskstates/<会话名>.json（独立侧车文件 + 原子写，不污染会话 JSONL 消息结构）。
+// 状态：{ goal, progress, artifacts, status('cap'|'interrupted'), updatedAt }
+//   - cap：本轮跑满步数上限，未完成，可续跑；
+//   - interrupted：用户主动中断（Ctrl+C/停止），可续跑；
+//   - 任务正常完成时清除检查点（clearTaskState）。
+import fs from 'node:fs';
+import path from 'node:path';
+import { mingdaoHome } from './config.js';
+import { atomicWriteFileSync } from './atomic-write.js';
+
+function taskStateDir() {
+  return path.join(mingdaoHome(), 'taskstates');
+}
+
+/** @param {any} sessionName */
+export function taskStateFile(sessionName) {
+  return path.join(taskStateDir(), `${String(sessionName)}.json`);
+}
+
+/** @param {any} sessionName */
+export function loadTaskState(sessionName) {
+  try {
+    const j = JSON.parse(fs.readFileSync(taskStateFile(sessionName), 'utf8'));
+    return j && typeof j === 'object' ? j : null;
+  } catch {
+    return null;
+  }
+}
+
+/** @param {any} sessionName @param {any} ts */
+export function saveTaskState(sessionName, ts) {
+  try {
+    const dir = taskStateDir();
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    atomicWriteFileSync(taskStateFile(sessionName), JSON.stringify(ts) + '\n', { mode: 0o600 });
+  } catch {}
+}
+
+/** @param {any} sessionName */
+export function clearTaskState(sessionName) {
+  try {
+    fs.unlinkSync(taskStateFile(sessionName));
+  } catch {}
+}
+
+// 续跑提示：注入到消息历史，让模型先核对现状（已完成文件不重做）、再做未完成部分。
+/** @param {any} ts */
+export function resumePrompt(ts) {
+  const art = (Array.isArray(ts?.artifacts) && ts.artifacts.length ? ts.artifacts : []).join('、') || '（无）';
+  const progress = String(ts?.progress || '').slice(0, 2000) || '（无总结）';
+  const goal = String(ts?.goal || '').slice(0, 500) || '（未知）';
+  return (
+    `（系统提示）上一个任务「${goal}」因步数上限中断，尚未完成，现在续跑。\n` +
+    `已完成进度摘要：\n${progress}\n` +
+    `已交付文件（勿重复重做，先核对现状）：${art}\n` +
+    `请从断点继续：先确认已完成部分的现状，再完成剩余工作。`
+  );
+}

package/src/tools/fs-tools.js

@@ -3,11 +3,12 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
+import { MAX_FILE_READ_BYTES } from '../web/constants.js';
 
 const MAX_SCAN_FILES = 20000;
 const MAX_GLOB_RESULTS = 1000;
 const MAX_GREP_MATCHES = 250;
-const MAX_FILE_BYTES = 5 * 1024 * 1024;
+const MAX_FILE_BYTES = MAX_FILE_READ_BYTES; // 单源化（v0.2.8 B2）：read/edit 单文件读取上限
 
 /**
  * @param {any} cwd