mingdao-harness 0.2.8 → 0.3.1

package/src/memory.js

@@ -8,6 +8,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { mingdaoHome, ensureHome } from './config.js';
 import { beijingParts } from './pricing.js';
+import { tokenize } from './session-index.js';
 
 export function memoryFile() {
   return path.join(mingdaoHome(), 'AGENTS.md');
@@ -216,11 +217,164 @@ 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 loadProjectMemoryEntries(/** @type {any} */ workingDir) {
+  return loadProjectMemory(workingDir)
+    .split('\n')
+    .map((/** @type {any} */ l) => l.trim())
+    .filter(Boolean);
+}
+
+// 零依赖语义检索：与 query 分词（ASCII 词 + 中文 bigram）的 Jaccard 相似度取 TopN 相关条目。
+// 用于「记忆/日志从最近 N 条 → 相关 N 条」（v0.3.1），换会话/换任务只注入相关记忆、省 token。
+export function retrieveRelevant(/** @type {any[]} */ entries, /** @type {any} */ query, /** @type {number} */ topN = 5) {
+  const qTerms = new Set([...tokenize(String(query || '')).keys()]);
+  if (!qTerms.size) return entries.slice(0, topN);
+  const scored = entries.map((/** @type {any} */ e) => {
+    const text = typeof e === 'string' ? e : String(e.text || e.outcome || e.firstUser || e.content || '');
+    const terms = tokenize(text);
+    if (!terms.size) return { e, score: 0 };
+    let overlap = 0;
+    for (const t of terms.keys()) if (qTerms.has(t)) overlap += 1;
+    const union = new Set([...qTerms, ...terms.keys()]).size || 1;
+    return { e, score: overlap / union };
+  });
+  scored.sort((/** @type {any} */ a, /** @type {any} */ b) => b.score - a.score);
+  return scored.filter((/** @type {any} */ s) => s.score > 0).slice(0, topN).map((/** @type {any} */ s) => s.e);
+}
+
+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 || '';
   try {
-    const wsName = null; // 由调用方通过 currentWorkspace 提供会更好，这里保持轻量
+    // v0.3.1 P1-3 修复：journal 归属信息——优先工作空间名，回退目录 basename（不再恒 null）
+    let wsName = null;
+    try {
+      const { workspaceForDir } = await import('./workspace.js');
+      wsName = workspaceForDir(workingDir)?.name || (workingDir ? path.basename(workingDir) : null);
+    } catch {
+      wsName = workingDir ? path.basename(workingDir) : null;
+    }
     appendJournal(home, {
       at: Date.now(),
       workspace: wsName,
@@ -239,4 +393,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/redact.js

@@ -0,0 +1,26 @@
+// 统一脱敏（v0.3.1 P1-1 修复）：审计/日志/会话/诊断/错误消息共用同一套规则，消除「各层自扫门前雪」。
+//  - redactSecrets：密钥脱敏（常见前缀 + Bearer + URL 内嵌凭据），保留路径便于排查 → 审计/日志用
+//  - redactSensitive：在 redactSecrets 之上再加私网 IP + 家目录路径掩码 → 诊断包/对外输出用
+import os from 'node:os';
+
+// 常见密钥前缀（GitHub/OpenAI/AWS/Slack/Google 等）；sk- 保留前缀、其余整体掩码
+const KEY_PREFIX = /(ghp_[A-Za-z0-9]{20,}|gho_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|AKIA[A-Z0-9]{16}|xox[baprs]-[A-Za-z0-9-]{10,}|AIza[A-Za-z0-9_-]{30,})/g;
+
+export function redactSecrets(/** @type {any} */ text) {
+  let s = String(text ?? '');
+  s = s.replace(/(sk-[A-Za-z0-9_-]{6,})/g, 'sk-***'); // 保留 sk- 前缀（兼容审计标记）
+  s = s.replace(KEY_PREFIX, '***');
+  s = s.replace(/(Authorization\s*:\s*Bearer\s+)[^\s"',}]+/gi, '$1***');
+  s = s.replace(/((?:api[_-]?key|token|secret|password|passwd|access_token)\s*[=:]\s*["']?)[^\s"',}]+/gi, '$1***');
+  s = s.replace(/([?&](?:key|token|secret|api_key|access_token)=)[^&\s"']+/gi, '$1***');
+  return s;
+}
+
+export function redactSensitive(/** @type {any} */ text) {
+  let s = redactSecrets(text);
+  s = s.replace(/\b(?:10|127)(?:\.\d{1,3}){3}\b|\b192\.168(?:\.\d{1,3}){2}\b|\b169\.254(?:\.\d{1,3}){2}\b|\b172\.(?:1[6-9]|2\d|3[01])(?:\.\d{1,3}){2}\b|\b100\.(?:6[4-9]|[7-9]\d|1[01]\d|12[0-7])(?:\.\d{1,3}){2}\b/g, '[私网IP]');
+  s = s.replace(/(?:fe80:[\da-f:]+|::1|::)/gi, '[链路本地/回环IPv6]');
+  const home = os.homedir();
+  if (home && home.length > 1) s = s.split(home).join('~');
+  return s;
+}

package/src/task-state.js

@@ -0,0 +1,77 @@
+// 任务检查点（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 {}
+}
+
+// 合并落盘（v0.3.1 P2-3 修复）：续跑再中断时保留原始 goal、合并 artifacts，只更新 progress/status。
+// 避免「第二次续跑」时把 goal 覆盖成「继续」、把已交付文件清单清零。
+/** @param {any} sessionName @param {any} ts */
+export function saveTaskStateMerge(sessionName, ts) {
+  const prev = loadTaskState(sessionName);
+  const prevUnfinished = prev && (prev.status === 'cap' || prev.status === 'interrupted');
+  const merged = prevUnfinished
+    ? {
+        goal: prev.goal || ts.goal,
+        artifacts: [...new Set([...(Array.isArray(prev.artifacts) ? prev.artifacts : []), ...(Array.isArray(ts.artifacts) ? ts.artifacts : [])])],
+        progress: ts.progress || prev.progress,
+        status: ts.status,
+        updatedAt: ts.updatedAt,
+      }
+    : ts;
+  saveTaskState(sessionName, merged);
+}
+
+// 续跑提示：注入到消息历史，让模型先核对现状（已完成文件不重做）、再做未完成部分。
+/** @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/fetch.js

@@ -0,0 +1,56 @@
+// HTTP 只读抓取工具（v0.3.1）：GET 任意 http(s) URL，返回文本（512KB 上限，正文截 20K）。
+// SSRF 防护：字面量私网/回环拒绝 + DNS 解析复检（防域名重绑定），口径与 server.js validateRemoteUrl 一致。
+import { lookup } from 'node:dns/promises';
+
+function isPrivateHost(/** @type {string} */ hostname) {
+  let h = String(hostname || '').toLowerCase();
+  if (!h) return true;
+  h = h.replace(/^\[|\]$/g, '');
+  if (h === 'localhost' || h.endsWith('.localhost') || h === '::1') return true;
+  if (h.includes(':')) {
+    if (/^::ffff:/.test(h)) return isPrivateHost(h.slice(7));
+    return /^fe[89ab]/.test(h) || /^f[c d]/.test(h) || h === '::' || h === '::1';
+  }
+  const m = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (!m) return false;
+  const a = Number(m[1]);
+  const b = Number(m[2]);
+  return a === 10 || a === 127 || a === 0 || a >= 224 || (a === 169 && b === 254) || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || (a === 100 && b >= 64 && b <= 127);
+}
+
+export async function runFetch(/** @type {any} */ args, /** @type {any} */ _ctx) {
+  const raw = String(args.url ?? '').trim();
+  if (!raw) return { ok: false, error: '缺少 url 参数。' };
+  let u;
+  try {
+    u = new URL(raw);
+  } catch {
+    return { ok: false, error: 'url 必须是合法的 http(s) URL。' };
+  }
+  if (u.protocol !== 'http:' && u.protocol !== 'https:') return { ok: false, error: '仅支持 http/https 地址。' };
+  const host = String(u.hostname || '').toLowerCase();
+  let blocked = isPrivateHost(host);
+  if (!blocked && host && host !== 'localhost' && !/^\d{1,3}(\.\d{1,3}){3}$/.test(host)) {
+    try {
+      const addrs = await lookup(host, { all: true, verbatim: true });
+      blocked = addrs.some((/** @type {any} */ a) => isPrivateHost(a.address));
+    } catch {
+      // DNS 解析失败：放行，连接阶段会报错
+    }
+  }
+  if (blocked) return { ok: false, error: `拒绝访问内网/本机地址（${host}）——SSRF 防护。` };
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), 15000);
+  try {
+    const res = await fetch(u, { signal: ac.signal, redirect: 'follow' });
+    const buf = await res.arrayBuffer();
+    clearTimeout(timer);
+    if (buf.byteLength > 512 * 1024) return { ok: false, error: `响应超过 512KB 上限（实际 ${buf.byteLength} 字节）。` };
+    const text = new TextDecoder('utf-8').decode(buf);
+    const truncated = text.length > 20000;
+    return { ok: true, status: res.status, contentType: res.headers.get('content-type') || '', output: (truncated ? text.slice(0, 20000) + '\n…[正文过长已截断，共 ' + text.length + ' 字符]' : text) || '（空响应）' };
+  } catch (/** @type {any} */ err) {
+    clearTimeout(timer);
+    return { ok: false, error: '抓取失败：' + (err?.name === 'AbortError' ? '超时（15s）' : String(err?.message || err)) };
+  }
+}

package/src/tools/git.js

@@ -0,0 +1,31 @@
+// git 只读工具（v0.3.1）：只允许只读子命令（status/log/diff/show/blame/rev-parse/branch/tag/ls-files/shortlog），
+// 经 execFile 无 shell 执行（防注入），运行于 ctx.workingDir，输出与退出码结构化返回。
+import { execFile } from 'node:child_process';
+
+const GIT_READONLY = new Set(['status', 'log', 'diff', 'show', 'blame', 'rev-parse', 'branch', 'tag', 'ls-files', 'shortlog']);
+
+export async function runGit(/** @type {any} */ args, /** @type {any} */ ctx) {
+  const command = String(args.command ?? '').trim();
+  if (!command) {
+    return { ok: false, error: `缺少 command 参数。只读子命令：${[...GIT_READONLY].join(' / ')}` };
+  }
+  const argv = command.split(/\s+/).filter(Boolean);
+  const sub = argv[0];
+  if (!GIT_READONLY.has(sub)) {
+    return { ok: false, error: `git ${sub} 不是只读子命令（仅支持 ${[...GIT_READONLY].join(' / ')}）。写操作请用 bash 并注意授权。` };
+  }
+  // 追加默认防超大输出：log/diff 限量（除非模型显式给了 -n/--max-count）
+  const cwd = ctx.workingDir || process.cwd();
+  try {
+    const { stdout, stderr } = await execFile('git', argv, {
+      cwd,
+      timeout: 15000,
+      maxBuffer: 4 * 1024 * 1024,
+    });
+    const out = String(stdout || '') + String(stderr || '');
+    return { ok: true, exitCode: 0, output: out.trim() || '（无输出）' };
+  } catch (/** @type {any} */ err) {
+    const e = /** @type {any} */ (err);
+    return { ok: false, error: String(e.stderr || e.message || err).trim(), exitCode: e.code };
+  }
+}

package/src/tools/index.js

@@ -3,10 +3,12 @@
 
 import { read, write, edit, ls, glob, grep, undo } from './fs-tools.js';
 import { runBash } from './bash.js';
+import { runGit } from './git.js';
+import { runFetch } from './fetch.js';
 import { listSkills, loadSkill } from '../skills.js';
 
 // 只读工具集合的单一来源：permissions.js 引用此导出，新增只读工具时只需改这里
-export const READONLY_TOOLS = new Set(['read', 'glob', 'grep', 'ls', 'skill']);
+export const READONLY_TOOLS = new Set(['read', 'glob', 'grep', 'ls', 'skill', 'git', 'fetch']);
 
 const READ_SCHEMA = {
   type: 'object',
@@ -116,6 +118,22 @@ const UNDO_SCHEMA = {
   },
 };
 
+const GIT_SCHEMA = {
+  type: 'object',
+  properties: {
+    command: { type: 'string', description: '只读 git 子命令与参数，如 log --oneline -10、diff HEAD、status、show。' },
+  },
+  required: ['command'],
+};
+
+const FETCH_SCHEMA = {
+  type: 'object',
+  properties: {
+    url: { type: 'string', description: '公网 http(s) 地址。' },
+  },
+  required: ['url'],
+};
+
 const TOOLS = [
   {
     type: 'function',
@@ -205,6 +223,22 @@ const TOOLS = [
       parameters: UNDO_SCHEMA,
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'git',
+      description: '只读 git 查询（status/log/diff/show/blame 等）。写操作请用 bash。',
+      parameters: GIT_SCHEMA,
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'fetch',
+      description: '抓取公网 URL 文本（≤512KB，SSRF 防护拒绝内网）。',
+      parameters: FETCH_SCHEMA,
+    },
+  },
 ];
 
 export function toolSchemas() {
@@ -322,6 +356,10 @@ export async function dispatch(/** @type {any} */ name, /** @type {any} */ args,
       return runTodo(args, ctx);
     case 'undo':
       return undo(args, ctx);
+    case 'git':
+      return runGit(args, ctx);
+    case 'fetch':
+      return runFetch(args, ctx);
     default:
       return { ok: false, error: `未知工具：${name}` };
   }