@yottameta/yotta-memory 0.6.3 → 0.6.5

package/README.md

@@ -43,7 +43,7 @@
 | **越用越懂（v0.6.0）** | `profile` 画像聚合（零推断）+ `context` 开工上下文包（身份 / 画像 / 近期记忆 / 边界 / 承诺）+ SKILL「记忆守则」规则层，记忆随使用成长 |
 | **生态分发** | GitHub + npm 双源同步发布；npx skills / npm / install.sh 三种方式，覆盖 17+ 类智能体目录 |
 | **便携记忆盘（随盘走）** | 记忆库即引擎：装在硬盘 / 主机上，插上即恢复全部记忆；引擎主机只需装 CLI 当存放点，无需装任何 AI 智能体 |
-| **局域网共享与自启** | 每智能体独立 token（Bearer + X-Agent-Id）鉴权、可吊销；`lan enable` 注册开机自启（Windows：优先计划任务；非管理员自动降级用户级 Startup 静默自启）；MCP 工具集与 CLI 一致（8 个工具），管理动作不远程暴露 |
+| **局域网共享与自启** | 每智能体独立 token（Bearer + X-Agent-Id）鉴权、可吊销；`lan enable` 注册开机自启（Windows：优先计划任务，非管理员自动降级用户级 Startup 静默自启；Linux：systemd 用户单元，不可用时自动降级用户 crontab @reboot）；MCP 工具集与 CLI 一致（8 个工具），管理动作不远程暴露 |
 | **本地 / 局域网双模式** | 本地 `serve --stdio` 零进程、按需拉起（无常驻）；局域网 streamable HTTP 常驻——两种模式可并存、按需选用 |
 
 ## 功能详解
@@ -97,6 +97,7 @@
 - `remember` 时自动构建 `index.json` 索引；recall 用 TF 打分排序，中文按 bigram 分词，不用额外模型。
 - `index.json` 的 `tokens` 字段是中文分词的词频表（TF 打分用），**不是**访问凭证；鉴权令牌在记忆目录下 `.server/tokens.json`。
 - 支持关键词、`--type` 过滤、`--limit` 截断、项目级优先。
+- **根位置去重（v0.6.5）**：当项目级与用户级记忆库指向同一目录（如 cwd = home 或其父）时，`recall` / `context` 自动唯一化根，同一文件只展示一次。
 - 命中展示会累加 `access_count` / `last_accessed`，为生命周期管理提供依据。
 
 ### 生命周期管理
@@ -115,7 +116,7 @@
 
 - **记忆库即引擎**：`serve` 把记忆目录挂成 MCP 服务，目录随盘走；引擎主机只需装 CLI 当存放点，无需装任何 AI 智能体。
 - **双模式可并存**：本地 `serve --stdio` 零进程（客户端按需拉起）；局域网 streamable HTTP（默认 `0.0.0.0:8787`）+ 每智能体 token 鉴权。
-- **开机自启**：`lan enable` 注册 Windows 开机自启——优先计划任务（默认登录自启，`--onstart` 开机即启需管理员）；非管理员（计划任务被拒）自动降级为**用户级 Startup 静默自启**（免管理员），启动脚本（VBS）内联启动命令，即使启动文件被外部清理也会在开机时自动重建（v0.6.3 自愈，不再出现 80070002 弹窗）；`lan disable` 移除，`lan status` 查询。
+- **开机自启**：`lan enable` 注册开机自启——Windows 优先计划任务（默认登录自启，`--onstart` 开机即启需管理员），非管理员自动降级为**用户级 Startup 静默自启**（免管理员，启动脚本内联启动命令、被清理也会在开机时自动重建，v0.6.3 起不再弹 80070002）；Linux 优先 **systemd 用户单元**（`systemctl --user`，登录自启；`--onstart` 附加 `loginctl enable-linger` 开机即启），systemd 不可用时自动降级**用户 crontab @reboot**（v0.6.4）；`lan disable` 移除，`lan status` 查询。
 - **安全边界**：管理动作（init / config / token / lan / serve）不进 MCP，token 不远程暴露；远程智能体只能读写记忆，不能改配置、不能管 token。
 - 完整操作步骤见上文「局域网多机共享」章节与 [USER_GUIDE.md](USER_GUIDE.md)。
 
@@ -196,7 +197,7 @@ npm i -g @yottameta/yotta-memory
 | `yotta-memory iam <id> [--name <显示名>] [--user <用户名>] [--relationship <关系>] [--force]` | 登记本智能体唯一身份并自动落自我档案（`agents.json`，ID 必须唯一；可选扩展显示名 / 用户 / 关系）|
 | `yotta-memory token new --agent <id> [--force]` / `token list` / `token revoke --agent <id>` | 为智能体生成 / 列出 / 吊销访问 token（登记于记忆库 `.server/tokens.json`；同 ID 已被其它来源占用需 `--force` 覆盖，防不同智能体合流）|
 | `yotta-memory serve [--host 0.0.0.0] [--port 8787] [--no-auth] [--stdio]` | 启动 MCP 记忆引擎（streamable HTTP 局域网 / --stdio 本地零进程模式；Bearer token + X-Agent-Id 鉴权）|
-| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务，默认 ONLOGON 登录自启、--onstart 开机即启需管理员；非管理员自动降级用户级 Startup 静默自启）|
+| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务，默认 ONLOGON、--onstart 开机即启需管理员，非管理员自动降级用户级 Startup 静默自启；Linux：systemd 用户单元，不可用时自动降级用户 crontab @reboot）|
 
 类型：`FACT`（事实，公共共享）/ `PREF`（偏好）/ `BOUND`（边界）/ `COMMIT`（承诺）。
 
@@ -239,7 +240,7 @@ yotta-memory recall --type FACT --limit 10
 3. 启动服务（默认监听 0.0.0.0:8787，Bearer token + X-Agent-Id 鉴权）——临时运行或注册开机自启二选一：
    ```bash
    yotta-memory serve                          # 临时前台运行
-   yotta-memory lan enable                     # 注册开机自启（Windows：计划任务；非管理员自动降级用户级 Startup 静默自启）
+   yotta-memory lan enable                     # 注册开机自启（Windows：计划任务/用户级 Startup；Linux：systemd 用户单元/用户 crontab）
    yotta-memory lan status                     # 查看自启状态
    ```
    > `lan enable --onstart` 改为开机即启（需管理员）；非管理员时 `lan enable` 自动改用用户级 Startup 静默自启（无需管理员）；`lan disable` 移除自启。

package/SKILL.md

@@ -1,14 +1,14 @@
 ---
 name: yotta-memory
 description: "元忆 —— 有权限边界的文件式智能体记忆。文件式、零依赖、可 diff/回滚：让任何 AI 智能体活过会话，开工 recall 恢复上下文、重要信息 remember 落盘、收工归档。类型体系 FACT（公共共享）/ PREF / BOUND / COMMIT（私密隔离）。触发：记住、别忘了、记一笔、记忆、remember、recall、跨会话、上次说到、续测、交接、归档、记忆盘、共享记忆、局域网记忆、画像、开工上下文、记忆守则、profile、context、越用越懂"
-version: 0.6.3
+version: 0.6.5
 license: MIT
 ---
 
 # yotta-memory（元忆）— 有权限边界的文件式智能体记忆
 
 > 一句话：元忆 —— 有权限边界的文件式智能体记忆（不注入、可 diff、能回滚；FACT 共享、PREF / BOUND / COMMIT 私密隔离）。
-> 版本：0.6.3 | 最后更新：2026-08-26
+> 版本：0.6.5 | 最后更新：2026-08-26
 
 ## 这是什么
 
@@ -158,7 +158,7 @@ license: MIT
 | `yotta-memory iam <id> [--name <显示名>] [--user <用户名>] [--relationship <关系>] [--force]` | 登记本智能体唯一身份并自动落自我档案（`agents.json`，ID 必须唯一；可选扩展显示名 / 用户 / 关系）|
 | `yotta-memory token new --agent <id> [--force]` / `token list` / `token revoke --agent <id>` | 每智能体访问 token：生成 / 列出 / 吊销（登记 `<记忆库>/.server/tokens.json`；同 ID 已被其它来源占用需 `--force` 覆盖，防不同智能体合流）|
 | `yotta-memory serve [--host 0.0.0.0] [--port 8787] [--no-auth] [--stdio]` | 启动 MCP 记忆引擎（streamable HTTP 局域网 / --stdio 本地零进程模式；Bearer token + X-Agent-Id 鉴权）|
-| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务，默认 ONLOGON 登录自启、--onstart 开机即启需管理员；非管理员自动降级用户级 Startup 静默自启；v0.6.3 起 VBS 自愈：内联启动命令，.cmd 缺失/被清理时开机自动重建，不再弹 80070002）|
+| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务，默认 ONLOGON、--onstart 开机即启需管理员，非管理员自动降级用户级 Startup 静默自启，v0.6.3 起 VBS 自愈不弹 80070002；Linux：systemd 用户单元，不可用时自动降级用户 crontab @reboot）|
 
 ## 存储格式（摘要）
 

package/USER_GUIDE.md

@@ -131,25 +131,16 @@ yotta-memory lan enable --onstart    # 开机即启（需管理员）
 yotta-memory lan status              # 查看状态
 yotta-memory lan disable             # 取消
 
