@fanchao8609/agent_brain_sync 0.1.0

package/README.md

@@ -0,0 +1,112 @@
+# abs — agent-brain-sync 跨会话 AI 编码记忆
+
+跨会话记忆的机械落盘：**hook 纯触发 → CLI/MCP 读写 → markdown 图谱（`.brain/`，可进 git）**。
+让每个会话不再无状态——经验/进度/踩坑有统一落点，重开不"失忆"。
+参考 [ai-memory](https://github.com/akitaonrails/ai-memory) 的接入机制，砍掉全部重引擎。
+
+> npm 发布名 `@fanchao8609/agent_brain_sync`（因 `agent-brain-sync` 已存在、相似名被 npm 拦截）；全局命令 `abs`（包名与命令名独立）。
+
+## 架构
+
+```
+hook (宿主事件, 纯触发) ──▶ abs log (一行技术流水, fire-and-forget, 不阻塞)
+agent (会话中)          ──▶ MCP (abs_load/abs_board/abs_task/…) ──▶ 读写 .brain/
+人   (终端)             ──▶ abs CLI 同一套读写
+```
+
+- **唯一真源**: `<项目>/.brain/`（index/todo/log + concepts/entities/sources/syntheses/sessions）
+- **多项目隔离**: 任何读写先从 cwd 向上找最近 `.brain/`（代码写死，MCP 无状态，各会话各归各位）
+- **三层分工**:
+  - **hook（机械层）**：宿主生命周期事件 → 只写技术日志（`~/.abs/log/`），不碰图谱 todo/log.md
+  - **CLI/MCP（实时层）**：任务/经验实时落盘（`abs task start/note/blocked/done`、`abs note`）
+  - **skill（自觉层）**：深提炼（sources→concepts）+ 收尾循环（详见 skill/SKILL.md）
+- **并发写保护**: 所有 .brain 读改写经 `lock.editFile`（`open wx` 原子锁 + 排队等锁 + SKIP 哨兵），跨进程(CLI/MCP/hook)同写不覆盖丢更新
+
+## 安装
+
+### 方式一：npm 全局安装（产品模式，推荐）
+
+```bash
+npm install -g @fanchao8609/agent_brain_sync
+abs install                    # 交互式选智能体（或 --agent 指定）
+```
+
+### 方式二：从源码（开发）
+
+```bash
+git clone <repo> && cd <repo> && npm install
+node bin/abs.js install        # 或先 npm link 使 `abs` 全局可用
+```
+
+### 安装到宿主（hook + MCP + skill）
+
+```bash
+abs install                     # 全部: claude-code codex opencode pi
+abs install --agent claude-code # 只装 Claude Code (MCP+hook+skill)
+abs install --agent claude-code --no-mcp   # 只 hook+skill
+
+abs uninstall --agent claude-code   # 卸载（只删 abs 装的，保留其它共存 hook）
+abs uninstall                        # 全部
+```
+
+安装内容：
+| 宿主 | hook | MCP | skill |
+|---|---|---|---|
+| claude-code | `~/.claude/settings.json` hooks（与 moshi-hook 等**共存追加**，不覆盖） | settings.json `mcpServers.abs` (stdio) | `~/.claude/skills/abs-agent-brain-sync/` |
+| codex | `~/.codex/hooks.json` | config.toml `[mcp_servers.abs]` | `~/.codex/skills/` |
+| opencode | `~/.config/opencode/plugins/abs.ts` | opencode.json mcp.abs | skills/ |
+| pi | `~/.pi/agent/extensions/abs.ts` | extension 内桥接 | skills/ |
+
+幂等：重复安装=更新；写入前自动备份；卸载只删 abs 的条目、保留其它共存 hook。
+
+## 项目里用
+
+```bash
+abs init          # 项目根建 .brain/ 图谱（一次）
+abs load          # 开机读状态（index 路线 + todo 看板 + 最近 log）
+abs todo          # 看板（Today/Backlog/Blocked/Done）
+abs task start   TASK-1 --note "做什么"        # 登记（幂等）
+abs task note    TASK-1 --note "改到X文件L40"  # 实时断点（↳ 断点: 行，幂等）
+abs task blocked TASK-1 --note "卡点原因"      # 碰壁移 Blocked
+abs task done    TASK-1                        # 完成归位 Done
+abs note "经验一句话" --tags 坑,docker          # 经验实时暂存 → sources/
+abs log "完成X：…"   # 记一行工作成果流水；abs log 无参=查看 log.md
+abs query <词>    # 检索图谱（多词 OR）
+abs lint          # 图谱体检（死链/孤岛/超尺寸/堆积/index 漏列）
+abs status        # 当前项目 + 图谱概要
+```
+
+实时化分工：**hook 自动记技术流水；任务/经验经 CLI/MCP 实时落盘（每个任务边界立即调）；
+深提炼（sources→concepts）归收尾自觉层，工具不替你判断什么值得沉淀。** 详见 `skill/SKILL.md`。
+
+## 核心能力
+
+- **并发写保护（lock）**: `.brain` 是"读-改-整写回"，跨进程并发会互相覆盖。`src/lock.js` 用同目录 `.lock` 文件 `open('wx')` 原子抢占 + 排队等锁（预算 30s，指数退避）+ `SKIP` 哨兵，把 todo/index/log 的写串行化，避免丢失更新。
+- **统一读写收口（brainio）**: `src/brainio.js` 提供 `readBrain / writeBrain / appendBrain / createBrainFile`——所有需读写 .brain 文档的地方统一走它，写自动带 lock 防并发（新代码遵循此入口）。
+- **收尾自动化**: Stop 时 hook 在 `~/.abs/log/wrapup.log` 留 wrapup 提醒；下会话开头走"收尾循环"（对账 todo / 沉淀经验 / 修 index/log）。
+- **多宿主共存**: install 分区合并追加，不会顶掉同事件的其它 hook（如 moshi-hook）。
+
+## 开发
+
+```bash
+npm test          # 全量 110+ 单测（四层: CLI/install/MCP/hook + lock/brainio）
+npm run pack:check  # 预览 npm 发布产物（files 白名单）
+```
+
+## 目录
+
+```
+agent_brain_sync/
+├── bin/abs.js      CLI 入口
+├── bin/mcp.js      MCP server (stdio, 官方 SDK, 窄工具面)
+├── src/index.js    图谱定位（向上找最近 .brain/）
+├── src/lock.js     .brain 并发写保护（原子锁 + 排队 + SKIP）
+├── src/brainio.js  统一读写收口（readBrain/writeBrain/appendBrain）
+├── src/todo.js     todo.md 分区读写
+├── src/store.js    CLI 命令实现 (init/load/todo/task/log/query/lint/status/…)
+├── src/hosts.js    四宿主接入定义
+├── src/install.js  安装/卸载向导（分区共存合并）
+├── hooks/event.sh  hook 模板（纯触发 → 技术日志 + Stop wrapup 提醒）
+├── skill/SKILL.md  技能（安装到各智能体）
+└── test/           单测（node:test，零外部测试依赖）
+```

package/bin/abs.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+// bin/abs.js — abs CLI 入口。
+// abs <cmd> [args]
+// 命令: init / board / status / load / task / install / uninstall / help
+import { cmdInit, cmdBoard, cmdStatus, cmdLoad, cmdTask, cmdLog, cmdQuery, cmdLint, cmdNote, cmdShow, cmdRepair, cmdWrapup } from '../src/store.js';
+import { runInstall, runUninstall, installSummary } from '../src/install.js';
+
+const [,, cmd, ...rest] = process.argv;
+
+function parseArgv(args) {
+  const o = { _: [] };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--dir') { o.dir = args[++i]; }
+    else if (a === '--agent') { o.agent = args[++i]; }
+    else if (a === '--id') { o.id = args[++i]; }
+    else if (a === '--section') { o.section = args[++i]; }
+    else if (a === '--note') { o.note = args[++i]; }
+    else if (a === '--yes') { o.yes = true; }
+    else if (a === '--repair') { o.repair = true; }
+    else if (a === '--no-mcp') { o.mcp = false; }
+    else if (a === '--no-skill') { o.skill = false; }
+    else if (a.startsWith('--')) { o[a.slice(2)] = true; }
+    else o._.push(a);
+  }
+  return o;
+}
+
+const usage = `abs — agent-brain-sync 记忆工具
+
+用法:
+  abs init [--repair]        建 .brain/ 图谱；结构不完整时报明细，--repair 只补缺不覆盖
+  abs load                   开机读状态 (index/todo/log)
+  abs todo                   查看任务看板 (board 的正名)
+  abs index                  查看图谱索引 index.md
+  abs log                    无参查看流水 log.md；带参追加一行: abs log "标题" (仅用户/AI 主动记, hook 事件走 ~/.abs/log/hooks.log)
+  abs status                 显示当前项目 + 图谱概要
+  abs task start   <id> [--note ..] [--section Today / In Progress]  登记任务
+  abs task note    <id> --note "断点/进度"   实时落 ↳ 断点 行
+  abs task blocked <id> --note "卡点原因"    移入 Blocked 区
+  abs task done    <id>                      完成并归位 Done
+  abs note "经验一句话" [--tags 坑,docker]    经验实时暂存 → sources/
+  abs query <词1> [词2 …]    检索 .brain/ 知识页 (多词 OR)
+  abs lint                   图谱体检 (死链/孤岛/超尺寸/堆积)
+  abs wrapup                 快照当前未完成任务到 ~/.abs/log/wrapup.log (收尾保险)
+  abs install [--agent <claude-code|opencode|codex|pi>]  安装 MCP+hook+skill
+  abs uninstall [--agent <...>]                            卸载
+  abs help                   本帮助
+`;
+
+async function main() {
+  const opts = parseArgv(rest);
+  try {
+    switch (cmd) {
+      case 'init': {
+        const msg = opts.repair
+          ? await cmdRepair({ dir: opts.dir })
+          : await cmdInit({ dir: opts.dir });
+        console.log(msg);
+        break;
+      }
+      case 'load':     console.log(await cmdLoad({ dir: opts.dir })); break;
+      case 'board':    console.log(await cmdShow({ dir: opts.dir, view: 'todo' })); break;
+      case 'todo':     console.log(await cmdShow({ dir: opts.dir, view: 'todo' })); break;
+      case 'index':    console.log(await cmdShow({ dir: opts.dir, view: 'index' })); break;
+      case 'log': {
+        // 无参=查看 log.md；带参=追加一行 (用户/AI 主动记; hook 生命周期事件走技术日志 hooks.log, 不经这里)
+        if (opts._.length) {
+          console.log(await cmdLog({ dir: opts.dir, title: opts._.join(' ') }));
+        } else {
+          console.log(await cmdShow({ dir: opts.dir, view: 'log' }));
+        }
+        break;
+      }
+      case 'status':   console.log(await cmdStatus({ dir: opts.dir })); break;
+      case 'task': {
+        const [action, id] = opts._;
+        if (!action || !['start', 'done', 'blocked', 'note'].includes(action)) {
+          throw new Error('abs task <start|done|blocked|note> <id>');
+        }
+        console.log(await cmdTask({ dir: opts.dir, action, id, section: opts.section, note: opts.note }));
+        break;
+      }
+      case 'note': {
+        console.log(await cmdNote({ dir: opts.dir, text: opts._.join(' '), tags: opts.tags }));
+        break;
+      }
+      case 'install':  await runInstall({ agent: opts.agent, mcp: opts.mcp !== false, skill: opts.skill !== false, yes: opts.yes }); break;
+      case 'uninstall': await runUninstall({ agent: opts.agent, yes: opts.yes }); break;
+      case 'agents':   console.log(installSummary()); break;
+      case 'query': {
+        console.log(await cmdQuery({ dir: opts.dir, terms: opts._ }));
+        break;
+      }
+      case 'lint': {
+        console.log(await cmdLint({ dir: opts.dir }));
+        break;
+      }
+      case 'wrapup': {
+        console.log(await cmdWrapup({ dir: opts.dir }));
+        break;
+      }
+      case 'help': case undefined: case '--help': console.log(usage); break;
+      default: throw new Error(`未知命令: ${cmd}\n\n${usage}`);
+    }
+  } catch (e) {
+    console.error(String(e && e.message ? e.message : e));
+    process.exit(1);
+  }
+}
+
+main();

