@xdxer/dingtalk-agent 0.1.0 → 0.1.2

package/src/dws.js

@@ -1,192 +0,0 @@
-// dws 硬化包装 —— 这一层是「拦」。
-//
-// **上面的每个模块都必须走它，不许自己 spawn dws。**
-//
-// ════════════════════════════════════════════════════════════════
-// 【六条工程纪律】—— 每一条都是踩出来的，违反必出错，而且是【静默】出错
-// ════════════════════════════════════════════════════════════════
-//
-// 1. **拿不到就响亮地死，绝不当成"是空的"。**
-//    不同接口把数据藏在不同层级。读错层级 → 拿到 undefined → 当成"表是空的"
-//    → **一整天的数据可以这么无声丢掉，而且不报错。**
-//    「查到 0 条」和「读错地方了」**必须分得开**。分不开就 die。
-//
-// 2. **分页会静默截断。** 默认页大小有上限，超了就悄悄少给你，
-//    **而且不一定有信号告诉你被截断了。**
-//    **拿不到分页信号 ≠ 没有下一页，那叫「没有信号」。**
-//    **半张表算出来的结果是错的，不是"差不多"。**
-//
-// 3. **创建类：报错了也可能其实建成功了。**
-//    **绝不看返回信封** —— 按名回查 + 内容回读定成败。
-//    推论：**创建类永不盲重试**（会造重复件），失败先按幂等键回查。
-//
-// 4. **写操作报错 ≠ 失败。** 回读实态才定成败。返回 success 也不算验收。
-//
-// 5. **字段读写不对称。** 写进去的形状 ≠ 读回来的形状。**写完必回读。**
-//
-// 6. **markdown 会被重排版。重排版不是漂移。**
-//    判漂移必须剥掉 markdown 符号只看文字流 —— 用行级 diff 会每次都误报，
-//    **然后你就会开始无脑 --force，真漂移也一起覆盖掉。**
-//
-// 一句话：**所有这些坑的形状都一样 —— 它不报错，它给你一个看起来很正常的答案。**
-// 这一层做的就是：**把「看起来正常」和「真的正常」分开。**
-
-import { spawnSync } from 'node:child_process'
-
-export class Blocked extends Error {}
-
-export function die(msg) {
-  console.error('[FAIL] ' + msg)
-  throw new Blocked(msg)
-}
-
-const sleep = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms)
-
-/** 跑一条 dws。限流退避；超时不当成"空"；坏响应响亮地死。 */
-export function run(args, { allowFail = false, timeout = 180_000, retries = 2 } = {}) {
-  let last = ''
-  for (let attempt = 0; attempt <= retries; attempt++) {
-    const p = spawnSync('dws', [...args, '--format', 'json'],
-      { encoding: 'utf8', timeout, maxBuffer: 64 * 1024 * 1024 })
-    if (p.error) {
-      if (p.error.code === 'ENOENT') {
-        if (allowFail) return null
-        die('dws 跑不起来 —— 先 export PATH="$HOME/.local/bin:$PATH"')
-      }
-      last = String(p.error); sleep(2000 * (attempt + 1)); continue
-    }
-    const out = p.stdout || p.stderr || ''
-    last = out.slice(0, 300)
-    const i = out.indexOf('{')
-    if (i < 0) { sleep(2000 * (attempt + 1)); continue }
-    let d
-    try { d = JSON.parse(out.slice(i, lastBrace(out) + 1)) }
-    catch { sleep(2000 * (attempt + 1)); continue }
-    const err = d.error || {}
-    if (err && (err.code || err.message)) {
-      const s = JSON.stringify(err).toLowerCase()
-      if (s.includes('limit') || s.includes('frequen') || s.includes('flow')) {
-        sleep(3000 * (attempt + 1)); continue          // 限流 → 退避
-      }
-      if (allowFail) return null
-      die(`dws 失败 ${args.slice(0, 4).join(' ')}\n  ${JSON.stringify(err).slice(0, 300)}`)
-    }
-    return d
-  }
-  if (allowFail) return null
-  die(`dws 无响应(重试 ${retries} 次) ${args.slice(0, 4).join(' ')}\n  ${last}`)
-}
-
-function lastBrace(s) {
-  // dws 有时在 JSON 后面粘一行 WARN / INFO —— 从最后一个 } 截断
-  for (let i = s.length - 1; i >= 0; i--) if (s[i] === '}') return i
-  return s.length - 1
-}
-
-// ──────────────── 三个层级，各读各的 ────────────────
-const inner = (d) => (d && typeof d.data === 'object' && d.data !== null ? d.data : d)
-
-/** 列表类查询的记录。拿不到就 die —— 绝不当成"表是空的"。 */
-export function records(d) {
-  const x = inner(d)
-  if (!('records' in x)) {
-    die(`返回里没有 records(顶层键=${Object.keys(d)}) —— 接口形状可能变了。` +
-        `**绝不把它当成【表是空的】。**`)
-  }
-  if (x.hasMore || x.partial) {
-    die('分页未收敛 —— **部分结果不许当完整结果用。** 半张表算出来的是错的。')
-  }
-  return x.records || []
-}
-
-/** 文档正文。**层级和列表类查询不一样** —— 两种形状都兜住，拿不到就 die。 */
-export function markdown(d) {
-  const md = inner(d).markdown ?? d.markdown
-  if (md === undefined || md === null) {
-    die(`拿不到文档正文(顶层键=${Object.keys(d)}) —— **绝不当成【这篇是空的】。**`)
-  }
-  return md
-}
-
-/** 目录节点。 */
-export const nodes = (d) => inner(d).nodes || []
-
-/**
- * 待办翻页 —— **这是唯一有分页信号的读法。**
- *
- * ⚠️ **不要把页开大**。超过这个大小，分页信号会消失，
- *    你拿到 undefined、当成 false，然后**静默漏掉剩下的**。
- *    心跳的收件靠它 —— 漏了循环件就是「静默收工且不自知」。
- */
-export function todosPage(status = 'false', page = 1) {
-  const d = run(['todo', 'task', 'list', '--status', status, '--size', '20', '--page', String(page)])
-  const r = d.result || {}
-  if (!('todoCards' in r)) {
-    die(`待办返回里没有 todoCards(result 键=${Object.keys(r)}) —— 绝不当成【没有待办】。`)
-  }
-  return { cards: r.todoCards || [], more: Boolean(r.hasMore) }
-}
-
-/** 把待办【拉全】。只看第一页会漏掉循环件。 */
-export function todosAll(status = 'false', maxPages = 20) {
-  const out = []
-  for (let page = 1; page <= maxPages; page++) {
-    const { cards, more } = todosPage(status, page)
-    out.push(...cards)
-    if (!more) return out
-  }
-  die(`待办翻页超过 ${maxPages} 页还没收敛 —— 不许把部分结果当完整。`)
-}
-
-// ──────────────── 创建类：报错也可能成功 → 按名回查 ────────────────
-/** 目录列表可能把扩展名单列，比对时要拼回去。 */
-export function findChild(folder, name) {
-  for (const n of nodes(run(['doc', 'list', '--folder', folder, '--page-size', '50']))) {
-    const nm = n.name || '', ext = n.extension || ''
-    if (nm === name || (ext && `${nm}.${ext}` === name)) return n.nodeId
-  }
-  return null
-}
-
-/** 建文档。**不看返回信封** —— 一律按名回查定成败。 */
-export function createDoc(folder, name, file) {
-  const exist = findChild(folder, name)
-  if (exist) return exist
-  run(['doc', 'create', '--name', name, '--folder', folder,
-       '--content-file', file, '--content-format', 'markdown', '--yes'],
-      { allowFail: true })                     // ← **报错也可能其实成功了**
-  sleep(1200)
-  const nid = findChild(folder, name)
-  if (!nid) die(`建不出文档 ${name} —— 别把它当成【建成功了】。`)
-  return nid
-}
-
-export const updateDoc = (node, file) =>
-  run(['doc', 'update', '--node', node, '--content-file', file,
-       '--content-format', 'markdown', '--mode', 'overwrite', '--yes'])
-
-export const readDoc = (node) => markdown(run(['doc', 'read', '--node', node]))
-export const docInfo = (node) => inner(run(['doc', 'info', '--node', node]))
-
-// ──────────────── 漂移判定：重排版【不是】漂移 ────────────────
-/**
- * 剥掉 markdown 语法和转义装饰，只留【文字本身】。
- *
- * 钉钉会重排版你推上去的 markdown。**重排版不是漂移。**
- * 用行级 diff 判漂移 → 每次 sync 都误报 →
- * **然后你就会开始无脑 --force，真正的漂移也一起覆盖掉了。**
- */
-export function words(s) {
-  let t = String(s ?? '')
-  for (let i = 0; i < 3; i++) t = unescapeHtml(t)     // 可能被多次转义
-  t = t.replace(/&#(\d+);/g, (_, n) => String.fromCharCode(+n))
-  t = t.replace(/\[打开\]\([^)]*\)/g, '')             // 钉钉自动加的链接装饰
-  return t.replace(/[`*_>#|\\~\-\s]+/g, '')
-}
-
-function unescapeHtml(s) {
-  return s.replace(/&(amp|lt|gt|quot|#39);/g, (m, e) =>
-    ({ amp: '&', lt: '<', gt: '>', quot: '"', '#39': "'" })[e])
-}
-
-export const same = (a, b) => words(a) === words(b)

package/src/init.js

@@ -1,84 +0,0 @@
-// init —— 在工作区里铺一个数字员工。
-//
-// 包里带的是【工具 + 行为范式】；本体和运行记录是 init 在【你的工作区】里生成的。
-// 所以这个包能发 npm，而你的 agent 是你自己的 git 仓库。
-
-import { mkdirSync, cpSync, existsSync, writeFileSync, symlinkSync } from 'node:fs'
-import { join, dirname } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import * as cfg from './config.js'
-
-const PKG = dirname(dirname(fileURLToPath(import.meta.url)))
-
-export function init(root) {
-  if (cfg.load(root)) {
-    console.log('已经初始化过了。看看: dingtalk-agent kb list')
-    return
-  }
-
-  // 行为范式（skills）+ 本体模板（ontology/self 三件套）
-  cpSync(join(PKG, 'skills'), join(root, 'skills'), { recursive: true })
-  cpSync(join(PKG, 'templates', 'ontology'), join(root, 'ontology'), { recursive: true })
-  for (const d of ['ontology/sources', 'ontology/wiki', 'runs', '.cache/kb']) {
-    mkdirSync(join(root, d), { recursive: true })
-  }
-
-  // AGENTS.md ← skills/AGENTS.md；CLAUDE.md 是它的符号链接
-  // **任何 Coding Agent 读到的协议完全一致。**
-  const agents = join(root, 'AGENTS.md')
-  if (!existsSync(agents)) {
-    writeFileSync(agents, `<!-- 正本在 skills/AGENTS.md -->\n\n` +
-      `# 先读这个\n\n` +
-      `\`\`\`bash\ndingtalk-agent boot\n\`\`\`\n\n` +
-      `然后读 [skills/AGENTS.md](skills/AGENTS.md) —— 我是谁、我怎么做事。\n\n` +
-      `**BOOT FAIL 时禁答身份/能力/记忆/知识类问题。** 不要猜，不要找替代路径。\n`)
-  }
-  const claude = join(root, 'CLAUDE.md')
-  if (!existsSync(claude)) {
-    try { symlinkSync('AGENTS.md', claude) } catch { cpSync(agents, claude) }
-  }
-
-  const gi = join(root, '.gitignore')
-  if (!existsSync(gi)) {
-    writeFileSync(gi, [
-      '# 知识库缓存：external 的真值在远端，本地这份【可丢弃】',
-      '.cache/',
-      '',
-      '# 运行记录：含对话原文、人名。本地留档，不进仓库',
-      'runs/*',
-      '!runs/.gitkeep',
-      '',
-      '# 配置：含硬 ID，一岗一份',
-      '.dingtalk-agent/',
-      '',
-      '# 原始证据里的敏感原文',
-      'ontology/sources/private/',
-      '',
-      'node_modules/',
-      '.DS_Store',
-      '',
-    ].join('\n'))
-  }
-  writeFileSync(join(root, 'runs', '.gitkeep'), '')
-
-  cfg.save(root, cfg.DEFAULT)
-
-  console.log(`✅ 铺好了
-
-  AGENTS.md         先读这个（CLAUDE.md 是它的符号链接）
-  skills/           行为范式：消息 · 任务 · 心跳 · 知识 · 钉钉 · 评测
-  ontology/self/    ★ 三件套 —— 我是谁 · 工牌 · 工位
-  ontology/wiki/    编译层（越干越有经验的地方）
-  runs/             运行记录（三个硬 ID，反查得到才算数）
-
-接下来三步（**顺序不能换**）:
-
-  1. 填 ontology/self/ 的三件套。**没填完 boot 会拒绝启动。**
-     一个「半个记忆」的员工，比一个明确说「我还没醒」的员工危险得多。
-
-  2. 挂知识库:
-     dingtalk-agent kb mount --name 公司知识库 --from dingtalk:doc:<folderId> --own external
-     dingtalk-agent kb mount --name 本体 --from dingtalk:doc:<folderId> --own owned --local ontology
-
-  3. dingtalk-agent boot     ← 它会【真去摸一遍工位】，拉不到就 BOOT FAIL`)
-}