-# Linux：用 systemd 开机自启（lan 命令当前仅支持 Windows）
-# 先查 yotta-memory 实际路径：which yotta-memory（npm 全局默认 /usr/local/bin/yotta-memory）
-sudo tee /etc/systemd/system/yotta-memory.service > /dev/null <<'EOF'
-[Unit]
-Description=yotta-memory memory engine
-After=network.target
-
-[Service]
-ExecStart=/usr/local/bin/yotta-memory serve --host 0.0.0.0 --port 8787
-Restart=on-failure
-
-[Install]
-WantedBy=multi-user.target
-EOF
-sudo systemctl daemon-reload
-sudo systemctl enable --now yotta-memory
-systemctl status yotta-memory        # 查看状态
+# Linux：内置命令（v0.6.4 起）——优先 systemd 用户单元（登录自启）；
+# systemd 不可用时自动降级用户 crontab @reboot（开机自启，免管理员）
+yotta-memory lan enable              # 登录后自动启动（默认）
+yotta-memory lan enable --onstart    # 开机即启（无需登录，需系统支持 loginctl）
+yotta-memory lan status              # 查看状态
+yotta-memory lan disable             # 取消
 ```
 
+> 说明：`lan enable` 默认「登录后自启」；如需系统级（整机、开机即启）服务，可手动创建 `/etc/systemd/system/yotta-memory.service`（ExecStart 指向 `which yotta-memory` 实际路径）并 `sudo systemctl enable --now yotta-memory`；桌面环境也可在 `~/.config/autostart/` 放置 `yotta-memory.desktop` 实现图形登录自启。
+
 **第 4 步：为局域网其它主机的智能体生成访问 token**
 
 ```bash
@@ -258,7 +249,7 @@ yotta-memory remember FACT 主题 内容    # 智能体落盘
 | `yotta-memory iam <id> [--name <显示名>] [--user <用户名>] [--relationship <关系>] [--force]` | 登记本智能体唯一身份并自动落自我档案（`agents.json`，ID 必须唯一；可选扩展显示名 / 用户 / 关系）|
 | `yotta-memory token new --agent <id> [--force]` / `token list` / `token revoke --agent <id>` | 访问 token（同 ID 已被其它来源占用需 `--force` 覆盖）|
 | `yotta-memory serve [--port 8787] [--stdio] [--no-auth]` | 启动记忆引擎（--no-auth 关闭鉴权，仅限可信内网）|
-| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务；非管理员自动降级用户级 Startup 静默自启）|
+| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务/用户级 Startup 静默自启；Linux：systemd 用户单元/用户 crontab @reboot）|
 
 类型：`FACT`（事实，共享）/ `PREF`（偏好）/ `BOUND`（边界）/ `COMMIT`（承诺），后三类按智能体物理分目录隔离（`private/<owner>/<type>/`）。
 
@@ -266,7 +257,7 @@ yotta-memory remember FACT 主题 内容    # 智能体落盘
 
 **远程连不上时，按顺序检查：**
 
-1. 引擎在运行吗？Windows：`yotta-memory lan status`；Linux（systemd 自启时）：`systemctl status yotta-memory`，或 `ps aux | grep yotta-memory`；也可直接 `yotta-memory --version`。
+1. 引擎在运行吗？`yotta-memory lan status`（Windows / Linux 通用）；Linux 也可 `systemctl --user status yotta-memory-serve.service`（systemd 自启时）或 `ps aux | grep yotta-memory`；也可直接 `yotta-memory --version`。
 2. IP 对吗？引擎主机执行 `hostname -I`（Linux）或 `ipconfig`（Windows）确认。
 3. 端口对吗？默认 8787，两端要一致。
 4. 防火墙放行了吗？Linux：`sudo ufw status`，未放行则 `sudo ufw allow 8787/tcp`；Windows：允许首次监听的入站请求。
@@ -281,7 +272,7 @@ yotta-memory remember FACT 主题 内容    # 智能体落盘
 
 **recall 没有结果：** 关键词太细或确实没有这条记忆；先 `recall`（不带关键词）看库里的全部记忆核对。
 
-**systemd 自启的引擎看日志：** `journalctl -u yotta-memory -n 50`。
+**systemd 自启的引擎看日志：** `journalctl --user -u yotta-memory-serve.service -n 50`（系统级手动服务为 `journalctl -u yotta-memory -n 50`）。
 
 **记错位置了？** `yotta-memory config get` 查看当前生效位置；`config set memory_home <正确目录>` 改正。
 

package/bin/yotta-memory.js

@@ -8,6 +8,8 @@
 // v0.6.0 新增：灵魂盘核心——profile（用户画像聚合，零推断）/ context（开工上下文包）/ iam 扩展（--name/--user/--relationship）/ remember --verify（写后回读）与 --no-hint（关闭类型启发式提示）+ SKILL「记忆守则」
 // v0.6.1 新增：灵魂盘机制精髓补齐——context --budget（token 预算，近记忆按剩余预算放行）/ context 内嵌「多智能体接入铁律」段 / remember --source/--weight（来源 + 重要性权重，去重 weight 取 max）/ 近期记忆排序融合 importance（confidence×recency+updated+weight+immutable）
 // v0.6.3 修复：lan 开机自启 VBS 自愈——VBS 内联 autostart.cmd 内容，启动时自动重建 .cmd（根治 80070002：wscript 找不到被引用启动文件）