package/bin/mcp.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+// bin/mcp.js — abs MCP server (stdio)。
+// 职责只有两个（PLAN.md v2 定稿）:
+//   ① resolve_project: 用代码写死逻辑定位当前项目目录（从 cwd 向上找最近 .brain/）
+//   ② 转接调用 CLI 读写（todo/board/query 的具体实现复用 src/）
+// 无状态：每次调用从入参 cwd 重新解析，多项目各归各位。
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { appendFile, mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { findBrainRoot } from '../src/index.js';
+import { cmdBoard, cmdLoad, cmdStatus, cmdTask, cmdQuery, cmdLint, cmdNote, cmdWrapup } from '../src/store.js';
+
+// ---------- 技术日志: MCP 请求跟踪（调试用, 与图谱 log.md 完全分开） ----------
+// 落 ~/.abs/log/mcp.log: 每次工具调用一行 [时间] tool cwd 参数摘要 → 耗时/结果摘要。
+// 关闭: ABS_LOG=0。stderr 不用（stdio transport 会污染协议）。
+const MCP_LOG = process.env.ABS_LOG !== '0';
+const LOG_DIR = process.env.ABS_LOG_DIR || join(homedir(), '.abs', 'log');
+async function tlog(line) {
+  if (!MCP_LOG) return;
+  try {
+    await mkdir(LOG_DIR, { recursive: true });
+    await appendFile(join(LOG_DIR, 'mcp.log'), `[${new Date().toISOString()}] ${line}\n`);
+  } catch { /* 日志失败不影响服务 */ }
+}
+
+// 包一层: 记录每个工具调用的入参摘要与耗时
+function withTrace(name, handler) {
+  return async (args) => {
+    const t0 = Date.now();
+    const argBrief = JSON.stringify(args || {}).slice(0, 200);
+    try {
+      const r = await handler(args);
+      const text = r?.content?.[0]?.text || '';
+      const brief = text.replace(/\n/g, '⏎').slice(0, 120);
+      await tlog(`tool=${name} cwd=${args?.cwd || '-'} args=${argBrief} → ${r?.isError ? 'ERR' : 'OK'} ${Date.now() - t0}ms | ${brief}`);
+      return r;
+    } catch (e) {
+      await tlog(`tool=${name} cwd=${args?.cwd || '-'} args=${argBrief} → THROW ${Date.now() - t0}ms | ${String(e?.message || e).slice(0, 200)}`);
+      throw e;
+    }
+  };
+}
+
+const server = new McpServer({
+  name: 'abs',
+  version: '0.1.0',
+});
+
+// 工具面（narrow on purpose — 只暴露读/查/记状态，不做深提炼）
+server.tool(
+  'abs_resolve_project',
+  '定位当前项目的 .brain 图谱根（从给定目录向上找最近 .brain/）。多项目隔离的唯一入口。',
+  { cwd: z.string().describe('当前工作目录，默认进程 cwd') },
+  async ({ cwd }) => {
+    const root = await findBrainRoot(cwd || process.cwd());
+    if (!root) {
+      return { content: [{ type: 'text', text: `未找到 .brain/（从 ${cwd} 向上无果）。先在该项目运行: abs init` }] };
+    }
+    return { content: [{ type: 'text', text: root }] };
+  }
+);
+
+server.tool(
+  'abs_board',
+  '读取当前项目 todo 看板（含断点/Next-Step）。先 resolve 得到项目，再传其根目录。',
+  { cwd: z.string().describe('项目内任意目录') },
+  async ({ cwd }) => {
+    const root = await findBrainRoot(cwd || process.cwd());
+    if (!root) return err('未找到 .brain/，先 abs init');
+    return { content: [{ type: 'text', text: await cmdBoard({ dir: root }) }] };
+  }
+);
+
+server.tool(
+  'abs_load',
+  '开机读状态：index 路线 + todo 看板 + 最近 log。跨会话续接的入口。',
+  { cwd: z.string().describe('项目内任意目录') },
+  async ({ cwd }) => {
+    const root = await findBrainRoot(cwd || process.cwd());
+    if (!root) return err('未找到 .brain/，先 abs init');
+    return { content: [{ type: 'text', text: await cmdLoad({ dir: root }) }] };
+  }
+);
+
+server.tool(
+  'abs_task',
+  '任务实时落盘（幂等键 = id）。start 登记 / note 补断点(改到哪个文件哪行) / blocked 碰壁 / done 完成归位。',
+  {
+    action: z.enum(['start', 'done', 'note', 'blocked']),
+    id: z.string().describe('任务幂等键，如 TASK-xxx 或子任务名'),
+    cwd: z.string().describe('项目内任意目录'),
+    note: z.string().optional().describe('start=做什么; note=断点(文件/到哪步); blocked=卡点原因'),
+  },
+  async ({ action, id, cwd, note }) => {
+    const root = await findBrainRoot(cwd || process.cwd());
+    if (!root) return err('未找到 .brain/，先 abs init');
+    return { content: [{ type: 'text', text: await cmdTask({ dir: root, action, id, note }) }] };
+  }
+);
+
+server.tool(
+  'abs_status',
+  '当前项目 + 图谱概要（各类页数）。',
+  { cwd: z.string().describe('项目内任意目录') },
+  async ({ cwd }) => {
+    const root = await findBrainRoot(cwd || process.cwd());
+    if (!root) return err('未找到 .brain/，先 abs init');
+    return { content: [{ type: 'text', text: await cmdStatus({ dir: root }) }] };
+  }
+);
+
+server.tool(
+  'abs_query',
+  '检索当前项目 .brain/ 知识页（多词 OR）：以前踩过什么坑、哪页记了 X。',
+  { cwd: z.string().describe('项目内任意目录'), terms: z.array(z.string()).min(1).describe('检索词') },
+  async ({ cwd, terms }) => {
+    const root = await findBrainRoot(cwd || process.cwd());
+    if (!root) return err('未找到 .brain/，先 abs init');
+    return { content: [{ type: 'text', text: await cmdQuery({ dir: root, terms }) }] };
+  }
+);
+
+server.tool(
+  'abs_lint',
+  '图谱体检：死链/孤岛/缺 frontmatter/超尺寸/sources 堆积/index 漏列。',
+  { cwd: z.string().describe('项目内任意目录') },
+  async ({ cwd }) => {
+    const root = await findBrainRoot(cwd || process.cwd());
+    if (!root) return err('未找到 .brain/，先 abs init');
+    return { content: [{ type: 'text', text: await cmdLint({ dir: root }) }] };
+  }
+);
+
+server.tool(
+  'abs_note',
+  '经验实时暂存：把刚踩的坑/技巧/结论一句话落进 sources/（防 context 断了流失）。Teardown 时再提炼进 concepts/。',
+  {
+    cwd: z.string().describe('项目内任意目录'),
+    text: z.string().min(1).describe('经验/坑/技巧一句话'),
+    tags: z.string().optional().describe('逗号分隔标签，如 "docker,坑"'),
+  },
+  async ({ cwd, text, tags }) => {
+    const root = await findBrainRoot(cwd || process.cwd());
+    if (!root) return err('未找到 .brain/，先 abs init');
+    return { content: [{ type: 'text', text: await cmdNote({ dir: root, text, tags }) }] };
+  }
+);
+
+server.tool(
+  'abs_wrapup',
+  '收尾保险：把当前 todo 未完成任务快照到 ~/.abs/log/wrapup.log（下会话 load 时展示滞留对账）。',
+  { cwd: z.string().describe('项目内任意目录') },
+  async ({ cwd }) => {
+    const root = await findBrainRoot(cwd || process.cwd());
+    if (!root) return err('未找到 .brain/，先 abs init');
+    return { content: [{ type: 'text', text: await cmdWrapup({ dir: root }) }] };
+  }
+);
+
+function err(msg) {
+  return { content: [{ type: 'text', text: msg }], isError: true };
+}
+
+await server.connect(new StdioServerTransport());

package/hooks/event.sh

@@ -0,0 +1,58 @@
+#!/bin/sh
+# abs hook — 纯触发层。宿主生命周期事件 → 技术日志一行（~/.abs/log/hooks.log）。
+# 纪律:
+#   fire-and-forget: 绝不阻塞 agent 热路径; 失败留痕不中断;
+#   事件只进技术日志, 不进图谱 log.md (log.md 是活动流水: 任务/沉淀, 不收琐碎请求);
+#   不写 todo (todo 由 agent/用户经 MCP/CLI 主动登记)。
+#   Stop 额外在 wrapup.log 留一行「疑似未收尾」提醒(低噪声、独立文件)——仍只进技术日志,
+#   不碰图谱; 由 agent/用户下会话自觉跑收尾循环, hook 不替 agent 判断什么该沉淀。
+# 用法: 由宿主 hook 配置以 stdin JSON 调起; __ABS_BIN__ 安装时替换为 abs CLI 绝对路径,
+# __NODE_BIN__ 替换为 node 绝对路径 (经 node 调起, 不依赖 exec 位)。
+set +e
+ABS_BIN="__ABS_BIN__"
+NODE_BIN="__NODE_BIN__"
+EVENT="__EVENT__"
+
+PAYLOAD=$(cat 2>/dev/null | head -c 500)
+
+# 后台执行，hook 立即返回——宿主热路径零阻塞。
+(
+  # 幂等: 同一 payload 指纹在 60s 内只落一行 (防重复触发)。
+  # mark 目录可经 ABS_MARK_DIR 覆盖(默认 /tmp)——测试注入沙盒目录隔离, 避免与真实/并发残留互扰。
+  FINGER=$(printf '%s' "$PAYLOAD" | cksum | cut -d' ' -f1)
+  STAMP=$(date +%Y%m%d%H%M)
+  MARK_DIR="${ABS_MARK_DIR:-/tmp}"
+  mkdir -p "$MARK_DIR" 2>/dev/null
+  MARK="$MARK_DIR/abs-hook-${FINGER}-${STAMP}.mark"
+  [ -e "$MARK" ] && exit 0
+  : > "$MARK" 2>/dev/null
+
+  # 定位项目由 CLI 完成 (向上找 .brain/, 代码写死); 找不到图谱则静默放弃。
+  # 纪律: hook 事件只进技术日志 (~/.abs/log/), 不进图谱 log.md (那是活动流水, 不收琐碎请求)。
+  # 用 awk 截前 120 字符 (#/bin/sh 兼容: 无 ${var:0:n} bash 扩展)。
+  # 经 node 调起 (bin 文件可能无 exec 位); 失败留痕到 /tmp 便于排查 (不静默到底)。
+  SHORT=$(printf '%s' "$PAYLOAD" | awk '{print substr($0, 1, 120)}')
+  # 取 session_id 供 wrapup 提醒标注 (payload 截 500 内、id 靠前; 取不到则留空不中断)。
+  SESSION_ID=$(printf '%s' "$PAYLOAD" | sed -n 's/.*"session_id":"\([^"]*\)".*/\1/p' | head -1)
+  LOG_DIR="${ABS_LOG_DIR:-$HOME/.abs/log}"
+  mkdir -p "$LOG_DIR" 2>/dev/null
+  {
+    printf '[%s] %s %s\n' "$(date '+%Y-%m-%d %H:%M:%S')" "$EVENT" "$SHORT"
+  } >> "$LOG_DIR/hooks.log" 2>/dev/null || true
+
+  # Stop 专用: 低噪声 wrap-up 提醒 (独立文件, 不进 per-event hooks.log, 不碰图谱 todo/log.md)。
+  # 纯机械信号——"一个会话结束了"; 是否真有滞留任务/经验由 agent 自觉判断, hook 不替做。
+  if [ "$EVENT" = "Stop" ]; then
+    {
+      printf '[%s] wrapup-remind 会话已结束(%s): 若 Today 有滞留任务或经验未沉淀, 下会话开头走收尾循环\n' \
+        "$(date '+%Y-%m-%d %H:%M:%S')" "$SESSION_ID"
+    } >> "$LOG_DIR/wrapup.log" 2>/dev/null || true
+    # 机械快照滞留清单: abs wrapup 把当前项目未完成任务+断点追加到 wrapup.log (跨会话收尾保险)。
+    # abs wrapup 已自行写 wrapup.log (honor ABS_LOG_DIR); 这里 stdout 只进 hooks.log 作痕迹, 避免污染 wrapup.log。
+    "$NODE_BIN" "$ABS_BIN" wrapup >>"$LOG_DIR/hooks.log" 2>/dev/null || true
+  fi
+) &
+
+# Claude Code 等宿主要求 stdout 以 { 开头才不告警。
+printf '{}\n'
+exit 0

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@fanchao8609/agent_brain_sync",
+  "version": "0.1.0",
+  "description": "agent-brain-sync: 跨会话 AI 编码记忆 — hook 纯触发 + CLI/MCP 读写 .brain markdown 图谱, 防并发写保护。",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "abs": "bin/abs.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "hooks/",
+    "skill/",
+    "README.md"
+  ],
+  "keywords": [
+    "memory", "agent", "brain", "markdown", "cross-session", "claude", "mcp", "knowledge-graph", "obsidian"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0"
+  },
+  "scripts": {
+    "abs": "node bin/abs.js",
+    "mcp": "node bin/mcp.js",
+    "test": "node --test 'test/*.test.js'",
+    "prepack": "node -e \"require('fs').chmodSync('bin/abs.js',0o755);require('fs').chmodSync('bin/mcp.js',0o755)\"",
+    "pack:check": "npm pack --dry-run"
+  }
+}