@yottameta/yotta-memory 0.24.0 → 0.24.3

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## v0.24.3 (2026-11-14)
+
+- **CI 精度回归**：将命中打点后的 mtime 断言收紧到 Node 原生精度边界内（纳秒偏差 < 5µs）并保留可见毫秒不变；避免 Linux 上 `utimesSync` 的亚微秒浮点误差把正确行为误判为失败。
+
+## v0.24.2 (2026-11-14)
+
+- **跨平台修复**：Windows profile 绝对路径（如 `C:\Users\...\serve-profile.json`）在 Linux CI / 非 Windows 环境生成任务 XML 时不再被 `path.resolve()` 误拼成仓库内相对路径；新增 host-independent profile 路径解析并保留 XML 回归。
+
+## v0.24.1 (2026-11-14)
+
+- **自启服务 profile**：`lan enable` 在目标用户上下文解析并写入 `serve-profile.json`（memoryHome / runtimeHome / configDir / host / port / userId），Windows 任务 XML、Startup 兜底、systemd unit 与 crontab 均显式引用该 profile，不再依赖 S4U 启动环境的 `os.homedir()`。
+- **serve fail-closed**：新增 `serve --profile <文件>`；启动时校验 profile schema、绝对路径、memoryHome / runtimeHome 是否存在、userId 是否匹配，并原子覆盖进程环境。缺文件、空库、错误用户或非法路径均拒绝启动并给出中文提示。
+- **状态与迁移**：`lan status` 显示 profile 的 memoryHome / runtimeHome，与当前配置比较漂移；旧任务缺少 `--profile` 时提示重新执行 `lan enable`。重新执行 `lan enable` 即可迁移旧任务。
+- **验证**：新增 Windows task / Startup / Linux unit / crontab profile 回归，以及 `serve --profile` 的路径固化、缺库、错用户、CLI 缺文件用例；全量测试覆盖正常与失败路径。
+
 ## v0.24.0 (2026-11-11)
 
 - **备份可靠性**：`backup status` 改为按 manifest `created` 解析时间排序，超过当前时间 15 分钟的备份标记 `future_timestamp` 并排除；manifest 缺失 / 不完整 / created 无效不参与健康判定；新增 `latest_valid` / `config_last_success` / `effective_last_success` / `source` / `anomalies`，`ensure-daily` 与默认备份体检复用同一选择逻辑。

package/README.md

@@ -33,6 +33,7 @@
 
 > 📖 The user-facing operations manual lives in [USER_GUIDE.md](USER_GUIDE.md).
 > 🆕 **v0.24.0 (structural capacity)**: `backup status` now selects valid manifest times and isolates future-dated anomalies; `index --stats` adds read-only field/byte analysis; index v5 uses gzip year shards while remaining v4-compatible; new writes use `yyyy/mm/dd` buckets with `layout plan/apply/rollback`; `doctor` adds four type-pressure indicators; `scan` supports exact rule + file + line-hash + expiry policies, while `--policy-candidates` only generates candidates.
+> 🆕 **v0.24.1 (autostart profile)**: `lan enable` writes a per-user `serve-profile.json`; Windows task XML, Startup fallback, systemd and crontab reference that absolute profile. `serve --profile <file>` pins memoryHome / runtimeHome / configDir and fails closed when paths or the Windows user do not match, preventing S4U / no-profile startup from landing on `C:\Users\Default\.yottamemory` and returning remote MCP 401.
 > 🆕 **v0.23.2 (ClawHub storefront)**: the ClawHub listing now ships an English-first bilingual summary and description (a dedicated `clawhub-dist/yotta-memory` publish copy), and the README gained the three usage cases above. Commands, options, output and the memory store format are unchanged.
 > 🆕 **v0.18.1 (distillation provenance + absolute dates + consolidation markers + rule-promotion suggestions + write discipline)**: `distill` now emits typed extraction lists (event / lesson / todo / growth / boundary-rule / other) with per-item `[source: file#L<a>-L<b>]` anchors, measured quality metrics and a skipped/boundary list, plus structured `--json`; `consolidate` rewrites relative dates ("yesterday / last week / this month / this year") into absolute dates based on each entry's `created` date and appends a consolidation marker to archived copies (`--undo` strips it); `maintain --rules` prints read-only "repeat pitfalls → promote to a rule" suggestions (default threshold 3, never writes BOUND automatically); the Memory Doctrine gained a 6-level conflict authority order and three write-discipline rules.
 