+// v0.6.4 新增：lan 命令扩展 Linux——systemd 用户单元（systemctl --user enable/start，登录自启；--onstart 附加 loginctl enable-linger 开机即启）/ systemd 不可用时自动降级用户 crontab @reboot；lanPlatform 测试钩子（YOTTA_LAN_PLATFORM）
+// v0.6.5 修复：recall/context 对同一文件显示 2 条——projectRoot 与 userRoot 指向同一目录（如 cwd=home 或其父）时同一索引被遍历两次；新增 memoryRoots() 唯一化根，hasGrant/recallCore/forgetCore/cmdReindex/contextCore 统一走 memoryRoots()
 // v0.6.2 修复：remember --verify 写后回读改为直查索引 + 权限判定 + 召回匹配性（不再依赖 recall top-N 排序，消除泛化 subject 下偶发误报「回读未命中」）
 'use strict';
 
@@ -18,7 +20,7 @@ const crypto = require('crypto');
 const http = require('http');
 const child_process = require('child_process');
 
-const VERSION = '0.6.3';
+const VERSION = '0.6.5';
 const TYPES = ['FACT', 'PREF', 'BOUND', 'COMMIT'];
 const TYPE_DIRS = { FACT: 'facts', PREF: 'prefs', BOUND: 'bounds', COMMIT: 'commits' };
 const PUBLIC_DIR = 'facts';