package/src/kb.js

@@ -1,221 +0,0 @@
-// 知识库挂载与同步。
-//
-// ════════════════════════════════════════════════════════════════════
-// 【核心判断】所有权决定真值方向。
-// ════════════════════════════════════════════════════════════════════
-//
-//                owned（我的本体）           external（别人维护的）
-//   真值在        **Git**（本地）             **钉钉**（远端）
-//   同步方向      push  本地 → 钉钉           pull  钉钉 → 本地
-//   为什么        给人看（人机同源）           给我 grep（快、能看上下文）
-//   冲突了        远端被人改过 → **停**       远端赢，本地缓存可丢弃
-//   落在          ontology/（入 Git）         .cache/kb/<name>/（gitignore）
-//
-// 这就是「Git 内核 × 钉钉暴露层」：**Git 是常量层，钉钉是可替换的暴露层。**
-//
-// ════════════════════════════════════════════════════════════════════
-// 【三个硬约束】—— 全是踩出来的
-// ════════════════════════════════════════════════════════════════════
-//
-// 1. **绝不双向自动 merge。** 一个方向是真值，另一个是投影。
-//    自动合并两个都在变的东西 = 灾难，而且是【静默】灾难。
-//
-// 2. **重排版不是漂移。** 判据是「剥掉 markdown 符号后的文字流」，不是行级 diff。
-//    用行级 diff → 每次 sync 都误报 → **你就会开始无脑 --force，真漂移也一起覆盖掉。**
-//
-// 3. **缓存不新鲜就不许用（fail-closed）。** external KB 是快照。
-//    **拿着过期快照回答，比说「我不知道」危险得多。**
-
-import { mkdirSync, writeFileSync, readFileSync, existsSync, statSync } from 'node:fs'
-import { readdirSync } from 'node:fs'
-import { join, dirname, relative, basename } from 'node:path'
-import { spawnSync } from 'node:child_process'
-import * as dws from './dws.js'
-
-export const OWNED = 'owned', EXTERNAL = 'external'
-export const PULL = 'pull', PUSH = 'push', NONE = 'none'
-
-/** external 缓存超过这么久就算过期。过期 → kb search 会警告并要求先 sync。 */
-export const STALE_HOURS = 24
-
-const now = () => new Date(Date.now() + 8 * 3600e3).toISOString().replace('Z', '+08:00').slice(0, 19)
-
-/** dingtalk:doc:<folderId> · dingtalk:wiki:<spaceId> · local:<path> */
-export function parseSource(s) {
-  let m = /^dingtalk:(doc|wiki):(.+)$/.exec(s)
-  if (m) return { kind: m[1], id: m[2] }
-  m = /^local:(.+)$/.exec(s)
-  if (m) return { kind: 'local', id: m[1].replace(/^~/, process.env.HOME) }
-  throw new Error(
-    `挂载源写错了: ${s}\n` +
-    `  支持三种:\n` +
-    `    dingtalk:doc:<folderId>    文档文件夹（最常见 —— 很多组织根本没建"知识库"）\n` +
-    `    dingtalk:wiki:<spaceId>    钉钉知识库空间\n` +
-    `    local:<路径>               本地目录（只读挂载，比如另一个仓库的 wiki/）`)
-}
-
-// ════════════════ pull：钉钉 → 本地缓存 ════════════════
-function walkDoc(folder, prefix = '') {
-  const out = []
-  for (const n of dws.nodes(dws.run(['doc', 'list', '--folder', folder, '--page-size', '50']))) {
-    const name = n.name || '', nid = n.nodeId
-    if (n.nodeType === 'folder') { out.push(...walkDoc(nid, join(prefix, name))); continue }
-    if (n.contentType && n.contentType !== 'ALIDOC') continue      // 二进制附件不是知识
-    out.push({ rel: join(prefix, name.endsWith('.md') ? name : `${name}.md`),
-               nid, mtime: n.updateTime || 0 })
-  }
-  return out
-}
-
-function walkWiki(space, folder, prefix = '') {
-  const args = ['wiki', 'node', 'list', '--workspace', space, '--limit', '50']
-  if (folder) args.push('--folder', folder)
-  const out = []
-  for (const n of dws.nodes(dws.run(args))) {
-    const name = n.name || '', nid = n.nodeId
-    if (n.nodeType === 'folder' || n.hasChildren) out.push(...walkWiki(space, nid, join(prefix, name)))
-    out.push({ rel: join(prefix, name.endsWith('.md') ? name : `${name}.md`),
-               nid, mtime: n.updateTime || 0 })
-  }
-  return out
-}
-
-/** 钉钉 → 本地缓存。**远端赢**（external 的真值在远端）。增量靠 updateTime。 */
-export function pull(kb, root, force = false) {
-  const { kind, id } = parseSource(kb.from)
-  if (kind === 'local') { console.log(`  local  ${kb.name}  就在本地，不用同步`); return }
-
-  const dest = join(root, kb.local)
-  const items = kind === 'doc' ? walkDoc(id) : walkWiki(id)
-  if (!items.length) {
-    throw new Error(
-      `「${kb.name}」远端一个节点都没有 —— **不许当成【这个知识库是空的】。**\n` +
-      `  可能是: ID 写错 / 没权限 / 它真的空。先用 dws 手工确认再说。`)
-  }
-  kb._state ??= {}
-  let pulled = 0, skipped = 0
-  for (const { rel, nid, mtime } of items) {
-    const p = join(dest, rel)
-    if (!force && kb._state[nid]?.mtime === mtime && existsSync(p)) { skipped++; continue }
-    const md = dws.readDoc(nid)
-    mkdirSync(dirname(p), { recursive: true })
-    // 头三行钉住来源 —— **没有指针的知识，用的时候不敢信。**
-    writeFileSync(p,
-      `<!-- 来自钉钉 · 只读缓存 · 不要在这里改，改了下次 sync 会被覆盖 -->\n` +
-      `<!-- nodeId: ${nid} -->\n<!-- 拉取: ${now()} -->\n\n${md}`)
-    kb._state[nid] = { rel, mtime }
-    pulled++
-  }
-  kb._syncedAt = now()
-  console.log(`  pull   ${kb.name.padEnd(14)} 拉了 ${pulled} 篇 · 没变 ${skipped} 篇`)
-}
-
-// ════════════════ push：本地 → 钉钉（人机同源）════════════════
-function walkLocal(dir, base = dir) {
-  const out = []
-  for (const e of readdirSync(dir, { withFileTypes: true })) {
-    const p = join(dir, e.name)
-    if (e.isDirectory()) { out.push(...walkLocal(p, base)); continue }
-    if (e.name.endsWith('.md')) out.push({ path: p, rel: relative(base, p) })
-  }
-  return out
-}
-
-/**
- * 本地 → 钉钉。**Git 赢**（owned 的真值在 Git）。
- *
- * ⚠️ **推之前先查漂移** —— 远端被人改过就【停下来问】，绝不盲覆盖。
- *    人在钉钉里改了东西，说明他有话要说。**盲覆盖 = 把人的意见删了。**
- */
-export function push(kb, root, force = false) {
-  const { kind, id } = parseSource(kb.from)
-  if (kind !== 'doc') {
-    throw new Error('push 目前只支持 dingtalk:doc:<folderId>（文档文件夹）。\n' +
-                    '  知识库空间的写入面还没验过 —— **不许假装支持。**')
-  }
-  const src = join(root, kb.local)
-  if (!existsSync(src)) throw new Error(`本地目录不存在: ${src}`)
-
-  kb._state ??= {}
-  const drift = []
-  let pushed = 0, unchanged = 0
-
-  for (const { path, rel } of walkLocal(src)) {
-    const body = readFileSync(path, 'utf8')
-    let nid = Object.keys(kb._state).find((k) => kb._state[k].rel === rel)
-    if (!nid) {
-      nid = dws.createDoc(id, basename(rel), path)
-      kb._state[nid] = { rel, pushedWords: dws.words(body) }
-      pushed++; console.log(`    + 新建 ${rel}`); continue
-    }
-    const remote = dws.readDoc(nid)
-    if (dws.same(remote, body)) { unchanged++; continue }
-
-    // 远端 ≠ 我上次推上去的 → **有人在钉钉里改过**
-    const last = kb._state[nid].pushedWords
-    if (last && dws.words(remote) !== last && !force) { drift.push({ rel, nid }); continue }
-
-    dws.updateDoc(nid, path)
-    if (!dws.same(dws.readDoc(nid), body)) {
-      throw new Error(`推了 ${rel} 但回读不一致 —— **写操作报错≠失败，回读定成败。**`)
-    }
-    kb._state[nid].pushedWords = dws.words(body)
-    pushed++; console.log(`    ↑ 更新 ${rel}`)
-  }
-
-  if (drift.length) {
-    console.log(`\n  ⚠️ **远端被人改过**，默认拒绝覆盖（${drift.length} 篇）:`)
-    for (const { rel, nid } of drift) console.log(`      ${rel}   nodeId=${nid}`)
-    console.log(`  人在钉钉里改了东西，说明他有话要说。**先去看一眼**，别盲覆盖。`)
-    console.log(`  确认要覆盖: dingtalk-agent kb sync --name ${kb.name} --force`)
-    const e = new Error('有漂移，拒绝覆盖'); e.exitCode = 1; throw e
-  }
-  kb._syncedAt = now()
-  console.log(`  push   ${kb.name.padEnd(14)} 推了 ${pushed} 篇 · 一致 ${unchanged} 篇`)
-}
-
-// ════════════════ search：跨所有挂载点 ════════════════
-export function stale(kb) {
-  if (kb.own !== EXTERNAL || kb.sync === NONE) return false
-  if (!kb._syncedAt) return true
-  const age = (Date.now() - Date.parse(kb._syncedAt)) / 3600e3
-  return age > STALE_HOURS
-}
-
-/**
- * 跨所有挂载的 KB 搜。**本地 grep 为主** —— 快、确定、能看到上下文。
- *
- * fail-closed：不新鲜的缓存会【警告】。
- * **拿着过期快照回答，比说「我不知道」危险得多。**
- */
-export function search(cfg, root, kw, top = 20) {
-  const hits = [], warned = []
-  for (const kb of cfg.kb || []) {
-    const base = kb.local.startsWith('/') ? kb.local : join(root, kb.local)
-    if (!existsSync(base)) continue
-    if (stale(kb)) warned.push(kb.name)
-    const r = spawnSync('grep', ['-ril', '--include=*.md', kw, base], { encoding: 'utf8' })
-    for (const p of (r.stdout || '').split('\n').filter(Boolean)) {
-      const ctx = spawnSync('grep', ['-i', '-n', '-m', '2', kw, p], { encoding: 'utf8' }).stdout || ''
-      hits.push({ kb: kb.name, file: relative(root, p), ctx: ctx.trim() })
-    }
-  }
-
-  if (warned.length) {
-    console.log(`⚠️ 这些知识库的缓存【超过 ${STALE_HOURS} 小时没同步】了: ${warned.join('、')}`)
-    console.log(`   **拿着过期快照回答，比说「我不知道」危险得多。**`)
-    console.log(`   先跑: dingtalk-agent kb sync\n`)
-  }
-  if (!hits.length) {
-    console.log(`没搜到「${kw}」。`)
-    console.log(`**搜不到就说搜不到 —— 不要编。** 挂了哪些库: dingtalk-agent kb list`)
-    return []
-  }
-  console.log(`命中 ${hits.length} 处:`)
-  for (const h of hits.slice(0, top)) {
-    console.log(`\n── [${h.kb}] ${h.file}`)
-    for (const l of h.ctx.split('\n').slice(0, 2)) console.log(`     ${l.slice(0, 110)}`)
-  }
-  console.log(`\n**别只看这几行就作答** —— 打开命中的那一页读完再说。`)
-  return hits
-}