@@ -318,7 +319,8 @@ Optional post-upgrade self-check: `yotta-memory config get` (confirm `memory_hom
 | `yotta-memory iam <id> [--name <name>] [--user <user>] [--relationship <rel>] [--force]` | Register this agent's unique identity and auto-write the self profile (`agents.json`, ID must be unique) |
 | `yotta-memory token new --agent <id> [--force]` / `token list` / `token revoke --agent <id>` | Create / list / revoke access tokens for agents (registered at `.server/tokens.json`) |
 | `yotta-memory serve [--host 0.0.0.0] [--port 8787] [--no-auth] [--stdio]` | Start the MCP memory engine (streamable HTTP LAN / --stdio local zero-process mode; Bearer token + X-Agent-Id + X-Agent-Key auth) |
-| `yotta-memory lan enable [--onstart] / disable / status` | Autostart management (Windows: scheduled task with an S4U principal — runs silently in the background with no console window; `--onstart` starts at boot without a logon session, registration needs admin; non-admin auto-degrades to user-level silent Startup; Linux: systemd user unit, falls back to user crontab @reboot) |
+| `yotta-memory lan enable [--onstart] / disable / status` | Autostart management (Windows: scheduled task with an S4U principal — runs silently in the background with no console window; `--onstart` starts at boot without a logon session, registration needs admin; non-admin auto-degrades to user-level silent Startup; Linux: systemd user unit, falls back to user crontab @reboot). v0.24.1 persists a per-user `serve-profile.json`; `lan status` reports drift and old tasks lacking `--profile` |
+| `yotta-memory serve --profile <file>` | Read the per-user service profile, pin memory/runtime/config roots, validate absolute paths and the Windows user, and fail closed before opening the MCP port when a path is missing |
 | `yotta-memory maintain [--dry-run] [--apply] [--purge] [--threshold N] [--age N] [--dedup] [--dedup --apply] [--merge A,B]` | Self-organization: archive / forget candidates / confidence-scored dedup / auto-merge high-confidence groups; dry-run by default; `--dedup` is mutually exclusive with archiving |
 | `yotta-memory consolidate [--min-age N] [--min-idle N] [--max-utility N] [--min-group N] [--period N] [--type T] [--model <cmd>] [--apply] [--undo <batch>] [--batches]` | Periodic-summary compression (v0.10.0): group old idle low-value memories into one traceable summary and archive the originals; dry-run by default; `--undo <batch>` rolls a batch back; `--batches` lists batches |
 | `yotta-memory feedback <file> --useful|--useless [--reason <r>] [--undo]` | Usage feedback (useful/useless adjusts weight / confidence / feedback_net; --undo rolls back the last one) |

package/README.zh-CN.md

@@ -23,6 +23,7 @@
 
 > 📖 面向用户的操作手册见 [USER_GUIDE.md](USER_GUIDE.md)。
 > 🆕 **v0.24.0（结构容量整改）**：`backup status` 按 manifest 时间选择有效备份并隔离未来时间异常；新增只读 `index --stats`，索引 v5 使用年份 gzip 分片并兼容 v4；新写入进入 `yyyy/mm/dd` 日级桶，`layout plan/apply/rollback` 支持可回滚迁移；`doctor` 增加类型压力四指标；`scan` 支持精确文件 + 规则 + 行哈希 + 有效期的例外策略，`--policy-candidates` 只生成候选、不自动启用。
+> 🆕 **v0.24.1（自启服务 profile）**：`lan enable` 在目标用户上下文生成 `serve-profile.json`；Windows 计划任务、Startup 兜底、systemd 与 crontab 都引用该绝对 profile。`serve --profile <文件>` 固定 memoryHome / runtimeHome / configDir，并在路径缺失或 Windows 用户不匹配时 fail-closed，避免 S4U / 无用户环境启动落到 `C:\Users\Default\.yottamemory` 空库后返回远端 MCP 401。
 > 🆕 **v0.23.2（ClawHub 门面）**：ClawHub 上的技能卡改为英文优先的双语摘要与描述（新增 `clawhub-dist/yotta-memory` 专属发布副本），README 首屏新增上面三条使用案例；命令、参数、输出与记忆库格式全部不变。
 > 🆕 **v0.20.0（上下文分页 + 画像驱逐修复）**：`memory.hook` 的 PREF 驱逐空转已修复——hook / paging 决策生效时，画像段落按实时可读条目渲染并套用同一套过滤；自我接入档案不进候选、不可驱逐。新增 `context.paging`：仅在显式 `--budget` 时调用，hook 先过滤、paging 再排序与分页；`drop` 始终安全应用，`order` 仅在 `complete:true` 且未截断时应用。`context --json` 新增 `paging` 块，`--explain` 增加 `[paging]` 轨迹。配置与协议见 `references/provider-protocol.md`。
 > 🆕 **v0.18.1（蒸馏溯源 + 日期绝对化 + 巩固标记 + 规则晋升建议 + 写入纪律）**：`distill` 新增分类型提取清单（事件 / 教训 / 待办 / 成长 / 规则边界 / 其他）+ 逐条 `[溯源: 文件#L<a>-L<b>]` + 实测质量指标 + 跳过与边界，`--json` 输出结构化报告；`consolidate` 摘要按条目 `created` 把「昨天 / 上周 / 本月 / 今年」写成绝对日期，归档副本写入巩固标记（`--undo` 剥离还原）；`maintain --rules` 只读给出「重复踩坑 → 建议升级为规则」（默认阈值 3，不自动写 BOUND）；记忆守则新增冲突权威顺序 6 层与写入纪律 3 条。
@@ -360,7 +361,8 @@ bash install.sh --agent <智能体名称>
 | `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 + X-Agent-Key 鉴权）|
-| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务 S4U 主体后台静默、不弹窗口；默认登录自启、`--onstart` 开机即启（无登录会话也可启动，注册需管理员），非管理员自动降级用户级 Startup 静默自启；Linux：systemd 用户单元，不可用时自动降级用户 crontab @reboot）|
+| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务 S4U 主体后台静默、不弹窗口；默认登录自启、`--onstart` 开机即启（无登录会话也可启动，注册需管理员），非管理员自动降级用户级 Startup 静默自启；Linux：systemd 用户单元，不可用时自动降级用户 crontab @reboot）。v0.24.1 生成每用户 `serve-profile.json`；`lan status` 检查路径漂移并提示缺少 `--profile` 的旧任务 |
+| `yotta-memory serve --profile <文件>` | 读取每用户服务 profile，固定记忆库 / 运行时 / 配置目录；路径缺失、非法或 Windows 用户不匹配时在监听端口前 fail-closed |
 | `yotta-memory maintain [--dry-run] [--apply] [--purge] [--threshold N] [--age N] [--dedup] [--dedup --apply] [--merge A,B]` / `maintain --capacity [--json]` | 记忆自组织：归档 / 遗忘候选 / 置信度查重 / 自动合并高置信组；默认 dry-run；`--dedup` 与归档互斥。`--capacity` 只读报告容量水位、LRU / LFU 淘汰候选与晋升建议（冷却期与常青条目豁免）|
 | `yotta-memory consolidate [--propose] [--min-age N] [--min-idle N] [--max-utility N] [--min-group N] [--period N] [--type T] [--model <cmd>] [--apply [--yes]] [--undo <batch>] [--batches]` | 周期摘要压缩：同主题旧记忆 → 带溯源摘要 + 原文归档；默认等价 `--propose`（结构化报告，不写盘）；`--apply` 需确认（非交互必须 `--yes`）；`--undo <batch>` 回滚批次；`--batches` 查批次 |
 | `yotta-memory feedback <文件|主题> --useful|--useless [--reason <原因>] [--undo]` | 使用反馈（useful/useless 调整 weight / confidence / feedback_net；`--undo` 回滚最近一次）|

package/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: yotta-memory
 description: 元忆 —— 有权限边界的文件式智能体记忆。文件式、零依赖、可 diff/可回滚：让任何 AI 智能体活过会话，开工 recall 恢复上下文、重要信息 remember 落盘、收工归档。类型体系 FACT（公共共享）/ PREF / BOUND / COMMIT（私密隔离）。触发：记住、别忘了、记一笔、记忆、remember、recall、跨会话、上次说到、续测、交接、归档、记忆盘、共享记忆、局域网记忆、画像、开工上下文、长期理解摘要、近期走廊、会话闭环、记忆守则、profile、context、越用越懂、语义检索、反馈、维护、蒸馏、feedback、maintain、distill、explain、自我学习、自我进化、自我提升、查看平台分页、recall 候选预过滤、任务相关记忆、--focus、--embedding、压缩遗忘、consolidate、周期摘要、自动合并、分类型衰减、回滚、备份、backup、防误删、doctor、事务快照、基线探针、恢复演练、记忆库安全扫描、scan、命中打点、容量水位、--capacity、--propose、上下文压缩审计、context --audit
-version: 0.24.0
+version: 0.24.3
 license: MIT
 ---
 
@@ -14,6 +14,10 @@ license: MIT
   新写入进入 `yyyy/mm/dd` 日级桶，`layout plan/apply/rollback` 提供可预演、可回滚迁移；
   `doctor` 增加类型压力四指标（保留 7 天观察窗）；`scan` 支持精确文件 + 规则 + 行哈希 +
   有效期的例外策略，`--policy-candidates` 只生成候选、不自动启用。
+- **自启服务 profile（v0.24.1）**：`lan enable` 在目标用户上下文生成
+  `serve-profile.json`，Windows 计划任务、Startup 兜底、systemd 与 crontab
+  均显式引用该 profile；`serve --profile <文件>` 固化 memory_home / runtime_home /
+  config_dir，避免 S4U 或无用户环境启动时 `os.homedir()` 漂移为空库并导致远端 401。
 
 ## 这是什么
 

package/USER_GUIDE.md

@@ -327,6 +327,21 @@ yotta-memory recall <关键词> --agent <id> --agent-key-file "<AI_HOME>/.yotta-
 - `doctor --json` 的 `checks.scale` 新增 `index_logical_bytes` / `index_shards` / `index_format` 与 `type_pressure`（总数 / 180 天陈旧 / 归档候选 / 30 天增长）；类型阈值按计划保留观察窗。
 - `scan` 精确例外：`security/scan-policy.json` 中每条必须同时匹配规则、文件、整行 SHA-256 与未过期的 `review_by`；内容变化或过期自动恢复命中。`scan --no-policy` 做全量复核；`scan --policy-candidates --out security/scan-policy.candidates.json` 只生成候选，不自动启用。
 
+## 3.12 每用户自启 profile（v0.24.1）
+
+- `yotta-memory lan enable` 在目标用户上下文解析 `memoryHome`、`runtimeHome`、
+  `configDir`、`host`、`port` 和 `userId`，写到该用户配置目录下的
+  `serve-profile.json`。不同用户的路径互不影响，不是代码或全机器共享常量。
+- Windows task XML、Startup 兜底、systemd unit 与 crontab 都引用该绝对 profile
+  路径。服务由 S4U 或无用户环境启动时，不再依赖 `os.homedir()`。
+- `yotta-memory serve --profile <文件>` 在监听端口前校验 profile schema、
+  绝对路径、memoryHome / runtimeHome 是否存在以及 Windows 用户是否匹配；
+  校验失败直接退出，不创建 `C:\Users\Default\.yottamemory` 空库。
+- `yotta-memory lan status` 显示 profile 中的记忆库和运行时路径，并与当前
+  设置比较漂移；旧任务命令缺少 `--profile` 时提示重新执行 `lan enable`。
+- 修改 `memory_home`、配置目录或 runtime 路径后，应重新执行
+  `yotta-memory lan enable --onstart` 更新 profile 和自启任务。
+
 ## 4. 便携记忆盘 · 记忆引擎主机篇
 
 场景：记忆放在一台主机上（Linux / Windows 均可），本机直接 CLI 读写；局域网内其它主机上的 AI 智能体经 MCP 远程接入。引擎主机只需装 CLI，不需要装任何 AI 智能体。

package/bin/yotta-memory.js

@@ -26,8 +26,8 @@ const zlib = require('zlib');
 const child_process = require('child_process');
 const { AsyncLocalStorage } = require('async_hooks');
 
-const VERSION = '0.24.0';
-const CLI_VALUE_OPTS = new Set(['--type', '--limit', '--days', '--out', '--owner', '--agent', '--agent-id', '--agent-key', '--agent-key-file', '--plugin-data', '--threshold', '--scope', '--host', '--port', '--dir', '--name', '--user', '--relationship', '--source', '--weight', '--budget', '--password', '--new-password', '--recovery-key', '--recovery-key-out', '--reason', '--merge', '--model', '--subject', '--embedding', '--focus', '--embedding-timeout', '--min-age', '--min-idle', '--max-utility', '--min-group', '--period', '--to', '--id', '--time', '--tools', '--mcp-config', '--skill-dir', '--year', '--evalset', '--k', '--seed', '--bootstrap', '--gate', '--against', '--template', '--path', '--from', '--from-plan', '--batch']);
+const VERSION = '0.24.3';
+const CLI_VALUE_OPTS = new Set(['--type', '--limit', '--days', '--out', '--owner', '--agent', '--agent-id', '--agent-key', '--agent-key-file', '--plugin-data', '--threshold', '--scope', '--host', '--port', '--dir', '--name', '--user', '--relationship', '--source', '--weight', '--budget', '--password', '--new-password', '--recovery-key', '--recovery-key-out', '--reason', '--merge', '--model', '--subject', '--embedding', '--focus', '--embedding-timeout', '--min-age', '--min-idle', '--max-utility', '--min-group', '--period', '--to', '--id', '--time', '--tools', '--mcp-config', '--skill-dir', '--year', '--evalset', '--k', '--seed', '--bootstrap', '--gate', '--against', '--template', '--path', '--from', '--from-plan', '--batch', '--profile']);
 const CLI_FLAG_OPTS = new Set(['--project', '--all', '--unsafe', '--no-auth', '--stdio', '--onstart', '--from-current', '--restart', '--force', '--attach', '--allow-same-volume', '--verify', '--no-hint', '--encrypt', '--no-encrypt', '--password-stdin', '--json', '--manual', '--skip-schedule', '--useful', '--useless', '--undo', '--dry-run', '--apply', '--purge', '--dedup', '--batches', '--propose', '--audit', '--capacity', '--rules', '--explain', '--semantic', '--runtime', '--ablate', '--timing', '--baseline', '--probe', '--quarantine', '--restore', '--no-usage', '--yes', '--keep-memories', '--keep-identity', '--stats', '--include-flat', '--no-policy', '--policy-candidates']);
 
 function helpOption(flag, arg, what, when, caution) {
@@ -316,8 +316,9 @@ const HELP_MODEL = [
       helpSub('status', 'status [--json]', '查看 current 与运行时状态', '排查版本漂移时', [helpOption('--json', '', '输出 JSON', '自动化读取运行时状态时', '')]),
       helpSub('list', 'list [--json]', '列出已安装运行时版本', '盘点可切换版本时', [helpOption('--json', '', '输出 JSON', '自动化盘点运行时版本时', '')]),
     ] },
-    { name: 'serve', usage: 'serve [--stdio] [--tools core|full] [--host <地址>] [--port <端口>]', what: '启动 MCP 记忆引擎', when: '宿主需要以 MCP 方式访问元忆时', options: [
+    { name: 'serve', usage: 'serve [--stdio] [--profile <文件>] [--tools core|full] [--host <地址>] [--port <端口>]', what: '启动 MCP 记忆引擎', when: '宿主需要以 MCP 方式访问元忆时', options: [
       helpOption('--stdio', '', '用本地 stdio 模式启动', '本地宿主不需要 HTTP 服务时', ''),
+      helpOption('--profile', '<文件>', '读取每用户服务 profile', '自启任务需要固定记忆库与运行时路径时', 'profile 不存在、路径无效或用户不匹配时拒绝启动'),
       helpOption('--tools', 'core|full', '选择工具分组', '想减少工具常驻开销时', 'core 更省上下文，full 暴露全部工具'),
       helpOption('--host', '<地址>', '设置 HTTP 监听地址', '需要远端 MCP 接入时', '监听公网前必须配置鉴权和防火墙'),
       helpOption('--port', '<端口>', '设置 HTTP 监听端口', '默认端口被占用时', ''),
@@ -11623,6 +11624,7 @@ function cmdServe(opts) {
   server.listen(port, host, function () {
     console.log('yotta-memory 记忆引擎已启动（v' + VERSION + '）');
     console.log('URL: http://' + host + ':' + port + '/mcp');
+    if (opts.profile) console.log('服务 profile: ' + path.resolve(String(opts.profile)));
     console.log('记忆库: ' + root);
     console.log('MCP 协议: 2026-07-28（modern，server/discover）/ 2025-11-25（legacy 握手兼容）');
     console.log('工具分组: ' + normalizeMcpToolProfile(opts.toolProfile));
@@ -11691,18 +11693,144 @@ 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';
+const SERVE_PROFILE_FILE = 'serve-profile.json';
+const SERVE_PROFILE_SCHEMA = 1;
+
+function resolveProfilePath(value) {
+  const text = String(value || '');
+  if (!text) return '';
+  if (path.isAbsolute(text)) return path.resolve(text);
+  if (path.win32.isAbsolute(text)) return path.win32.normalize(text);
+  return path.resolve(text);
+}
+
+function lanServeProfilePath(opts) {
+  opts = opts || {};
+  if (opts.profilePath) return resolveProfilePath(opts.profilePath);
+  if (process.env.YOTTA_LAN_PROFILE_FILE) return resolveProfilePath(process.env.YOTTA_LAN_PROFILE_FILE);
+  const configDir = opts.configDir || process.env.YOTTA_MEMORY_CONFIG_DIR || path.dirname(configPath());
+  return path.join(path.resolve(String(configDir)), SERVE_PROFILE_FILE);
+}
+
+function lanCurrentUser(opts) {
+  opts = opts || {};
+  if (opts.currentUser) return String(opts.currentUser);
+  if (lanPlatform() === 'win32') return lanWindowsTaskUser(opts);
+  try {
+    const info = os.userInfo();
+    return String(info.username || '');
+  } catch (e) {
+    return '';
+  }
+}
+
+function sameLanUser(a, b) {
+  const left = String(a || '').trim().toLowerCase();
+  const right = String(b || '').trim().toLowerCase();
+  return !left || !right || left === right;
+}
+
+function lanWriteServeProfile(opts) {
+  opts = opts || {};
+  try {
+    const memoryHome = path.resolve(String(opts.memoryHome || userRoot()));
+    const runtimeHome = path.resolve(String(opts.runtimeHome || runtimeRoot()));
+    const configDir = path.resolve(String(opts.configDir || process.env.YOTTA_MEMORY_CONFIG_DIR || path.dirname(configPath())));
+    const profilePath = lanServeProfilePath(Object.assign({}, opts, { configDir: configDir }));
+    if (!fs.existsSync(memoryHome) || !fs.statSync(memoryHome).isDirectory()) {
+      return { error: true, text: '记忆库不存在或不是目录: ' + memoryHome + '。请先初始化或修正 memory_home。' };
+    }
+    const profile = {
+      schemaVersion: SERVE_PROFILE_SCHEMA,
+      generatedAt: new Date().toISOString(),
+      userId: String(opts.userId || lanCurrentUser(opts)),
+      memoryHome: memoryHome,
+      runtimeHome: runtimeHome,
+      configDir: configDir,
+      host: String(opts.host || '0.0.0.0'),
+      port: parseInt(opts.port, 10) || 8787,
+    };
+    fs.mkdirSync(path.dirname(profilePath), { recursive: true });
+    atomicWriteFileSync(profilePath, JSON.stringify(profile, null, 2) + '\n', 'utf8');
+    return { error: false, profilePath: profilePath, profile: profile };
+  } catch (e) {
+    return { error: true, text: '写入服务 profile 失败: ' + String((e && e.message) || e) };
+  }
+}
+
+function loadServeProfile(profilePath, opts) {
+  opts = opts || {};
+  const resolved = resolveProfilePath(profilePath);
+  try {
+    if (!profilePath) return { error: true, text: 'profile 路径不能为空。' };
+    const profile = JSON.parse(String(fs.readFileSync(resolved, 'utf8')).replace(/^\uFEFF/, ''));
+    if (!profile || profile.schemaVersion !== SERVE_PROFILE_SCHEMA) {
+      return { error: true, text: 'profile schemaVersion 无效，需要 ' + SERVE_PROFILE_SCHEMA + '。' };
+    }
+    for (const key of ['memoryHome', 'runtimeHome', 'configDir']) {
+      const value = String(profile[key] || '').trim();
+      if (!value || !path.isAbsolute(value)) {
+        return { error: true, text: 'profile 字段 ' + key + ' 必须是绝对路径。' };
+      }
+    }
+    const memoryHome = path.resolve(String(profile.memoryHome));
+    const runtimeHome = path.resolve(String(profile.runtimeHome));
+    const configDir = path.resolve(String(profile.configDir));
+    if (!fs.existsSync(memoryHome) || !fs.statSync(memoryHome).isDirectory()) {
+      return { error: true, text: 'profile memoryHome 指定的记忆库不存在或不是目录: ' + memoryHome };
+    }
+    if (!fs.existsSync(runtimeHome) || !fs.statSync(runtimeHome).isDirectory()) {
+      return { error: true, text: 'profile runtimeHome 指定的运行时目录不存在或不是目录: ' + runtimeHome };
+    }
+    const currentUser = opts.currentUser || lanCurrentUser(opts);
+    if (!sameLanUser(profile.userId, currentUser)) {
+      return { error: true, text: 'profile userId 与当前用户不匹配: ' + String(profile.userId || '(empty)') + ' != ' + String(currentUser || '(empty)') };
+    }
+    return {
+      error: false,
+      profilePath: resolved,
+      profile: Object.assign({}, profile, {
+        memoryHome: memoryHome,
+        runtimeHome: runtimeHome,
+        configDir: configDir,
+      }),
+    };
+  } catch (e) {
+    return { error: true, text: '无法读取服务 profile ' + resolved + ': ' + String((e && e.message) || e) };
+  }
+}
+
+function applyServeProfile(profilePath, opts) {
+  const loaded = loadServeProfile(profilePath, opts);
+  if (loaded.error) return loaded;
+  process.env.YOTTA_MEMORY_HOME = loaded.profile.memoryHome;
+  process.env.YOTTA_MEMORY_RUNTIME_HOME = loaded.profile.runtimeHome;
+  process.env.YOTTA_MEMORY_CONFIG_DIR = loaded.profile.configDir;
+  return loaded;
+}
+
+function serveProfileDrift(profile) {
+  if (!profile) return [];
+  const drift = [];
+  if (path.resolve(String(profile.memoryHome || '')) !== path.resolve(userRoot())) drift.push('memoryHome');
+  if (path.resolve(String(profile.runtimeHome || '')) !== path.resolve(runtimeRoot())) drift.push('runtimeHome');
+  if (path.resolve(String(profile.configDir || '')) !== path.resolve(path.dirname(configPath()))) drift.push('configDir');
+  return drift;
+}
+
 function lanTaskRunCmd(opts) {
   opts = opts || {};
   const host = opts.host || '0.0.0.0';
   const port = opts.port || 8787;
+  const profilePath = lanServeProfilePath(opts);
   // schtasks /tr 不接受多余内嵌引号：路径无空格不加引号，含空格/引号用 \" 转义（0.5.2 修复）
   const q = (p) => /[\s"]/.test(p) ? '\\"' + p.replace(/"/g, '\\"') + '\\"' : p;
   const prefix = lanElectronHost(opts) ? 'set "ELECTRON_RUN_AS_NODE=1" && ' : '';
-  return prefix + q(process.execPath) + ' ' + q(runtimeManagedScript()) + ' serve --host ' + host + ' --port ' + port;
+  return prefix + q(process.execPath) + ' ' + q(runtimeManagedScript()) + ' serve --profile ' + q(profilePath) + ' --host ' + host + ' --port ' + port;
 }
 
 function lanServeArgs(opts) {
-  return ['serve', '--host', String(opts.host || '0.0.0.0'), '--port', String(opts.port || 8787)];
+  return ['serve', '--profile', lanServeProfilePath(opts), '--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)
@@ -11773,6 +11901,7 @@ function lanAutostartCmdContent(opts) {
   opts = opts || {};
   const host = opts.host || '0.0.0.0';
   const port = opts.port || 8787;
+  const profilePath = lanServeProfilePath(opts);
   const q = (p) => '"' + String(p).replace(/"/g, '""') + '"';
   // 生成文件用纯 ASCII（避免 cmd/VBS 按系统代码页读取中文注释乱码；VBS 自愈内联同一内容）
   // v0.22.5: Electron 宿主下需先设 ELECTRON_RUN_AS_NODE=1，否则拉起桌面程序本体而非 Node。
@@ -11780,7 +11909,7 @@ function lanAutostartCmdContent(opts) {
     + 'chcp 65001 >nul\r\n'
     + 'rem ' + LAN_GEN_MARKER + '; remove with: yotta-memory lan disable (English only, keep ASCII)\r\n'
     + (lanElectronHost(opts) ? 'set "ELECTRON_RUN_AS_NODE=1"\r\n' : '')
-    + q(process.execPath) + ' ' + q(runtimeManagedScript()) + ' serve --host ' + host + ' --port ' + port + ' >> ' + q(lanLogPath(opts)) + ' 2>&1\r\n';
+    + q(process.execPath) + ' ' + q(runtimeManagedScript()) + ' serve --profile ' + q(profilePath) + ' --host ' + host + ' --port ' + port + ' >> ' + q(lanLogPath(opts)) + ' 2>&1\r\n';
 }
 function lanVbsContent(opts) {
   // v0.6.3 自愈：VBS 内联 autostart.cmd 内容，启动时若 .cmd 缺失/被清理即就地重建，
@@ -11893,6 +12022,7 @@ function lanWindowsTaskXml(opts) {
   const nodePath = opts.nodePath || process.execPath;
   const scriptPath = opts.scriptPath || runtimeManagedScript();
   const logPath = opts.logPath || lanLogPath(opts);
+  const profilePath = lanServeProfilePath(opts);
   const userId = opts.userId || '';
   const cmdPath = opts.cmdPath || process.env.ComSpec || 'cmd.exe';
   // cmd /c 外层引号：命令首段带引号时必须用 ""..." 包裹（cmd 的 /c 引号规则），
@@ -11902,7 +12032,7 @@ function lanWindowsTaskXml(opts) {
   // v0.22.5: Electron 宿主（YottaCode shim）下先 set ELECTRON_RUN_AS_NODE=1，
   // 否则任务会拉起桌面程序本体（GUI）而不是 Node 服务。
   const envPrefix = lanElectronHost(opts) ? 'set "ELECTRON_RUN_AS_NODE=1" &amp;&amp; ' : '';
-  const inner = envPrefix + '"' + xmlEscape(nodePath) + '" "' + xmlEscape(scriptPath) + '" serve --host ' + host + ' --port ' + port
+  const inner = envPrefix + '"' + xmlEscape(nodePath) + '" "' + xmlEscape(scriptPath) + '" serve --profile "' + xmlEscape(profilePath) + '" --host ' + host + ' --port ' + port
     + ' >> "' + xmlEscape(logPath) + '" 2>&amp;1';
   const triggerXml = onstart
     ? '<BootTrigger><Enabled>true</Enabled></BootTrigger>'
@@ -11937,6 +12067,8 @@ function lanWindowsTaskXml(opts) {
 }
 function lanWindowsEnableCore(opts) {
   opts = opts || {};
+  const profileResult = lanWriteServeProfile(opts);
+  if (profileResult.error) return { error: true, phase: 'profile', text: profileResult.text };
   const trigger = opts.onstart ? 'onstart' : 'onlogon';
   const host = opts.host || '0.0.0.0';
   const port = opts.port || 8787;
@@ -11944,7 +12076,7 @@ function lanWindowsEnableCore(opts) {
   const scriptPath = opts.scriptPath || runtimeManagedScript();
   const logPath = lanLogPath(opts);
   const userId = lanWindowsTaskUser(opts);
-  const xml = lanWindowsTaskXml({ trigger: trigger, host: host, port: port, nodePath: nodePath, scriptPath: scriptPath, logPath: logPath, userId: userId, electronHost: opts.electronHost });
+  const xml = lanWindowsTaskXml({ trigger: trigger, host: host, port: port, nodePath: nodePath, scriptPath: scriptPath, logPath: logPath, profilePath: profileResult.profilePath, userId: userId, electronHost: opts.electronHost });
   const xmlDir = opts.xmlDir || process.env.YOTTA_LAN_TASK_XML_DIR || os.tmpdir();
   const xmlPath = opts.xmlPath || path.join(xmlDir, LAN_TASK_NAME + '-task-' + process.pid + '-' + Date.now() + '.xml');
   let failure = null;
@@ -11962,7 +12094,7 @@ function lanWindowsEnableCore(opts) {
   if (!failure) {
     let removedStartup = [];
     try { removedStartup = lanRemoveStartupFiles(opts); } catch (e) { removedStartup = []; }
-    return { error: false, mode: 'task', taskName: LAN_TASK_NAME, trigger: trigger, logPath: logPath, removedStartup: removedStartup };
+    return { error: false, mode: 'task', taskName: LAN_TASK_NAME, trigger: trigger, logPath: logPath, profilePath: profileResult.profilePath, removedStartup: removedStartup };
   }
   try {
     lanInstallStartup(opts);
@@ -11978,6 +12110,7 @@ function lanWindowsEnableCore(opts) {
     vbsPath: lanVbsPath(opts),
     cmdPath: lanAutostartCmdPath(opts),
     logPath: logPath,
+    profilePath: profileResult.profilePath,
   };
 }
 
@@ -11992,7 +12125,9 @@ function lanLinuxUnitPath() { return path.join(lanLinuxSystemdUserDir(), LAN_UNI
 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(runtimeManagedScript())].concat(lanServeArgs(opts)).join(' ');
+  return [systemdEscapeArg(process.execPath), systemdEscapeArg(runtimeManagedScript())]
+    .concat(lanServeArgs(opts).map(systemdEscapeArg))
+    .join(' ');
 }
 function lanLinuxUnitContent(opts) {
   // keep comments ASCII (avoid locale/encoding issues); ExecStart uses systemd's own quote rules
@@ -12022,7 +12157,7 @@ function lanCrontabLine(opts) {
   const parts = ['@reboot'];
   if (lanElectronHost(opts)) parts.push('ELECTRON_RUN_AS_NODE=1');
   parts.push(shQuote(process.execPath), shQuote(runtimeManagedScript()));
-  return parts.concat(lanServeArgs(opts)).join(' ') + ' >> ' + shQuote(lanLogPath(opts)) + ' 2>&1 ' + LAN_CRONTAB_MARKER;
+  return parts.concat(lanServeArgs(opts).map(shQuote)).join(' ') + ' >> ' + shQuote(lanLogPath(opts)) + ' 2>&1 ' + LAN_CRONTAB_MARKER;
 }
 function lanCrontabRead() {
   try {
@@ -12101,6 +12236,12 @@ function lanLinuxRemoveCrontab() {
   return true;
 }
 function cmdLanLinuxEnable(opts) {
+  const profileResult = lanWriteServeProfile(opts);
+  if (profileResult.error) {
+    console.error('服务 profile 写入失败，拒绝注册开机自启: ' + profileResult.text);
+    process.exit(1);
+  }
+  opts = Object.assign({}, opts, { profilePath: profileResult.profilePath });
   if (lanLinuxHasSystemd()) {
     try {
       const unit = lanLinuxInstallSystemd(opts);
@@ -12143,6 +12284,23 @@ function cmdLanLinuxDisable() {
 }
 function cmdLanLinuxStatus() {
   let any = false;
+  const profilePath = lanServeProfilePath();
+  if (fs.existsSync(profilePath)) {
+    console.log('服务 profile: ' + profilePath);
+    const loaded = loadServeProfile(profilePath);
+    if (loaded.error) {
+      console.log('  警告: ' + loaded.text);
+    } else {
+      console.log('  记忆库: ' + loaded.profile.memoryHome);
+      console.log('  运行时: ' + loaded.profile.runtimeHome);
+      const drift = serveProfileDrift(loaded.profile);
+      if (drift.length) {
+        console.log('  警告: 服务 profile 与当前配置漂移(' + drift.join(', ') + ')，请重新执行 yotta-memory lan enable');
+      }
+    }
+  } else {
+    console.log('服务 profile: 不存在 ' + profilePath + '（请重新执行 yotta-memory lan enable）');
+  }
   const unit = lanLinuxUnitPath();
   const unitExists = fs.existsSync(unit) && lanFileHasMarker(unit);
   if (unitExists) {
@@ -12164,7 +12322,13 @@ function cmdLanLinuxStatus() {
   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());
+    for (const l of lines) {
+      if (l.indexOf(LAN_CRONTAB_MARKER) === -1) continue;
+      console.log('  ' + l.trim());
+      if (!/--profile(?:\s|$)/.test(l)) {
+        console.log('  警告: crontab 命令未固定服务 profile；请重新执行 yotta-memory lan enable 修复');
+      }
+    }
   } else {
     console.log('crontab @reboot: 未启用');
   }
@@ -12177,9 +12341,11 @@ function cmdLanWinEnable(opts) {
   }
   const result = lanWindowsEnableCore(opts);
   if (result.mode === 'task') {
+    opts = Object.assign({}, opts, { profilePath: result.profilePath });
     const triggerText = result.trigger === 'onstart' ? '开机触发（无需登录）' : '登录触发';
     console.log('已注册开机自启: 计划任务 ' + LAN_TASK_NAME + '（' + triggerText + '，后台静默运行，不弹窗口）');
     console.log('运行命令: ' + lanTaskRunCmd(opts));
+    console.log('服务 profile: ' + result.profilePath);
     console.log('日志: ' + result.logPath);
     if (result.removedStartup && result.removedStartup.length) {
       console.log('已清理旧 Startup 兜底文件 ' + result.removedStartup.length + ' 个（避免双份自启）');
@@ -12188,6 +12354,10 @@ function cmdLanWinEnable(opts) {
     return;
   }
   if (result.error) {
+    if (result.phase === 'profile') {
+      console.error('服务 profile 写入失败，拒绝注册开机自启: ' + String(result.text || '').split(/\r?\n/)[0]);
+      process.exit(1);
+    }
     console.error('计划任务注册失败: ' + String(result.reason || '').split(/\r?\n/)[0]);
     console.error('写 Startup 自启失败: ' + String(result.text || '').split(/\r?\n/)[0]);
     console.error('请用管理员终端执行 yotta-memory lan enable，或将以下命令手动加入启动项: ' + lanTaskRunCmd(opts));
@@ -12200,6 +12370,7 @@ function cmdLanWinEnable(opts) {
   console.log('已启用用户级 Startup 静默自启（无需管理员）');
   console.log('启动脚本: ' + result.vbsPath);
   console.log('启动命令: ' + result.cmdPath);
+  console.log('服务 profile: ' + result.profilePath);
   console.log('日志: ' + result.logPath);
   console.log('备注: 服务不会立刻启动，需重新登录后自动启动；如需现在运行请执行 yotta-memory serve');
   console.log('提示: 如需改回计划任务（后台静默），请用管理员终端重新执行 yotta-memory lan enable');
@@ -12236,9 +12407,12 @@ function cmdLanWinStatus() {
     return;
   }
   let taskFound = false;
+  const profilePath = lanServeProfilePath();
   const q = lanWindowsRunSchtasks({}, ['/query', '/tn', LAN_TASK_NAME, '/fo', 'LIST', '/v']);
   if (q.status === 0) {
     taskFound = true;
+    const xmlQ = lanWindowsRunSchtasks({}, ['/query', '/tn', LAN_TASK_NAME, '/xml']);
+    const xmlSaysS4U = xmlQ.status === 0 && /<LogonType>\s*S4U\s*<\/LogonType>/i.test(String(xmlQ.stdout || ''));
     console.log('计划任务 ' + LAN_TASK_NAME + ': 已启用');
     const re = /^(状态|Status|登录模式|Logon Mode|上次运行时间|Last Run Time|上次结果|Last Result|要运行的任务|Task To Run)\s*[:=]\s*(.+)$/;
     let logonMode = '';
@@ -12250,12 +12424,31 @@ function cmdLanWinStatus() {
       if (/^(登录模式|Logon Mode)$/.test(m[1])) logonMode = m[2];
       if (/^(要运行的任务|Task To Run)$/.test(m[1])) taskRun = m[2];
     }
-    if (/interactive|交互式/i.test(logonMode)) {
+    if (/interactive|交互式/i.test(logonMode) && !xmlSaysS4U) {
       console.log('  提示: 登录模式为交互式（仅登录时运行，且在登录会话会弹窗口）——这是旧版任务；请重新执行 yotta-memory lan enable 修复为后台静默');
     }
     if (lanTaskCommandNeedsElectronEnv(taskRun)) {
       console.log('  警告: 任务命令指向 Electron 可执行文件（如 YottaCode.exe）但缺少 ELECTRON_RUN_AS_NODE —— 开机将拉起桌面程序而非服务；请重新执行 yotta-memory lan enable 修复');
     }
+    if (taskRun && !/--profile(?:\s|$)/.test(taskRun)) {
+      console.log('  警告: 任务命令未固定服务 profile，S4U / 无用户环境启动可能落到错误记忆库；请重新执行 yotta-memory lan enable 修复');
+    }
+    if (fs.existsSync(profilePath)) {
+      console.log('  服务 profile: ' + profilePath);
+      const loaded = loadServeProfile(profilePath);
+      if (loaded.error) {
+        console.log('  警告: ' + loaded.text);
+      } else {
+        console.log('  记忆库: ' + loaded.profile.memoryHome);
+        console.log('  运行时: ' + loaded.profile.runtimeHome);
+        const drift = serveProfileDrift(loaded.profile);
+        if (drift.length) {
+          console.log('  警告: 服务 profile 与当前配置漂移(' + drift.join(', ') + ')，请重新执行 yotta-memory lan enable');
+        }
+      }
+    } else {
+      console.log('  警告: 服务 profile 不存在: ' + profilePath + '；请重新执行 yotta-memory lan enable');
+    }
   } else {
     console.log('计划任务 ' + LAN_TASK_NAME + ': 未启用');
   }
@@ -13254,6 +13447,7 @@ async function main() {
       else if (a === '--id') opts.id = v;
       else if (a === '--time') opts.time = v;
       else if (a === '--tools') opts.toolProfile = v;
+      else if (a === '--profile') opts.profile = v;
       else if (a === '--mcp-config') opts.mcpConfigPaths = (opts.mcpConfigPaths || []).concat(v);
       else if (a === '--skill-dir') opts.skillDirs = (opts.skillDirs || []).concat(v);
       else if (a === '--year') opts.years = (opts.years || []).concat(v);
@@ -13296,6 +13490,16 @@ async function main() {
     console.error('位置参数不足：yotta-memory remember <type> <subject> <statement>');
     process.exit(2);
   }
+  if (first === 'serve' && opts.profile) {
+    const applied = applyServeProfile(opts.profile);
+    if (applied.error) {
+      console.error('服务 profile 启动失败: ' + applied.text);
+      process.exit(2);
+    }
+    opts.profile = applied.profilePath;
+    if (opts.host === undefined && applied.profile.host) opts.host = applied.profile.host;
+    if (opts.port === undefined && applied.profile.port) opts.port = applied.profile.port;
+  }
   const runtimeIdentity = resolveIdentity(opts);
   setRuntimeAgent(runtimeIdentity.error ? '' : runtimeIdentity.id, runtimeIdentity.error ? '' : runtimeIdentity.agentKey);
   switch (first) {
@@ -13512,6 +13716,12 @@ module.exports = {
   runtimeDoctorCore: runtimeDoctorCore,
   runtimeEnsureForManagedTask: runtimeEnsureForManagedTask,
   runtimeRestartManagedServer: runtimeRestartManagedServer,
+  lanServeProfilePath: lanServeProfilePath,
+  resolveProfilePath: resolveProfilePath,
+  lanWriteServeProfile: lanWriteServeProfile,
+  loadServeProfile: loadServeProfile,
+  applyServeProfile: applyServeProfile,
+  serveProfileDrift: serveProfileDrift,
   lanTaskRunCmd: lanTaskRunCmd,
   lanStartupDir: lanStartupDir,
   lanAutostartDir: lanAutostartDir,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yottameta/yotta-memory",
-  "version": "0.24.0",
+  "version": "0.24.3",
   "description": "Yuanyi (元忆) — boundary-aware, file-based memory for AI agents. File-based, zero-dependency, diff/rollback-able; FACT/PREF/BOUND/COMMIT types (public shared / private isolated), user-level + project-level storage; v0.12 reliability baseline (init guard, trash-based deletion, independent-volume backup/list/doctor/restore, start-of-work doctor, transactional snapshots before destructive writes), v0.10 consolidation (periodic summaries with provenance, near-duplicate auto-merge, per-type decay, batch audit + rollback), v0.9 recall quality + context focus + optional local embedding plugin, plus v0.8 semantic search, feedback loop, self-organization and distillation.",
   "license": "MIT",
   "keywords": [

package/references/faq.md

@@ -53,6 +53,9 @@ yotta-memory recall <关键词> --agent <id> --agent-key-file "<AI_HOME>/.yotta-
 ## 6.1 全局 CLI、MCP 或常驻服务版本不一致？
 先跑 `yotta-memory doctor --runtime`：它会列出 CLI、current、`runtime.json`、MCP 配置、运行中 server、技能副本与身份模式的漂移，并给出实际版本、期望版本、修复命令和是否阻断。用 `yotta-memory runtime install --from-current` 建立 `<runtimeRoot>/current` 稳定入口；升级用 `runtime install <tarball|版本>` + `runtime use <版本> --restart`，回滚用 `runtime rollback --restart`。`lan enable` 与备份调度只登记 `current/bin/yotta-memory.js`，不再写死版本目录。
 
+## 6.2 电脑异常重启后，局域网 MCP 一直返回 401？
+先运行 `yotta-memory lan status`，检查“服务 profile”的记忆库是否指向真实库，而不是 `C:\Users\Default\.yottamemory`。v0.24.1 起，`lan enable` 会生成每用户 `serve-profile.json`，任务命令应包含 `--profile <绝对路径>`。若仍显示旧任务未固定 profile，请在目标用户的管理员终端重新执行 `yotta-memory lan enable --onstart`，然后结束旧任务并从新任务启动。这样 S4U / 无登录会话启动不会重新猜测 home，也不会起在空库上。运行中的服务日志应显示 `服务 profile:` 与真实 `记忆库:`。
+
 ## 7. MCP 工具没加载？
 检查客户端 `mcpServers` 已配置 yotta-memory（url + token + agent_key）；agent_key 应来自 `<AI_HOME>/.yotta-memory-agent-key` 或 MCP secret 注入，不把明文 key 写进对话。改配置后重启/重载会话。本机直连可不配 MCP，直接用 CLI。
 

package/references/protocol.md

@@ -1,4 +1,4 @@
-# yotta-memory 协议规范 v0.24.0
+# yotta-memory 协议规范 v0.24.1
 
 > 本文件定义 yotta-memory 记忆标准：存储位置、目录结构、文件格式、类型体系与 CLI 命令参考。
 > 目标：任何支持 Agent Skills 开放标准的智能体，装完即可读写同一份记忆。
@@ -159,6 +159,8 @@ magic "YTMIDX1" (7B) | nonce(12B) | tag(16B) | ciphertext(JSON: {version, update
 | `reindex` | 全量扫描重建 `index.json`（手动改 .md 后校正）|
 | `index --stats [--json]` | 只读分析索引存储 / 逻辑体积、字段占比、token 与 gzip 年份分片预估 |
 | `layout plan/apply/rollback` | 生成日级目录迁移计划、按 journal 执行、失败回滚或按批次恢复 |
+| `serve --profile <文件>` | 读取每用户服务 profile，固定 memoryHome / runtimeHome / configDir；缺失或无效时 fail-closed |
+| `lan enable/disable/status` | 生成并检查每用户 `serve-profile.json`；自启任务只引用该 profile |
 | `export [--out f.json]` | 导出全部记忆为 JSON |
 | `import <f.json>` | 从 JSON 导入（幂等）|
 | `profile [--owner <id>]` | 用户画像聚合（零推断，写 `private/<owner>/profile.md`；跨 owner 默认拒绝）|

package/skill-manifest.json

@@ -3,7 +3,7 @@
   "slug": "yotta-memory",
   "name": "元忆",
   "package": "@yottameta/yotta-memory",
-  "version": "0.24.0",
+  "version": "0.24.3",
   "trust": "yottameta",
   "install": {
     "idempotent": true