@@ -56,6 +58,19 @@ function userRoot() {
 function projectRoot() {
   return path.join(process.cwd(), '.yottamemory');
 }
+// 唯一化记忆库根：projectRoot 与 userRoot 可能指向同一目录（如 cwd=home 或其父时），
+// 若不唯一化，recall/context 等会对同一索引遍历两次 -> 同一条记忆重复展示（v0.6.5 修复）。
+function memoryRoots() {
+  const out = [], seen = new Set();
+  for (const r of [projectRoot(), userRoot()]) {
+    const abs = path.resolve(r);
+    if (!fs.existsSync(abs)) continue;
+    if (seen.has(abs)) continue;
+    seen.add(abs);
+    out.push(abs);
+  }
+  return out;
+}
 function today() {
   const d = new Date();
   const p = (n) => String(n).padStart(2, '0');
@@ -348,7 +363,7 @@ function loadGrants(root) {
 }
 function hasGrant(userAgent, ownerAgent) {
   if (!userAgent || !ownerAgent) return false;
-  for (const root of [projectRoot(), userRoot()]) {
+  for (const root of memoryRoots()) {
     if (!fs.existsSync(root)) continue;
     const grants = loadGrants(root);
     const list = grants[userAgent];
@@ -468,7 +483,7 @@ function rememberCore(type, subject, statement, opts) {
   return { error: false, text: text };
 }
 function recallCore(query, opts) {
-  const roots = [projectRoot(), userRoot()].filter(function (r) { return fs.existsSync(r); });
+  const roots = memoryRoots();
   if (!roots.length) return { error: false, exitCode: 0, text: '记忆库不存在，请先运行: yotta-memory init' };
   const limit = opts.limit || 50;
   const onlyType = opts.type ? String(opts.type).toUpperCase() : null;
@@ -550,7 +565,7 @@ function relOf(root, fp) { return path.relative(root, fp).replace(/\\/g, '/'); }
 function forgetCore(fileRef, opts) {
   opts = opts || {};
   const selfAgent = opts.selfAgent || currentAgent();
-  const roots = [projectRoot(), userRoot()].filter(function (r) { return fs.existsSync(r); });
+  const roots = memoryRoots();
   const ref = String(fileRef || '').replace(/\\/g, '/');
   let target = null, targetRoot = null, targetRel = null;
   for (const root of roots) {
@@ -624,7 +639,7 @@ function cmdArchive(opts) {
   console.log(r.text);
 }
 function cmdReindex() {
-  const roots = [projectRoot(), userRoot()].filter(function (r) { return fs.existsSync(r); });
+  const roots = memoryRoots();
   if (!roots.length) { console.log('记忆库不存在。'); return; }
   for (const root of roots) {
     const n = buildIndex(root).length;
@@ -963,7 +978,7 @@ function selfProfileKv(root, id) {
 }
 function contextCore(opts) {
   opts = opts || {};
-  const roots = [projectRoot(), userRoot()].filter(function (r) { return fs.existsSync(r); });
+  const roots = memoryRoots();
   if (!roots.length) return { error: false, exitCode: 0, text: '记忆库不存在，请先运行: yotta-memory init' };
   const root = userRoot();
   const limit = opts.limit || 10;
@@ -1268,11 +1283,17 @@ function cmdServeStdio() {
   process.stdin.on('end', function () { process.exit(0); });
 }
 
-// ---- lan 命令（Windows 开机自启管理 serve）----
-// 双机制：① schtasks 计划任务（默认，需相应权限）；② 非管理员（Access denied）自动降级为
-// 用户级 Startup 静默自启（VBS sh.Run <autostart.cmd>, 0, False + autostart.cmd；node 路径 process.execPath 自动探测，0.5.4）
+// ---- lan command (autostart management for serve) ----
+// Windows dual mechanism: (1) schtasks scheduled task (default, needs permission); (2) non-admin
+// (Access denied) auto-fallback to user-level Startup silent autostart (VBS sh.Run <autostart.cmd>,
+// 0, False + autostart.cmd; node path process.execPath auto-detected, 0.5.4)
+// Linux (v0.6.4): (1) systemd user unit (systemctl --user enable/start, login autostart; --onstart
+// additionally runs loginctl enable-linger for boot autostart); (2) auto-fallback to user crontab
+// @reboot when no systemd user session is available.
 const LAN_TASK_NAME = 'YottaMemoryServe';
 const LAN_GEN_MARKER = 'Generated by yotta-memory lan enable';
+const LAN_UNIT_NAME = 'yotta-memory-serve.service';
+const LAN_CRONTAB_MARKER = '#YTM_LAN:yotta-memory-serve';
 function lanTaskRunCmd(opts) {
   const host = opts.host || '0.0.0.0';
   const port = opts.port || 8787;
@@ -1280,6 +1301,33 @@ function lanTaskRunCmd(opts) {
   const q = (p) => /[\s"]/.test(p) ? '\\"' + p.replace(/"/g, '\\"') + '\\"' : p;
   return q(process.execPath) + ' ' + q(__filename) + ' serve --host ' + host + ' --port ' + port;
 }
+
+function lanServeArgs(opts) {
+  return ['serve', '--host', String(opts.host || '0.0.0.0'), '--port', String(opts.port || 8787)];
+}
+// generic spawn wrapper: YOTTA_LAN_*_BIN may point to a .js stub (testing/advanced use;
+// on Windows run it with the current node interpreter automatically)
+function lanSpawn(bin, args, spawnOpts) {
+  if (process.platform === 'win32' && /\.js$/i.test(String(bin))) {
+    return child_process.spawnSync(process.execPath, [bin].concat(args), spawnOpts);
+  }
+  return child_process.spawnSync(bin, args, spawnOpts);
+}
+// platform override for testing/advanced use (YOTTA_LAN_PLATFORM=linux/win32/...)
+function lanPlatform() { return process.env.YOTTA_LAN_PLATFORM || process.platform; }
+// sh-style single-quote quoting (crontab line is executed via /bin/sh -c)
+function shQuote(s) {
+  const p = String(s);
+  if (!/[\s'"\\$\`]/.test(p)) return p;
+  return "'" + p.replace(/'/g, "'\\''") + "'";
+}
+// systemd ExecStart quoting (systemd's own parse rules: double quotes group, \" escapes a quote,
+// \\ escapes a backslash)
+function systemdEscapeArg(s) {
+  const p = String(s);
+  if (!/[\s"\\$;]/.test(p)) return p;
+  return '"' + p.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
+}
 function lanStartupDir() {
   // 测试/高级用途可用 YOTTA_LAN_STARTUP_DIR 覆盖（默认用户级 Startup 目录，免管理员）
   if (process.env.YOTTA_LAN_STARTUP_DIR) return process.env.YOTTA_LAN_STARTUP_DIR;
@@ -1370,7 +1418,191 @@ function isSchtasksAccessDenied(e) {
   const msg = String((e && e.stderr) || (e && e.message) || e);
   return /access\s+is\s+denied|access\s+denied|拒绝访问/i.test(msg);
 }
-function cmdLanEnable(opts) {
+
+// ---- lan Linux (systemd user unit / user crontab @reboot) ----
+function lanLinuxSystemdUserDir() {
+  // override with YOTTA_LAN_SYSTEMD_USER_DIR for testing/advanced use (default ~/.config/systemd/user)
+  if (process.env.YOTTA_LAN_SYSTEMD_USER_DIR) return process.env.YOTTA_LAN_SYSTEMD_USER_DIR;
+  const cfg = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+  return path.join(cfg, 'systemd', 'user');
+}
+function lanLinuxUnitPath() { return path.join(lanLinuxSystemdUserDir(), LAN_UNIT_NAME); }
+function lanLinuxSystemctlBin() { return process.env.YOTTA_LAN_SYSTEMCTL_BIN || 'systemctl'; }
+function lanLinuxLoginctlBin() { return process.env.YOTTA_LAN_LOGINCTL_BIN || 'loginctl'; }
+function lanLinuxExecStart(opts) {
+  return [systemdEscapeArg(process.execPath), systemdEscapeArg(__filename)].concat(lanServeArgs(opts)).join(' ');
+}
+function lanLinuxUnitContent(opts) {
+  // keep comments ASCII (avoid locale/encoding issues); ExecStart uses systemd's own quote rules
+  return [
+    '# ' + LAN_GEN_MARKER + '; remove with: yotta-memory lan disable (English only, keep ASCII)',
+    '',
+    '[Unit]',
+    'Description=yotta-memory memory engine (lan autostart)',
+    '',
+    '[Service]',
+    'Type=simple',
+    'ExecStart=' + lanLinuxExecStart(opts),
+    'Restart=on-failure',
+    'RestartSec=3',
+    '',
+    '[Install]',
+    'WantedBy=default.target',
+    '',
+  ].join('\n');
+}
+function lanCrontabBin() { return process.env.YOTTA_LAN_CRONTAB_BIN || 'crontab'; }
+function lanCrontabLine(opts) {
+  const parts = ['@reboot', shQuote(process.execPath), shQuote(__filename)].concat(lanServeArgs(opts));
+  return parts.join(' ') + ' >> ' + shQuote(lanLogPath(opts)) + ' 2>&1 ' + LAN_CRONTAB_MARKER;
+}
+function lanCrontabRead() {
+  try {
+    const r = lanSpawn(lanCrontabBin(), ['-l'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    if (r.status === 0) return String(r.stdout || '').split(/\r?\n/).filter(function (l) { return l !== ''; });
+  } catch (e) { /* crontab unavailable -> treat as empty */ }
+  return [];
+}
+function lanCrontabWrite(lines) {
+  const content = lines.join('\n') + (lines.length ? '\n' : '');
+  const r = lanSpawn(lanCrontabBin(), ['-'], { input: content, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+  if (r.error) throw r.error;
+  if (r.status !== 0) throw new Error(String(r.stderr || r.stdout || '').toString().split(/\r?\n/)[0]);
+}
+function lanCrontabHasOurLine(lines) {
+  return lines.some(function (l) { return l.indexOf(LAN_CRONTAB_MARKER) !== -1; });
+}
+function lanCrontabWithoutOurLine(lines) {
+  return lines.filter(function (l) { return l.indexOf(LAN_CRONTAB_MARKER) === -1; });
+}
+function lanLinuxHasSystemd() {
+  try {
+    const r = lanSpawn(lanLinuxSystemctlBin(), ['--user', 'show-environment'], { stdio: ['ignore', 'ignore', 'ignore'] });
+    return r.status === 0;
+  } catch (e) { return false; }
+}
+function lanLinuxSystemctl(args) {
+  const r = lanSpawn(lanLinuxSystemctlBin(), ['--user'].concat(args), { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  if (r.error) throw r.error;
+  return { status: r.status, out: String(r.stdout || ''), err: String(r.stderr || '') };
+}
+function lanLinuxInstallSystemd(opts) {
+  const dir = lanLinuxSystemdUserDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const unit = lanLinuxUnitPath();
+  fs.writeFileSync(unit, lanLinuxUnitContent(opts), 'utf8');
+  lanLinuxSystemctl(['daemon-reload']);
+  const en = lanLinuxSystemctl(['enable', LAN_UNIT_NAME]);
+  if (en.status !== 0) throw new Error('systemctl --user enable 失败: ' + en.err.split(/\r?\n/)[0]);
+  const st = lanLinuxSystemctl(['start', LAN_UNIT_NAME]);
+  if (st.status !== 0) {
+    console.error('启动服务失败（已注册，稍后可执行 systemctl --user start yotta-memory-serve.service）: ' + st.err.split(/\r?\n/)[0]);
+  }
+  if (opts.onstart) {
+    try {
+      const lr = lanSpawn(lanLinuxLoginctlBin(), ['enable-linger'], { stdio: ['ignore', 'pipe', 'pipe'] });
+      if (lr.status === 0) console.log('已启用 lingering（开机即启，无需登录）');
+      else console.error('提示: 开机即启需 loginctl enable-linger，当前未生效（' + String(lr.stderr || '').split(/\r?\n/)[0] + '）');
+    } catch (e) {
+      console.error('提示: 开机即启需 loginctl enable-linger，当前无 loginctl（' + String((e && e.message) || e).split(/\r?\n/)[0] + '）');
+    }
+  }
+  return unit;
+}
+function lanLinuxRemoveSystemd() {
+  // only remove our own marker unit file, never a user's own systemd unit
+  const unit = lanLinuxUnitPath();
+  if (!fs.existsSync(unit) || !lanFileHasMarker(unit)) return false;
+  try { lanLinuxSystemctl(['disable', LAN_UNIT_NAME]); } catch (e) {}
+  try { lanLinuxSystemctl(['stop', LAN_UNIT_NAME]); } catch (e) {}
+  try { fs.unlinkSync(unit); } catch (e) {}
+  try { lanLinuxSystemctl(['daemon-reload']); } catch (e) {}
+  return true;
+}
+function lanLinuxInstallCrontab(opts) {
+  const lines = lanCrontabWithoutOurLine(lanCrontabRead());
+  lines.push(lanCrontabLine(opts));
+  lanCrontabWrite(lines);
+  return lanCrontabLine(opts);
+}
+function lanLinuxRemoveCrontab() {
+  const cur = lanCrontabRead();
+  const lines = lanCrontabWithoutOurLine(cur);
+  if (lines.length === cur.length) return false;
+  lanCrontabWrite(lines);
+  return true;
+}
+function cmdLanLinuxEnable(opts) {
+  if (lanLinuxHasSystemd()) {
+    try {
+      const unit = lanLinuxInstallSystemd(opts);
+      console.log('已注册开机自启: systemd 用户单元 ' + LAN_UNIT_NAME);
+      console.log('单元文件: ' + unit);
+      console.log('备注: 登录后自动启动（systemctl --user）；如需现在运行请执行 yotta-memory serve');
+      if (!opts.onstart) console.log('提示: 如需开机即启（无需登录），请用 --onstart 重新执行 yotta-memory lan enable');
+      return;
+    } catch (e) {
+      const msg = String((e && e.message) || e).split(/\r?\n/)[0];
+      console.error('systemd 注册失败: ' + msg);
+      console.log('自动改用用户 crontab @reboot 自启...');
+    }
+  } else {
+    console.log('未检测到 systemd 用户会话，改用用户 crontab @reboot 自启...');
+  }
+  try {
+    const line = lanLinuxInstallCrontab(opts);
+    console.log('已启用用户 crontab @reboot 自启');
+    console.log('启动命令: ' + line);
+    console.log('日志: ' + lanLogPath(opts));
+    console.log('备注: 开机时自动启动；如需现在运行请执行 yotta-memory serve');
+  } catch (e2) {
+    console.error('crontab 注册失败: ' + String((e2 && e2.message) || e2).split(/\r?\n/)[0]);
+    console.error('请手动配置开机自启（如 ~/.config/autostart/*.desktop 或系统服务），或直接运行 yotta-memory serve');
+    process.exit(1);
+  }
+}
+function cmdLanLinuxDisable() {
+  let removedAny = false;
+  let sawError = false;
+  try {
+    if (lanLinuxRemoveSystemd()) { console.log('已移除 systemd 用户单元 ' + LAN_UNIT_NAME); removedAny = true; }
+  } catch (e) { console.error('移除 systemd 单元失败: ' + String((e && e.message) || e).split(/\r?\n/)[0]); sawError = true; }
+  try {
+    if (lanLinuxRemoveCrontab()) { console.log('已移除 crontab @reboot 自启'); removedAny = true; }
+  } catch (e) { console.error('移除 crontab 自启失败: ' + String((e && e.message) || e).split(/\r?\n/)[0]); sawError = true; }
+  if (!removedAny && !sawError) console.log('未启用: 未发现任何自启配置（systemd 单元与 crontab 均不存在）');
+  if (sawError) process.exit(1);
+}
+function cmdLanLinuxStatus() {
+  let any = false;
+  const unit = lanLinuxUnitPath();
+  const unitExists = fs.existsSync(unit) && lanFileHasMarker(unit);
+  if (unitExists) {
+    any = true;
+    console.log('systemd 用户单元 ' + LAN_UNIT_NAME + ': 已注册');
+    try {
+      const en = lanLinuxSystemctl(['is-enabled', LAN_UNIT_NAME]);
+      if (en.status === 0) console.log('  启用状态: ' + String(en.out).trim());
+    } catch (e) {}
+    try {
+      const ac = lanLinuxSystemctl(['is-active', LAN_UNIT_NAME]);
+      if (ac.status === 0) console.log('  运行状态: ' + String(ac.out).trim());
+    } catch (e) {}
+    console.log('  单元文件: ' + unit);
+  } else {
+    console.log('systemd 用户单元 ' + LAN_UNIT_NAME + ': 未注册');
+  }
+  const lines = lanCrontabRead();
+  if (lanCrontabHasOurLine(lines)) {
+    any = true;
+    console.log('crontab @reboot: 已启用');
+    for (const l of lines) if (l.indexOf(LAN_CRONTAB_MARKER) !== -1) console.log('  ' + l.trim());
+  } else {
+    console.log('crontab @reboot: 未启用');
+  }
+  if (!any) console.log('未启用任何开机自启（可用 yotta-memory lan enable 注册）');
+}
+function cmdLanWinEnable(opts) {
   if (process.platform !== 'win32') {
     console.error('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + process.platform);
     process.exit(2);
@@ -1404,7 +1636,7 @@ function cmdLanEnable(opts) {
     return;
   }
 }
-function cmdLanDisable() {
+function cmdLanWinDisable() {
   if (process.platform !== 'win32') {
     console.error('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + process.platform);
     process.exit(2);
@@ -1429,7 +1661,7 @@ function cmdLanDisable() {
   if (!removedAny && !sawError) console.log('未启用: 未发现任何自启配置（计划任务与 Startup 文件均不存在）');
   if (sawError) process.exit(1);
 }
-function cmdLanStatus() {
+function cmdLanWinStatus() {
   if (process.platform !== 'win32') {
     console.log('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + process.platform);
     return;
@@ -1460,6 +1692,27 @@ function cmdLanStatus() {
   }
   if (!taskFound && !vbsOk && !cmdOk) console.log('未启用任何开机自启（可用 yotta-memory lan enable 注册）');
 }
+
+function cmdLanEnable(opts) {
+  const p = lanPlatform();
+  if (p === 'win32') return cmdLanWinEnable(opts);
+  if (p === 'linux') return cmdLanLinuxEnable(opts);
+  console.error('lan 命令当前仅支持 Windows / Linux；本机平台: ' + p);
+  process.exit(2);
+}
+function cmdLanDisable() {
+  const p = lanPlatform();
+  if (p === 'win32') return cmdLanWinDisable();
+  if (p === 'linux') return cmdLanLinuxDisable();
+  console.error('lan 命令当前仅支持 Windows / Linux；本机平台: ' + p);
+  process.exit(2);
+}
+function cmdLanStatus() {
+  const p = lanPlatform();
+  if (p === 'win32') return cmdLanWinStatus();
+  if (p === 'linux') return cmdLanLinuxStatus();
+  console.log('lan 命令当前仅支持 Windows / Linux；本机平台: ' + p);
+}
 // ---- usage / main ----
 function usage() {
   console.log([
@@ -1484,7 +1737,7 @@ function usage() {
     '  yotta-memory token list                   列出已登记智能体',
     '  yotta-memory token revoke --agent <id>    吊销某智能体 token',
     '  yotta-memory serve [--host 0.0.0.0] [--port 8787] [--no-auth] [--stdio]  启动 MCP 记忆引擎（streamable HTTP；--stdio 本地零进程模式）',
-    '  yotta-memory lan enable [--onstart] | disable | status  开机自启管理（Windows 计划任务，默认 ONLOGON；非管理员自动降级用户级 Startup 静默自启）',
+    '  yotta-memory lan enable [--onstart] | disable | status  开机自启管理（Windows：计划任务，默认 ONLOGON，非管理员自动降级用户级 Startup 静默自启；Linux：systemd 用户单元，不可用时自动降级用户 crontab @reboot）',
     '  yotta-memory --version                    版本',
     '',
     '类型: FACT(公共共享) / PREF(偏好) / BOUND(边界) / COMMIT(承诺)',
@@ -1591,6 +1844,7 @@ module.exports = {
   VERSION: VERSION,
   userRoot: userRoot,
   projectRoot: projectRoot,
+  memoryRoots: memoryRoots,
   rememberCore: rememberCore,
   recallCore: recallCore,
   profileCore: profileCore,
@@ -1620,4 +1874,34 @@ module.exports = {
   lanRemoveStartupFiles: lanRemoveStartupFiles,
   lanFileHasMarker: lanFileHasMarker,
   isSchtasksAccessDenied: isSchtasksAccessDenied,
+  lanServeArgs: lanServeArgs,
+  lanSpawn: lanSpawn,
+  lanPlatform: lanPlatform,
+  shQuote: shQuote,
+  systemdEscapeArg: systemdEscapeArg,
+  lanLinuxSystemdUserDir: lanLinuxSystemdUserDir,
+  lanLinuxUnitPath: lanLinuxUnitPath,
+  lanLinuxSystemctlBin: lanLinuxSystemctlBin,
+  lanLinuxLoginctlBin: lanLinuxLoginctlBin,
+  lanLinuxExecStart: lanLinuxExecStart,
+  lanLinuxUnitContent: lanLinuxUnitContent,
+  lanCrontabBin: lanCrontabBin,
+  lanCrontabLine: lanCrontabLine,
+  lanCrontabRead: lanCrontabRead,
+  lanCrontabWrite: lanCrontabWrite,
+  lanCrontabHasOurLine: lanCrontabHasOurLine,
+  lanCrontabWithoutOurLine: lanCrontabWithoutOurLine,
+  lanLinuxHasSystemd: lanLinuxHasSystemd,
+  lanLinuxSystemctl: lanLinuxSystemctl,
+  lanLinuxInstallSystemd: lanLinuxInstallSystemd,
+  lanLinuxRemoveSystemd: lanLinuxRemoveSystemd,
+  lanLinuxInstallCrontab: lanLinuxInstallCrontab,
+  lanLinuxRemoveCrontab: lanLinuxRemoveCrontab,
+  cmdLanWinEnable: cmdLanWinEnable,
+  cmdLanWinDisable: cmdLanWinDisable,
+  cmdLanWinStatus: cmdLanWinStatus,
+  cmdLanLinuxEnable: cmdLanLinuxEnable,
+  cmdLanLinuxDisable: cmdLanLinuxDisable,
+  cmdLanLinuxStatus: cmdLanLinuxStatus,
+
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yottameta/yotta-memory",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "元忆 —— 有权限边界的文件式智能体记忆。文件式、零依赖、可 diff/回滚；FACT/PREF/BOUND/COMMIT 四分类（公共共享/私密隔离），用户级+项目级双级存储。",
   "license": "MIT",
   "keywords": [

package/references/protocol.md

@@ -1,4 +1,4 @@
-# yotta-memory 协议规范 v0.6.3
+# yotta-memory 协议规范 v0.6.5
 
 > 本文件定义 yotta-memory 记忆标准：存储位置、目录结构、文件格式、类型体系与 CLI 命令参考。
 > 目标：任何支持 Agent Skills 开放标准的智能体，装完即可读写同一份记忆。