package/src/runs.js

@@ -1,77 +0,0 @@
-// 留痕与集中进化 —— runs/YYYY-MM-DD.md，一天一档 jsonl。
-//
-// 每行钉住【三个硬 ID】—— 出问题才反查得到：
-//   issue → 平台派单 id，翻得出整个运行过程
-//   conv  → 会话 id，**filter 得出整条对话流（这就是训练素材）**
-//   msg   → 触发消息 id，定位到那一句
-// **缺了这三个，记录就只是一堆"我做了什么"，出了问题什么也追不到。**
-//
-// r  = 【引擎层】成败（跑通没有）
-// fb = 【用户层】成败（主人认不认）
-// **两者必须分开** —— 引擎跑通 ≠ 答对 ≠ 主人满意。
-// 只看 r，你会看到一片绿，然后什么也进化不了。
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'node:fs'
-import { join } from 'node:path'
-
-export const FB_OK = '认可', FB_MORE = '追问', FB_FIX = '纠正'
-const MARKER = 'AGENT_RUN_LOG_V1'
-
-const cst = (d = new Date()) => new Date(d.getTime() + 8 * 3600e3)
-export const today = () => cst().toISOString().slice(0, 10)
-export const now = () => cst().toISOString().replace('Z', '+08:00').slice(0, 19)
-export const todayZero = () => today() + 'T00:00:00+08:00'
-
-/** 【今晚跑过没有】= 数据水位 ≥ 今天 00:00。纯【数据派生】——
- *  不记状态、不建标记文件、不看会话记忆。重启/换实例/漏拍都不受影响。 */
-export const ranTonight = (wm) => Boolean(wm) && String(wm) >= todayZero()
-
-const file = (root, day) => join(root, 'runs', `${day}.md`)
-
-export function read(root, day) {
-  const p = file(root, day)
-  if (!existsSync(p)) return []
-  const out = []
-  for (const line of readFileSync(p, 'utf8').split('\n')) {
-    const s = line.trim()
-    if (!s.startsWith('{')) continue
-    try { out.push(JSON.parse(s)) }
-    catch { console.error(`  ⚠️ 运行记录有坏行，跳过但【不当成空】: ${s.slice(0, 60)}`) }
-  }
-  return out
-}
-
-export function write(root, day, rows) {
-  mkdirSync(join(root, 'runs'), { recursive: true })
-  const body = rows.map((r) => JSON.stringify(r)).join('\n')
-  writeFileSync(file(root, day), `${MARKER} · ${day}\n\n\`\`\`jsonl\n${body}\n\`\`\`\n`)
-}
-
-/** 追加一行 + 回读校验。**写了没落上 = 这次没发生过，要说出来。** */
-export function append(root, row) {
-  const day = today()
-  const rows = read(root, day)
-  rows.push(row)
-  write(root, day, rows)
-  const ok = read(root, day).some((r) => r.t === row.t && r.did === row.did)
-  if (!ok) console.error('  ⚠️ 运行记录写后回读不到 —— 动作照常，但【留痕失败】')
-  return ok ? row.t : ''
-}
-
-export function scan(root, days = 1) {
-  const out = []
-  for (let i = 0; i < Math.max(1, days); i++) {
-    const d = new Date(Date.now() - i * 86400e3)
-    const day = cst(d).toISOString().slice(0, 10)
-    for (const r of read(root, day)) out.push({ ...r, _day: day })
-  }
-  return out.sort((a, b) => (a._day + a.t).localeCompare(b._day + b.t))
-}
-
-export function logq(root, { did, kind = '问答', secs = 0, r = 'pass', ev = '',
-                            ch = '钉钉单聊', asked = '', issue = '', conv = '', msg = '' }) {
-  const row = { t: now().slice(11, 19), ch, kind, did: String(did).slice(0, 300), secs: +secs, r }
-  for (const [k, v] of [['asked', asked], ['issue', issue], ['conv', conv], ['msg', msg], ['ev', ev]]) {
-    if (v) row[k] = String(v).slice(0, 600)
-  }
-  return append(root, row)
-}