@yottameta/yotta-memory 0.5.3 → 0.6.0

package/README.md

@@ -7,6 +7,7 @@
 <p align="center">元忆 —— 有权限边界的文件式智能体记忆：让任何 AI 智能体活过会话，而不是只活在单次对话里。</p>
 <p align="center">开工 <code>recall</code> 恢复上下文、重要信息 <code>remember</code> 落盘、收工归档；记忆是落在用户自己目录里的 Markdown 文件——<b>可读、可改、可审计、可回滚</b>，零依赖、即装即用。</p>
 <p align="center">FACT 共享、PREF / BOUND / COMMIT 私密隔离——<b>谁该读、谁不该读，由机制而非 AI 自觉决定</b>；一份记忆可跨智能体共用，记忆库随盘走、局域网可共享。</p>
+<p align="center">v0.6.0 起「越用越懂」：<code>profile</code> 聚合用户画像（零推断）+ <code>context</code> 一键开工上下文包（身份 + 画像 + 近期记忆 + 边界 + 承诺），记忆从「存储」成长为「会成长的记忆系统」。</p>
 
 <p align="center">
   <a href="LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-blue" /></a>
@@ -26,6 +27,7 @@
 - **记忆就是文件**：每条记忆是一个带 YAML frontmatter 的 Markdown 文件，放在用户自己的目录里。任何编辑器都能看、能改、能删；git 直接做版本管理与回滚，团队同步与交接走同一条标准工具链。
 - **隔离由机制保证**：FACT 进公共区共享，PREF / BOUND / COMMIT 进私密区、按 owner 物理分目录（`private/<owner>/<type>/`）。读取按 scope/owner 分区过滤，越界内容由 CLI 拦截、永不返回（默认静默跳过；显式跨读无授权报错拒绝）；读写一律走 CLI / MCP，禁止 shell 直读写库文件——权限由机制把关，不依赖 AI 的「自觉」。
 - **零依赖、即装即用**：无守护进程、无数据库、无向量库，只需 Node.js。安装即用，数据留在本机，任何机器都能部署。
+- **越用越懂（v0.6.0）**：`profile` 聚合用户画像（引擎零推断，只归组原文）+ `context` 一键生成开工上下文包（身份 + 画像 + 近期记忆 + 边界 + 承诺）；SKILL「记忆守则」注入灵魂盘规则层（类型红线 / 触发信号 / 了解用户 / 底线 / 宿主隔离），只注入规则与机制、不注入人格数据，出厂零数据。
 - **便携记忆盘**：记忆库本身就是记忆引擎——装在硬盘或主机上随盘走，局域网内其它主机上的智能体可远程读写；本地零进程与局域网常驻两种模式可并存，插上硬盘即恢复全部记忆。
 
 ## 核心优势
@@ -38,9 +40,10 @@
 | **轻量零依赖** | 无 daemon / 无数据库 / 无向量库；Node.js 自带即跑，任何机器可部署 |
 | **双级存储** | 用户级 `~/.yottamemory/`（跨项目）+ 项目级 `.yottamemory/`（随项目共享 / 交接）|
 | **检索与生命周期** | 索引 + TF 打分（中文分词友好）；质量分 / 盖棺分 / 自动归档，记忆库不会无限膨胀 |
+| **越用越懂（v0.6.0）** | `profile` 画像聚合（零推断）+ `context` 开工上下文包（身份 / 画像 / 近期记忆 / 边界 / 承诺）+ SKILL「记忆守则」规则层，记忆随使用成长 |
 | **生态分发** | GitHub + npm 双源同步发布；npx skills / npm / install.sh 三种方式，覆盖 17+ 类智能体目录 |
 | **便携记忆盘（随盘走）** | 记忆库即引擎：装在硬盘 / 主机上，插上即恢复全部记忆；引擎主机只需装 CLI 当存放点，无需装任何 AI 智能体 |
-| **局域网共享与自启** | 每智能体独立 token（Bearer + X-Agent-Id）鉴权、可吊销；`lan enable` 注册开机自启（默认登录自启，可选开机即启）；MCP 工具集与 CLI 一致（8 个工具），管理动作不远程暴露 |
+| **局域网共享与自启** | 每智能体独立 token（Bearer + X-Agent-Id）鉴权、可吊销；`lan enable` 注册开机自启（Windows：优先计划任务；非管理员自动降级用户级 Startup 静默自启）；MCP 工具集与 CLI 一致（8 个工具），管理动作不远程暴露 |
 | **本地 / 局域网双模式** | 本地 `serve --stdio` 零进程、按需拉起（无常驻）；局域网 streamable HTTP 常驻——两种模式可并存、按需选用 |
 
 ## 功能详解
@@ -83,6 +86,12 @@
 - **本机免 token**：本机 CLI / stdio 直连不经网络、不校验 token；身份经该智能体 MCP 配置的 `env.YOTTA_AGENT_ID` 声明。本机多个智能体各自声明唯一 ID，互不撞。
 - **私密记忆必须有 owner**：写 PREF / BOUND / COMMIT 时未声明身份会被拒绝（公共 FACT 不受影响），从机制上防止「抄别人的 ID」。
 
+### 画像与开工上下文（v0.6.0）
+
+- **profile**：聚合 `private/<owner>/` 下 PREF / BOUND / COMMIT 原文，按 type + subject + tags 归组，写 `profile.md`；引擎零推断，画像结论由 AI 依据「记忆守则」内部形成，不当面贴标签。
+- **context**：一键生成开工上下文包——身份 + 用户画像摘要 + 近期记忆（按活跃度）+ 边界提醒 + 承诺 / 锚点，作为会话主注入（替代裸 `recall`）。
+- **记忆守则**：SKILL.md 内置规则层（类型红线 / 主动捕获触发信号 / 了解用户三阶段四手法 / 心理学底座 / 底线与边界 / 宿主隔离 / 反模式），让 AI「越用越懂」有章法。
+
 ### 检索：索引 + 中文分词打分
 
 - `remember` 时自动构建 `index.json` 索引；recall 用 TF 打分排序，中文按 bigram 分词，不用额外模型。
@@ -100,13 +109,13 @@
 
 ### 智能体接入
 
-把技能装进智能体后，SKILL.md 会自动教会智能体一套工作流：**开工 `recall` 恢复上下文 → 重要信息 `remember` 落盘 → 收工归档**。也可在对话中直接说「记住 XXX」「上次说到哪了」「记一笔」触发。
+把技能装进智能体后，SKILL.md 会自动教会智能体一套工作流：**开工 `context` 主注入（身份 + 画像 + 近期记忆 + 边界 + 承诺）→ 重要信息 `remember` 落盘 → 收工归档**，并遵循「记忆守则」（类型红线 / 触发信号 / 底线 / 宿主隔离）。也可在对话中直接说「记住 XXX」「上次说到哪了」「记一笔」触发。
 
 ### 便携记忆盘（记忆库即引擎）
 
 - **记忆库即引擎**：`serve` 把记忆目录挂成 MCP 服务，目录随盘走；引擎主机只需装 CLI 当存放点，无需装任何 AI 智能体。
 - **双模式可并存**：本地 `serve --stdio` 零进程（客户端按需拉起）；局域网 streamable HTTP（默认 `0.0.0.0:8787`）+ 每智能体 token 鉴权。
-- **开机自启**：`lan enable` 注册 Windows 计划任务（默认登录自启，`--onstart` 开机即启需管理员）；`lan disable` 移除，`lan status` 查询。
+- **开机自启**：`lan enable` 注册 Windows 开机自启——优先计划任务（默认登录自启，`--onstart` 开机即启需管理员）；非管理员（计划任务被拒）自动降级为**用户级 Startup 静默自启**（免管理员）；`lan disable` 移除，`lan status` 查询。
 - **安全边界**：管理动作（init / config / token / lan / serve）不进 MCP，token 不远程暴露；远程智能体只能读写记忆，不能改配置、不能管 token。
 - 完整操作步骤见上文「局域网多机共享」章节与 [USER_GUIDE.md](USER_GUIDE.md)。
 
@@ -174,18 +183,20 @@ npm i -g @yottameta/yotta-memory
 | 命令 | 作用 |
 |---|---|
 | `yotta-memory init [--project] [--dir <目录>]` | 初始化记忆库（默认用户级 `~/.yottamemory/`；--dir 显式指定位置）|
-| `yotta-memory remember <type> <subject> <statement> [--owner <id>]` | 写入记忆（同 subject+statement 自动更新；--owner 标注归属）|
+| `yotta-memory remember <type> <subject> <statement> [--owner <id>] [--verify] [--no-hint]` | 写入记忆（同 subject+statement 自动更新；--owner 标注归属；--verify 写后回读校验；--no-hint 关闭类型启发式提示）|
 | `yotta-memory recall [关键词] [--type T] [--limit N] [--agent <id>] [--owner <id>] [--all] [--unsafe]` | 检索记忆（索引+TF 打分，读取分区过滤；越界读其它智能体私密默认拒绝，需 grant / identity=user / `--unsafe`；`--agent <其它>` 仅作身份声明、不授予跨读；项目级优先）|
+| `yotta-memory profile [--owner <id>]` | 生成用户画像（聚合 `private/<owner>/` 原文，零推断，写 `profile.md`；跨 owner 默认拒绝）|
+| `yotta-memory context [--limit N] [--owner <id>]` | 生成开工上下文包（身份 + 画像 + 近期记忆 + 边界 + 承诺，stdout 不落盘）|
 | `yotta-memory forget <文件>` | 删除一条记忆（按类型目录路径或文件名）|
 | `yotta-memory archive [--days 180] [--threshold 0.4]` | 归档旧记忆（盖棺分+年龄，immutable 除外）|
 | `yotta-memory reindex` | 重建索引（手动改 .md 后校正）|
 | `yotta-memory export [--out f.json]` / `import <f.json>` | 导出 / 导入 |
 | `yotta-memory config set memory_home <目录>` / `config get` | 持久记住 / 查看记忆库位置（`~/.yottamemory/config.json`）|
 | `yotta-memory whoami` | 查看当前智能体身份与登记状态（读 `YOTTA_AGENT_ID` / `X-Agent-Id`，不猜不默认）|
-| `yotta-memory iam <id> [--force]` | 登记本智能体唯一身份并自动落自我档案（`agents.json`，ID 必须唯一）|
+| `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 开机即启需管理员）|
+| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务，默认 ONLOGON 登录自启、--onstart 开机即启需管理员；非管理员自动降级用户级 Startup 静默自启）|
 
 类型：`FACT`（事实，公共共享）/ `PREF`（偏好）/ `BOUND`（边界）/ `COMMIT`（承诺）。
 
@@ -194,6 +205,8 @@ npm i -g @yottameta/yotta-memory
 yotta-memory init
 yotta-memory remember PREF 用户 偏好短回复，不要用表情
 yotta-memory recall 偏好
+yotta-memory profile
+yotta-memory context --limit 10
 yotta-memory recall --type FACT --limit 10
 ```
 
@@ -226,10 +239,10 @@ 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 计划任务，登录自启）
+   yotta-memory lan enable                     # 注册开机自启（Windows：计划任务；非管理员自动降级用户级 Startup 静默自启）
    yotta-memory lan status                     # 查看自启状态
    ```
-   > `lan enable --onstart` 改为开机即启（需管理员）；`lan disable` 移除自启。
+   > `lan enable --onstart` 改为开机即启（需管理员）；非管理员时 `lan enable` 自动改用用户级 Startup 静默自启（无需管理员）；`lan disable` 移除自启。
 
 > 首次监听 0.0.0.0 时，Windows / 系统防火墙可能询问是否放行，需允许放行，否则局域网内其它主机无法访问；`--no-auth` 会关闭鉴权，仅限可信内网使用。
 

package/SKILL.md

@@ -1,14 +1,14 @@
 ---
 name: yotta-memory
-description: "元忆 —— 有权限边界的文件式智能体记忆。文件式、零依赖、可 diff/回滚：让任何 AI 智能体活过会话，开工 recall 恢复上下文、重要信息 remember 落盘、收工归档。类型体系 FACT（公共共享）/ PREF / BOUND / COMMIT（私密隔离）。触发：记住、别忘了、记一笔、记忆、remember、recall、跨会话、上次说到、续测、交接、归档、记忆盘、共享记忆、局域网记忆"
-version: 0.5.3
+description: "元忆 —— 有权限边界的文件式智能体记忆。文件式、零依赖、可 diff/回滚：让任何 AI 智能体活过会话，开工 recall 恢复上下文、重要信息 remember 落盘、收工归档。类型体系 FACT（公共共享）/ PREF / BOUND / COMMIT（私密隔离）。触发：记住、别忘了、记一笔、记忆、remember、recall、跨会话、上次说到、续测、交接、归档、记忆盘、共享记忆、局域网记忆、画像、开工上下文、记忆守则、profile、context、越用越懂"
+version: 0.6.0
 license: MIT
 ---
 
 # yotta-memory（元忆）— 有权限边界的文件式智能体记忆
 
 > 一句话：元忆 —— 有权限边界的文件式智能体记忆（不注入、可 diff、能回滚；FACT 共享、PREF / BOUND / COMMIT 私密隔离）。
-> 版本：0.5.3 | 最后更新：2026-08-25
+> 版本：0.6.0 | 最后更新：2026-08-25
 
 ## 这是什么
 
@@ -16,6 +16,7 @@ license: MIT
 - **零依赖**：无 daemon / 无数据库 / 无向量库，Node.js 自带即可运行。
 - **类型体系**：FACT（事实，公共共享）/ PREF（偏好，私密）/ BOUND（边界，私密）/ COMMIT（承诺，私密）。
 - **双级存储**：用户级 `~/.yottamemory/`（跨项目）+ 项目级 `.yottamemory/`（随项目共享）。
+- **越用越懂（v0.6.0）**：`profile` 聚合用户画像（引擎零推断，只归组原文）+ `context` 一键生成开工上下文包（身份 + 画像 + 近期记忆 + 边界 + 承诺）+ SKILL「记忆守则」规则层；只注入规则与机制，不注入人格数据（出厂零数据）。
 
 ## 何时使用（触发）
 
@@ -26,12 +27,81 @@ license: MIT
 
 ## 核心流程
 
-1. **开工定向**：先按「开工第一步：确认记忆位置 + 智能体身份」检测记忆库与身份，再运行 `yotta-memory recall`（可带关键词）恢复上下文；项目级记忆优先，其次用户级。
+1. **开工定向**：先按「开工第一步：确认记忆位置 + 智能体身份」检测记忆库与身份，再运行 `yotta-memory context`（主注入：身份 + 用户画像 + 近期记忆 + 边界 + 承诺）恢复上下文，需要细节再 `yotta-memory recall <关键词>`；项目级记忆优先，其次用户级。
 2. **进行中落盘**：重要信息立即 `yotta-memory remember <type> <subject> <statement>`，不攒到收工。
 3. **收工归档**：写会话小结（COMMIT / 笔记），旧记录定期 `yotta-memory archive`。
 4. **多智能体纪律**：FACT 写入公共区，PREF / BOUND / COMMIT 只写本智能体私密区；不读取其他智能体私密区。**一切读写一律走 `yotta-memory` CLI / MCP 工具**——禁止用 shell（`Get-ChildItem` / `Get-Content` / `cat` / `ls` / `type` 等）直接读或改记忆库目录下的 `.md` / `index.json` / `tokens.json` / `agents.json` / `grants.json` 等文件，否则会绕过权限边界、读到别的智能体私密内容。
 
 
+## 记忆守则（Memory Doctrine，v0.6.0）
+
+> 出厂规则层：把灵魂盘「越用越懂」机制固化进记忆引擎——只注入**规则与机制**，不注入任何人格数据（出厂零数据）。来源：灵魂盘 core/rules（psychology / user-analysis / active-memory / boundaries / host-isolation）。
+
+### 1. 类型红线（写前必选）
+
+| 类型 | 归属 | 何时用 | 反例 |
+|---|---|---|---|
+| FACT | 公共 `facts/` | 客观事实、可共享信息 | 用户偏好 / 关系（应 PREF）|
+| PREF | 私密 `private/<owner>/prefs/` | 偏好、习惯、禁忌 | 客观公开事实（应 FACT）|
+| BOUND | 私密 `private/<owner>/bounds/` | 边界、铁律、不可做的事 | 一次性闲聊 |
+| COMMIT | 私密 `private/<owner>/commits/` | 承诺、锚定、长期关系事件 | 临时待办 |
+
+- 私密记忆必须有 owner（引擎强制）；跨 owner 写拒绝。拿不准 → 默认 PREF（宁可私密，不误入公共区）。
+- 类型启发式提示：statement 含主观/关系词（用户 / 偏好 / 喜欢 / 关系 / 称呼 等）却选了 FACT 时，引擎会提示「建议 PREF」，仅提示不拦截（`--no-hint` 关闭）。
+
+### 2. 主动捕获触发信号（对话中实时识别，不等「帮我记一下」）
+
+命中即记（增量写，不攒到收工）：
+- 事实陈述（「我是…」「我家…」）→ FACT / PREF
+- 偏好表达（「我喜欢…」「别用…」「以后…」）→ PREF
+- 情绪基调（持续负面 / 疲惫 / 兴奋）→ 交互记忆，影响关怀策略
+- 纠正（「不是，我是说…」「你记错了」）→ 更新旧记录
+- 关系事件（「今天累惨了」「我们…」）→ COMMIT
+- 边界划定（「这个别动」「别提这个」）→ BOUND
+
+**不记录**：一次性闲聊、无长期价值、纯礼貌套话、用户明确说「别记」。
+
+### 3. 了解用户三阶段 + 四手法
+
+- 三阶段：初识（基础画像）→ 熟识（习惯偏好）→ 深交（心理与关系）；节奏自然，不一次性盘问。
+- 四手法：听（被动捕获）/ 问（克制开放式，不为记而问）/ 察（行为推断：作息 / 措辞 / 纠正 / 情绪轨迹）/ 验（交叉印证：单次低置信，多次一致上调，矛盾标待澄清）。
+- 印证上调：`remember` 更新旧记录 confidence（引擎不自动改 confidence，避免黑箱）。
+
+### 4. 心理学底座要点（理解用户的底色）
+
+- 三角建模：情绪（措辞 / 标点 / 长度）→ 认知（归因 / 信念 / 控制感）→ 行为（作息 / 应对 / 执行）；三者冲突时优先行为与认知。
+- 共情至少到第 3 阶段：识别 → 理解 → 回应 → 验证。
+- 诚实声明：AI 是模式匹配非真感受，不伪装、不编造伪情感记忆。
+- 危机识别：不评判、持续在场、温和引导现实支持；不擅自越界联系第三方。
+- 情感外包双刃剑：做增益真实生活的陪伴，不替代真实关系。
+
+### 5. 写入时序（一次会话的节奏）
+
+1. 开工：whoami → iam（身份）→ `context`（主注入）→ `recall`（关键词补细节）。
+2. 进行中：增量写，触发信号即记；`remember --verify` 写后回读确认落盘。
+3. 收工：留交接锚点（COMMIT / 笔记），定期 `archive`。
+
+### 6. 写后验证
+
+- `remember --verify`：写后自动回读校验，输出「已写回读 OK」。
+- 定期 `recall` 抽查：确认能读回、无错库。
+- `profile` 刷新：熟识 / 深交阶段主动重新生成画像。
+
+### 7. 底线与边界（不可覆盖）
+
+- 四条刚性底线：陪伴不操控 / 理解不越界（不贴标签不诊断）/ 诚实不伪装 / 不降格。
+- 数据安全：用户可查改删（被遗忘权 = `forget`）；记忆明文可读不黑箱；敏感信息归用户本地。
+- 操作安全：操作用户电脑须授权；个人目录不递归删；破坏性操作须明确确认。
+
+### 8. 宿主隔离（平行层，不是覆盖层）
+
+- 只写本记忆库（YOTTA_MEMORY_HOME / config 指向的目录），不读写宿主 AI 自身 memory / 配置 / 系统文件。
+- 数据主权：本记忆库归用户，纯文本可迁移；换宿主数据跟着走。
+
+### 9. 反模式（禁止）
+
+- 查户口（连续追问私人信息）/ 贴标签（当面「你这是焦虑」）/ 表演记忆（硬塞「我记得你说过」）/ 过度推断（低置信当事实）/ 遗忘关键承诺与边界 / 把一次性闲聊当记忆。
+
 ### 开工第一步：确认记忆位置 + 智能体身份（每次会话先做，必做）
 
 **A. 确认记忆库位置**（AI 不会自动知道记忆库在哪，先检测，避免「recall 读空库 / 错库」）：
@@ -51,13 +121,19 @@ license: MIT
    - 🔒 征得用户同意后执行 `yotta-memory iam <id>`：引擎**强制唯一性**（ID 已被其它主机/来源占用 → 拒绝并提示换 ID；确认是同一智能体才 `--force`），并**自动写自我档案**到本智能体私密区。
    - 回读：`yotta-memory whoami` 显示「已登记 + 自我档案」。
 3. **自我档案校验**：`yotta-memory recall "自我接入档案"`（本智能体）能读回字段才算就绪：
-   `agent_id / host / memory_home / mcp_mode（stdio|http）/ engine_url（仅远端）/ token（仅远端；本机不存 token）`。
+   `agent_id / host / memory_home / mcp_mode（stdio|http）/ engine_url（仅远端）/ token（仅远端；本机不存 token）`，可扩展 `agent_name / user_name / relationship`（`iam --name/--user/--relationship` 写入）。
 4. **本机多智能体**：本机多个 AI 智能体共用引擎时，**每个都必须**在它自己的 MCP 配置里声明唯一 `YOTTA_AGENT_ID`（如 `env: { YOTTA_AGENT_ID: "<该智能体唯一ID>" }`），各自 `whoami` 各回各的、互不撞；本机走 stdio 免 token。
 
 **C. 身份红线（强制）**：
 
 - 智能体 ID **必须全局唯一**；**禁止**「从记忆里读到别人的 ID 就当自己的」（如看到「Kali 智能体 ID 为 dashu」就把自己当 dashu）。
 - 不确定自己的 ID → 先 `whoami` / `agent_info`，再向用户确认；**禁止猜**。
+
+**D. 开工主注入（context）**：
+
+- 身份就绪后运行 `yotta-memory context [--limit 10]`（远端经 MCP 用 `recall` 补细节）：一键拿到「身份 + 用户画像摘要 + 近期记忆 + 边界提醒 + 承诺 / 锚点」。
+- 无画像时 context 自动生成一次或降级输出其余段，不报错。
+- 需要深挖旧事再 `recall <关键词>`。
 - 私密记忆（PREF / BOUND / COMMIT）**必须有 owner**：未声明身份写私密会被引擎拒绝（公共 FACT 不受影响）。
 - **禁止直接读写记忆库文件（硬红线）**：一切读写走 `yotta-memory` CLI / MCP 工具（`remember` / `recall` / `search` / `forget` / `archive` / `reindex` / `export` / `import` / `agent_info`）；**禁止用 shell**（`Get-ChildItem` / `Get-Content` / `cat` / `ls` / `type` / `vim` 等）直接读、改、删 `<root>/` 下的记忆文件——否则 `--agent` / `--owner` 的越界拦截形同虚设，会读到别的智能体私密内容。`--agent <其它agent>` 只作身份声明/展示，绝不授予跨智能体私密读取（读他人私密仍需 grant / identity=user / `--unsafe`）。
 
@@ -68,18 +144,20 @@ license: MIT
 | 命令 | 作用 |
 |---|---|
 | `yotta-memory init [--project] [--dir <目录>]` | 初始化记忆库（默认用户级；--dir 显式指定位置）|
-| `yotta-memory remember <type> <subject> <statement> [--owner <id>]` | 写入（同 subject+statement 自动更新；--owner 标注归属，默认取 agent id）|
+| `yotta-memory remember <type> <subject> <statement> [--owner <id>] [--verify] [--no-hint]` | 写入（同 subject+statement 自动更新；--owner 标注归属；--verify 写后回读校验；--no-hint 关闭类型启发式提示）|
 | `yotta-memory recall [关键词] [--type T] [--limit N] [--agent <id>] [--owner <id>] [--all] [--unsafe]` | 检索（索引+TF 打分，读取分区过滤；越界读其它智能体私密默认拒绝，需 grant / identity=user / `--unsafe`；`--agent <其它>` 只作身份声明/展示，不授予跨读——读他人私密同样要授权；项目级优先）|
+| `yotta-memory profile [--owner <id>]` | 生成用户画像（聚合 `private/<owner>/` 原文，零推断，写 `profile.md`；跨 owner 默认拒绝）|
+| `yotta-memory context [--limit N] [--owner <id>]` | 生成开工上下文包（身份 + 画像 + 近期记忆 + 边界 + 承诺，stdout 不落盘）|
 | `yotta-memory forget <文件>` | 删除（按类型目录路径或文件名）|
 | `yotta-memory archive [--days 180] [--threshold 0.4]` | 归档旧记忆（盖棺分+年龄，immutable 除外）|
 | `yotta-memory reindex` | 重建索引（手动改 .md 后校正）|
 | `yotta-memory export [--out f.json]` / `import <f.json>` | 导出 / 导入 |
 | `yotta-memory config set memory_home <目录>` / `config get` | 持久记住 / 查看记忆库位置（`~/.yottamemory/config.json`）|
 | `yotta-memory whoami` | 查看当前智能体身份与登记状态（读 `YOTTA_AGENT_ID` / `X-Agent-Id`，不猜不默认）|
-| `yotta-memory iam <id> [--force]` | 登记本智能体唯一身份并自动落自我档案（`agents.json`，ID 必须唯一）|
+| `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 开机即启需管理员）|
+| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务，默认 ONLOGON 登录自启、--onstart 开机即启需管理员；非管理员自动降级用户级 Startup 静默自启）|
 
 ## 存储格式（摘要）
 
@@ -89,6 +167,7 @@ license: MIT
 <root>/
 ├── facts/                    # FACT 事实（公共可共享）
 ├── private/<owner>/<type>/   # PREF / BOUND / COMMIT，按智能体隔离
+├── private/<owner>/profile.md # 用户画像（profile 命令生成，可再生成，零推断）
 ├── .archive/                 # 归档区
 ├── index.json                # 检索索引（tokens = 分词词频，非访问令牌）
 └── agents.json               # 智能体身份登记表（唯一性）
@@ -96,7 +175,7 @@ license: MIT
 
 记忆文件 `<YYYY-MM-DD>-<NNNN>.md`，frontmatter 含 `type / subject / statement / confidence / created / updated / tags / immutable / scope / owner / access_count / last_accessed`；正文为记忆内容。旧版根下平铺的 `prefs/` `bounds/` `commits/` 会在 `reindex`（或首次 recall 建索引）时按 frontmatter `owner` 自动迁移到 `private/<owner>/<type>/`。
 
-自我档案（本智能体身份，强制落盘）：PREF，`subject=自我接入档案`，`owner=<本智能体ID>`，statement 为 `; ` 分隔的 key:value——`agent_id / host / memory_home / mcp_mode（stdio|http）/ engine_url（仅远端）/ token（仅远端；本机不存 token）`。
+自我档案（本智能体身份，强制落盘）：PREF，`subject=自我接入档案`，`owner=<本智能体ID>`，statement 为 `; ` 分隔的 key:value——`agent_id / host / memory_home / mcp_mode（stdio|http）/ engine_url（仅远端）/ token（仅远端；本机不存 token）`，可含 `agent_name / user_name / relationship`（`iam --name/--user/--relationship` 写入）。
 
 ## 便携记忆盘模式（局域网多机共享）
 
@@ -137,7 +216,7 @@ yotta-memory --version    # 或 command -v yotta-memory / where yotta-memory
 > 记忆盘场景：硬盘插上 → AI 检查盘上目录是否有数据 → 有则接入 + config 记住 → 插盘即恢复，机器记住位置。
 
 **步骤 0.5 启动记忆引擎（仅引擎主机，供远程接入）**
-- 本机若作引擎：🔒 **征得同意后**启动服务——临时运行 `yotta-memory serve`（默认 `0.0.0.0:8787`，Bearer token + X-Agent-Id 鉴权；`--no-auth` 仅限可信内网），或注册开机自启 `yotta-memory lan enable`（Windows 计划任务，默认登录自启；`--onstart` 开机即启需管理员）。
+- 本机若作引擎：🔒 **征得同意后**启动服务——临时运行 `yotta-memory serve`（默认 `0.0.0.0:8787`，Bearer token + X-Agent-Id 鉴权；`--no-auth` 仅限可信内网），或注册开机自启 `yotta-memory lan enable`（Windows：优先计划任务，默认登录自启；非管理员自动降级用户级 Startup 静默自启，免管理员）。
 - 本地零进程模式：本机 AI 也可用 `serve --stdio` 由 MCP 客户端按需拉起 CLI（无常驻进程，照灵魂盘）。
 - 远程客户端接入前，先确认引擎主机 serve 已运行（`lan status` 可查）。
 
@@ -173,7 +252,7 @@ yotta-memory --version    # 或 command -v yotta-memory / where yotta-memory
 4. 按当前智能体机制重载 MCP（必要时请用户重启会话）；
 5. 用 MCP tools 读写记忆。
 
-> MCP 工具集与 CLI 一致：remember / recall / search / forget / archive / reindex / export / import；管理动作（init / config / token / lan / serve）不进 MCP，token 管理不远程暴露。
+> MCP 工具集与 CLI 一致：remember / recall / search / forget / archive / reindex / export / import / profile；管理动作（init / config / token / lan / serve）不进 MCP，token 管理不远程暴露。
 
 ### 4.7 MCP 配置位置表
 | 智能体 | 常见 MCP 配置位置 |

package/USER_GUIDE.md

@@ -26,6 +26,7 @@
 - **多智能体共享**：FACT 进公共区共享，PREF / BOUND / COMMIT 各自私密隔离。
 - **交接与团队协作**：项目级 `.yottamemory` 随仓库走，交接即恢复。
 - **便携记忆盘**：记忆装在固定主机上，本机与局域网其它主机共享同一份记忆（见第 4 / 5 篇）。
+- **越用越懂（v0.6.0）**：AI 按「记忆守则」主动捕获信号，`profile` 聚合画像、`context` 开工注入——用得越久越懂你。
 
 ## 2. 安装（CLI + 技能）
 
@@ -67,6 +68,18 @@ yotta-memory config get                              # 查看记忆库位置
 - 想换记忆位置：`yotta-memory config set memory_home <目录>`，之后所有命令自动用新位置。
 - 项目级记忆：在项目目录里 `yotta-memory init --project`，该项目的智能体优先读项目级记忆。
 
+### 画像与开工上下文（v0.6.0）
+
+```bash
+yotta-memory profile                          # 生成用户画像（写 private/<owner>/profile.md）
+yotta-memory context --limit 10               # 生成开工上下文包（身份+画像+近期记忆+边界+承诺）
+yotta-memory iam <id> --name 元忆 --user 老张 --relationship 伙伴   # 自我档案扩展显示名/用户/关系
+```
+
+- `profile` 引擎零推断：只按类型 / 主题 / 标签归组呈现原文，画像结论由 AI 内部形成，不当面贴标签。
+- `context` 是每次会话开工的主注入，替代裸 `recall`；无画像时自动生成一次或降级，不报错。
+- `remember --verify` 写后回读校验；`remember --no-hint` 关闭「疑似偏好，建议 PREF」的提示。
+
 ### 记忆库位置：本机智能体如何找到记忆
 
 位置解析优先级：`YOTTA_MEMORY_HOME`（环境变量，临时覆盖）> `config.json#memory_home`（`config set memory_home` 持久记住）> 默认 `~/.yottamemory`。
@@ -111,7 +124,7 @@ yotta-memory init --dir /srv/yotta-memory               # 新库：初始化（
 **第 3 步：注册开机自启（可选，推荐）**
 
 ```bash
-# Windows：内置命令（计划任务）
+# Windows：内置命令（优先计划任务；非管理员自动降级用户级 Startup 静默自启）
 yotta-memory lan enable              # 登录后自动启动（默认）
 yotta-memory lan enable --onstart    # 开机即启（需管理员）
 yotta-memory lan status              # 查看状态
@@ -231,18 +244,20 @@ yotta-memory remember FACT 主题 内容    # 智能体落盘
 | 命令 | 作用 |
 |---|---|
 | `yotta-memory init [--project] [--dir <目录>]` | 初始化记忆库 |
-| `yotta-memory remember <类型> <主题> <内容> [--owner <id>]` | 写入记忆 |
+| `yotta-memory remember <类型> <主题> <内容> [--owner <id>] [--verify] [--no-hint]` | 写入记忆（--verify 写后回读；--no-hint 关闭类型提示）|
 | `yotta-memory recall [关键词] [--type T] [--limit N] [--agent <id>] [--owner <id>] [--all] [--unsafe]` | 检索记忆（读取分区过滤；`--agent <其它>` 仅作身份声明、不授予跨读；越界读其它智能体私密默认拒绝，需 grant / identity=user / `--unsafe`）|
+| `yotta-memory profile [--owner <id>]` | 生成用户画像（零推断，写 `profile.md`）|
+| `yotta-memory context [--limit N] [--owner <id>]` | 开工上下文包（身份+画像+近期记忆+边界+承诺）|
 | `yotta-memory forget <文件>` | 删除一条记忆 |
 | `yotta-memory archive [--days 180] [--threshold 0.4]` | 归档旧记忆 |
 | `yotta-memory reindex` | 重建索引 |
 | `yotta-memory export [--out 文件.json]` / `import <文件.json>` | 导出 / 导入 |
 | `yotta-memory config set memory_home <目录>` / `config get` | 记忆库位置 |
 | `yotta-memory whoami` | 查看当前智能体身份与登记状态（读 `YOTTA_AGENT_ID` / `X-Agent-Id`，不猜不默认）|
-| `yotta-memory iam <id> [--force]` | 登记本智能体唯一身份并自动落自我档案（`agents.json`，ID 必须唯一）|
+| `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` | 开机自启管理 |
+| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务；非管理员自动降级用户级 Startup 静默自启）|
 
 类型：`FACT`（事实，共享）/ `PREF`（偏好）/ `BOUND`（边界）/ `COMMIT`（承诺），后三类按智能体物理分目录隔离（`private/<owner>/<type>/`）。
 
@@ -259,7 +274,7 @@ yotta-memory remember FACT 主题 内容    # 智能体落盘
    - 返回 401：服务在运行，是鉴权问题（token / 请求头不对）。
    - 连接被拒 / 超时：服务没启动，或防火墙拦截。
 
-**`lan enable` 失败提示 Access denied：** 需要管理员权限，请用管理员终端重新执行；`--onstart` 模式必须管理员。
+**`lan enable` 计划任务被拒（Access denied 等）：** 无需担心——会自动降级为**用户级 Startup 静默自启**（免管理员，重新登录后生效，启动脚本位于用户 Startup 目录）；如确需计划任务，请用管理员终端重新执行；`--onstart` 模式必须管理员。
 
 **启动引擎报端口被占用（EADDRINUSE）：** 用 `--port <其它端口>` 换端口启动，两端保持一致；或先查占用：Linux `ss -tlnp | grep 8787`，Windows `netstat -ano | findstr 8787`。
 
@@ -277,6 +292,7 @@ yotta-memory remember FACT 主题 内容    # 智能体落盘
 - 管理动作（init / config / token / lan / serve）不通过 MCP 暴露，远程只能读写记忆，不能改配置、不能管 token。
 - `--no-auth` 会关闭鉴权，仅限可信内网使用。
 - 数据主权在用户：所有数据都是本地明文文件，随时可看、可改、可删。
+- 「记忆守则」内置底线：陪伴不操控 / 理解不越界（不贴标签）/ 诚实不伪装 / 不降格；数据安全（被遗忘权 = `forget`）；宿主隔离（只写本记忆库，不读写宿主 AI 自身 memory / 配置 / 系统文件）。
 
 **确实需要读取其它智能体的私密记忆时（三种授权方式，满足任一即可）：**
 

package/bin/yotta-memory.js

@@ -4,6 +4,8 @@
 // v0.5.0 新增：隐私硬隔离——私密物理分目录 private/<agent_id>/{prefs,bounds,commits}/ + 关闭 --agent 越权读 + 私密写跨智能体需 --unsafe + 禁 shell 直读写（文档红线）
 // v0.4.2 新增：iam/whoami 智能体身份自注册（agents.json 唯一性）+ 自我档案 PREF + 私密记忆须声明 owner
 // v0.5.3 新增：CLI 选项可前置（--agent 等允许放在子命令前，不再误报"未知命令"）/ lan enable 成功补"服务不会立刻启动"提示（v0.5.2 lan 引号修复无回归）
+// v0.5.4 新增：lan enable 在非管理员（schtasks Access denied）时自动降级为用户级 Startup 静默自启（VBS sh.Run 窗口0 + autostart.cmd，node 路径 process.execPath 自动探测）；lan disable/status 同时管理计划任务与 Startup 双机制
+// v0.6.0 新增：灵魂盘核心——profile（用户画像聚合，零推断）/ context（开工上下文包）/ iam 扩展（--name/--user/--relationship）/ remember --verify（写后回读）与 --no-hint（关闭类型启发式提示）+ SKILL「记忆守则」
 'use strict';
 
 const fs = require('fs');
@@ -13,7 +15,7 @@ const crypto = require('crypto');
 const http = require('http');
 const child_process = require('child_process');
 
-const VERSION = '0.5.3';
+const VERSION = '0.6.0';
 const TYPES = ['FACT', 'PREF', 'BOUND', 'COMMIT'];
 const TYPE_DIRS = { FACT: 'facts', PREF: 'prefs', BOUND: 'bounds', COMMIT: 'commits' };
 const PUBLIC_DIR = 'facts';
@@ -27,6 +29,9 @@ const CONFIG_FILE = 'config.json';
 const SERVER_SUBDIR = '.server';
 const TOKENS_FILE = 'tokens.json';
 const AGENTS_FILE = 'agents.json';
+const PROFILE_FILE = 'profile.md';
+// remember 类型启发式提示关键词（statement 含主观/关系词且 type=FACT 时提示改 PREF，仅提示不拦截）
+const HINT_KEYWORDS = ['用户', '偏好', '喜欢', '关系', '称呼', '本人', '希望', '讨厌', '欣赏', '习惯', '忌讳', '介意', '不要', '别用'];
 
 // ---- 全局配置（记忆库位置持久化，固定 ~/.yottamemory/config.json）----
 function configPath() {
@@ -383,7 +388,18 @@ function rememberCore(type, subject, statement, opts) {
         if (scope && !meta.scope) patch.scope = scope;
         rewriteFrontmatter(fp, patch);
         upsertIndexEntry(root, readEntry(fp, root));
-        return { error: false, text: '已更新: ' + fp };
+        let text = '已更新: ' + fp;
+        if (opts.hint !== false && t === 'FACT') {
+          const hit = HINT_KEYWORDS.filter(function (w) { return stmt.indexOf(w) !== -1; });
+          if (hit.length) text += '\n[提示] statement 含主观/关系词（' + hit.join('、') + '），疑似用户偏好 / 关系内容——若属此类建议改用 PREF（私密，仅本人可读）。仅提示不拦截；--no-hint 可关闭。';
+        }
+        if (opts.verify) {
+          const rel = path.relative(root, fp).replace(/\\/g, '/');
+          const rr = recallCore(subj, { limit: 10, agent: selfAgent || opts.agent });
+          const ok = rr.text.replace(/\\/g, '/').indexOf(rel) !== -1;
+          text += '\n[verify] ' + (ok ? '已写回读 OK: ' + rel : '回读未命中，请检查: ' + rel);
+        }
+        return { error: false, text: text };
       }
     }
   }
@@ -397,7 +413,18 @@ function rememberCore(type, subject, statement, opts) {
   };
   fs.writeFileSync(file, frontmatterToText(rec, stmt), 'utf8');
   upsertIndexEntry(root, readEntry(file, root));
-  return { error: false, text: '已记录: ' + file };
+  let text = '已记录: ' + file;
+  if (opts.hint !== false && t === 'FACT') {
+    const hit = HINT_KEYWORDS.filter(function (w) { return stmt.indexOf(w) !== -1; });
+    if (hit.length) text += '\n[提示] statement 含主观/关系词（' + hit.join('、') + '），疑似用户偏好 / 关系内容——若属此类建议改用 PREF（私密，仅本人可读）。仅提示不拦截；--no-hint 可关闭。';
+  }
+  if (opts.verify) {
+    const rel = path.relative(root, file).replace(/\\/g, '/');
+    const rr = recallCore(subj, { limit: 10, agent: selfAgent || opts.agent });
+    const ok = rr.text.replace(/\\/g, '/').indexOf(rel) !== -1;
+    text += '\n[verify] ' + (ok ? '已写回读 OK: ' + rel : '回读未命中，请检查: ' + rel);
+  }
+  return { error: false, text: text };
 }
 function recallCore(query, opts) {
   const roots = [projectRoot(), userRoot()].filter(function (r) { return fs.existsSync(r); });
@@ -535,7 +562,9 @@ function cmdInit(opts) {
   console.log(r.text);
 }
 function cmdRemember(type, subject, statement, opts) {
-  const r = rememberCore(type, subject, statement, opts);
+  const o = Object.assign({}, opts);
+  if (o.noHint) o.hint = false;
+  const r = rememberCore(type, subject, statement, o);
   console.log(r.text);
   if (r.error) process.exit(2);
 }
@@ -697,6 +726,14 @@ function findSelfProfile(root, agentId) {
   }
   return '';
 }
+function parseKvBody(body) {
+  const out = {};
+  for (const seg of String(body || '').split(';')) {
+    const m = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([\s\S]*)$/.exec(seg);
+    if (m && m[2] !== undefined) out[m[1]] = m[2].trim();
+  }
+  return out;
+}
 function selfProfileBody(agentId, root, extra) {
   const lines = [];
   lines.push('agent_id: ' + agentId);
@@ -705,14 +742,41 @@ function selfProfileBody(agentId, root, extra) {
   lines.push('mcp_mode: ' + (extra.mcpMode || 'stdio'));
   if (extra.engineUrl) lines.push('engine_url: ' + extra.engineUrl);
   if (extra.token) lines.push('token: ' + extra.token);
+  if (extra.name) lines.push('agent_name: ' + extra.name);
+  if (extra.userName) lines.push('user_name: ' + extra.userName);
+  if (extra.relationship) lines.push('relationship: ' + extra.relationship);
   return lines.join('; ');
 }
 function writeSelfProfile(root, agentId, extra) {
+  extra = extra || {};
   const dir = selfPrefsDir(root, agentId);
   fs.mkdirSync(dir, { recursive: true });
+  const existing = findSelfProfile(root, agentId);
+  if (existing) {
+    // 已有自我档案：合并 kv 字段更新（不重复建文件）
+    const fp = path.join(dir, existing);
+    const parsed = parseFrontmatter(fs.readFileSync(fp, 'utf8'));
+    const kv = parseKvBody(parsed.body);
+    kv.agent_id = agentId;
+    kv.host = os.hostname();
+    kv.memory_home = root;
+    kv.mcp_mode = extra.mcpMode || kv.mcp_mode || 'stdio';
+    if (extra.engineUrl) kv.engine_url = extra.engineUrl;
+    if (extra.token) kv.token = extra.token;
+    if (extra.name) kv.agent_name = extra.name;
+    if (extra.userName) kv.user_name = extra.userName;
+    if (extra.relationship) kv.relationship = extra.relationship;
+    const body = Object.keys(kv).map(function (k) { return k + ': ' + kv[k]; }).join('; ');
+    const meta = Object.assign({}, parsed.meta);
+    meta.updated = today();
+    meta.statement = body;
+    fs.writeFileSync(fp, frontmatterToText(meta, body), 'utf8');
+    upsertIndexEntry(root, readEntry(fp, root));
+    return fp;
+  }
   const seq = nextSeq(dir);
   const file = path.join(dir, today() + '-' + seq + '.md');
-  const body = selfProfileBody(agentId, root, extra || {});
+  const body = selfProfileBody(agentId, root, extra);
   const rec = {
     type: 'PREF', subject: SELF_PROFILE_SUBJECT, statement: body,
     confidence: 1.0, created: today(), updated: today(),
@@ -735,7 +799,7 @@ function identityConflict(root, agentId) {
 function cmdIam(agentId, opts) {
   const root = userRoot();
   ensureInit(root);
-  if (!agentId) { console.error('请指定 <id>：yotta-memory iam <id> [--force]'); process.exit(2); }
+  if (!agentId) { console.error('请指定 <id>：yotta-memory iam <id> [--name <显示名>] [--user <用户名>] [--relationship <关系>] [--force]'); process.exit(2); }
   const conflict = identityConflict(root, agentId);
   if (conflict && !opts.force) {
     console.error("错误: ID '" + agentId + "' " + conflict + '。每个 AI 智能体的 ID 必须唯一。请换一个唯一 ID，或确认是同一智能体后加 --force 覆盖。');
@@ -748,8 +812,11 @@ function cmdIam(agentId, opts) {
   const existed = data.agents[agentId];
   data.agents[agentId] = { host: host, created: (existed && existed.created) || today() };
   saveAgents(root, data);
-  const file = writeSelfProfile(root, agentId, { mcpMode: 'stdio' });
+  const file = writeSelfProfile(root, agentId, { mcpMode: 'stdio', name: opts.name, userName: opts.user, relationship: opts.relationship });
   console.log('已登记智能体身份: ' + agentId + '（host=' + host + '，' + (conflict ? '--force 覆盖' : '新建') + '）');
+  if (opts.name || opts.user || opts.relationship) {
+    console.log('自我档案扩展: ' + [opts.name && '显示名=' + opts.name, opts.user && '用户=' + opts.user, opts.relationship && '关系=' + opts.relationship].filter(Boolean).join(' / '));
+  }
   console.log('已写入自我档案: ' + file);
   console.log('本机免 token：以后用 whoami 确认身份；远端接入需 token new --agent ' + agentId);
 }
@@ -771,9 +838,184 @@ function cmdWhoami() {
   console.log('当前智能体身份: ' + id);
   console.log('登记状态: ' + reg);
   console.log('自我档案: ' + (profile ? profile : '未写入（请执行 yotta-memory iam ' + id + '）'));
+  if (profile) {
+    const kv = parseKvBody(parseFrontmatter(fs.readFileSync(path.join(selfPrefsDir(root, id), profile), 'utf8')).body);
+    if (kv.agent_name) console.log('显示名: ' + kv.agent_name);
+    if (kv.user_name) console.log('用户: ' + kv.user_name);
+    if (kv.relationship) console.log('关系: ' + kv.relationship);
+  }
   if (!agents[id] && !tokens[id]) console.log('提示: 请先 yotta-memory iam ' + id + ' 登记唯一身份并落自我档案，再写私密记忆。');
 }
 
+// ---- 用户画像聚合（v0.6.0，零推断：只归组呈现原文，结论由承载 AI 依据「记忆守则」内部形成）----
+function profileGroups(root, owner) {
+  const groups = [];
+  const map = {};
+  for (const t of PRIVATE_LEAF) {
+    const dir = path.join(root, PRIVATE_DIR, owner, t);
+    if (!fs.existsSync(dir)) continue;
+    for (const f of fs.readdirSync(dir)) {
+      const fp = path.join(dir, f);
+      if (!fs.statSync(fp).isFile()) continue;
+      const e = readEntry(fp, root);
+      const key = e.type + '\u0000' + (e.subject || '') + '\u0000' + e.tags.join(',');
+      if (!map[key]) {
+        map[key] = { type: e.type, subject: e.subject || '', tags: e.tags || [], items: [] };
+        groups.push(map[key]);
+      }
+      map[key].items.push({
+        file: e.file, statement: e.statement, confidence: e.confidence,
+        last_accessed: e.last_accessed, updated: e.updated,
+      });
+    }
+  }
+  return groups;
+}
+function profileCore(opts) {
+  opts = opts || {};
+  const root = userRoot();
+  const selfAgent = opts.selfAgent !== undefined ? opts.selfAgent : currentAgent();
+  const owner = opts.owner || selfAgent;
+  if (!owner) return { error: true, exitCode: 2, text: '请先声明身份（YOTTA_AGENT_ID / AGENT_ID）或传 --owner <id>，再生成画像。' };
+  if (selfAgent && owner !== selfAgent && owner !== 'user' && !opts.unsafe && !hasGrant(selfAgent, owner)) {
+    return { error: true, exitCode: 3, text: '拒绝: 不能生成其它智能体 ' + owner + ' 的画像（private/' + owner + '/ 为私密区）。如需读取请 --owner user 或 --unsafe（用户显式授权）。' };
+  }
+  const ownerDir = path.join(root, PRIVATE_DIR, owner);
+  if (!fs.existsSync(ownerDir)) return { error: false, text: '该智能体（' + owner + '）暂无画像：private/' + owner + '/ 不存在或为空。' };
+  const groups = profileGroups(root, owner);
+  if (!groups.length) return { error: false, text: '该智能体（' + owner + '）暂无画像：private/' + owner + '/ 下无 PREF / BOUND / COMMIT 条目。' };
+  const lines = [];
+  lines.push('# 用户画像（' + owner + '）');
+  lines.push('');
+  lines.push('> 生成: yotta-memory profile | 引擎零推断：以下为私密记忆原文的结构化归组，画像结论由承载 AI 依据「记忆守则」在内部形成，不当面贴标签。');
+  lines.push('> 刷新: ' + today());
+  lines.push('');
+  for (const g of groups) {
+    lines.push('## ' + g.type + ' · ' + (g.subject || '（无主题）') + (g.tags.length ? '  [tags: ' + g.tags.join(', ') + ']' : ''));
+    lines.push('');
+    for (const it of g.items) {
+      const acc = it.last_accessed ? '最近访问 ' + it.last_accessed : '未访问';
+      lines.push('- ' + it.statement + '（confidence ' + it.confidence + ' · ' + acc + '）');
+      lines.push('  - ' + it.file);
+    }
+    lines.push('');
+  }
+  const text = lines.join('\n');
+  const outFile = path.join(ownerDir, PROFILE_FILE);
+  fs.writeFileSync(outFile, text + '\n', 'utf8');
+  return { error: false, text: text + '\n\n[已写入] ' + outFile };
+}
+function cmdProfile(opts) {
+  const r = profileCore(opts);
+  console.log(r.text);
+  if (r.exitCode) process.exit(r.exitCode);
+  if (r.error) process.exit(2);
+}
+
+// ---- 开工上下文包（v0.6.0：身份 + 画像 + 近期记忆 + 边界 + 承诺，stdout 不落盘）----
+function selfProfileKv(root, id) {
+  const profile = findSelfProfile(root, id);
+  if (!profile) return {};
+  return parseKvBody(parseFrontmatter(fs.readFileSync(path.join(selfPrefsDir(root, id), profile), 'utf8')).body);
+}
+function contextCore(opts) {
+  opts = opts || {};
+  const roots = [projectRoot(), userRoot()].filter(function (r) { return fs.existsSync(r); });
+  if (!roots.length) return { error: false, exitCode: 0, text: '记忆库不存在，请先运行: yotta-memory init' };
+  const root = userRoot();
+  const limit = opts.limit || 10;
+  const selfAgent = opts.selfAgent !== undefined ? opts.selfAgent : currentAgent();
+  const owner = opts.owner || selfAgent;
+  const unsafe = !!opts.unsafe;
+  const lines = [];
+  lines.push('# 开工上下文包（yotta-memory context）');
+  lines.push('');
+  lines.push('## 1. 身份');
+  lines.push('');
+  if (!owner) {
+    lines.push('- 未声明智能体身份（无 YOTTA_AGENT_ID / --owner）。私密记忆与画像不可用；请先 whoami / iam。');
+  } else {
+    lines.push('- agent_id: ' + owner);
+    const kv = selfProfileKv(root, owner);
+    if (kv.agent_name) lines.push('- agent_name: ' + kv.agent_name);
+    if (kv.user_name) lines.push('- user_name: ' + kv.user_name);
+    if (kv.relationship) lines.push('- relationship: ' + kv.relationship);
+    lines.push('- host: ' + os.hostname());
+    lines.push('- memory_home: ' + root);
+  }
+  lines.push('');
+  lines.push('## 2. 用户画像摘要');
+  lines.push('');
+  if (owner) {
+    const pf = path.join(root, PRIVATE_DIR, owner, PROFILE_FILE);
+    if (fs.existsSync(pf)) {
+      lines.push('```markdown');
+      lines.push(fs.readFileSync(pf, 'utf8').trim());
+      lines.push('```');
+    } else {
+      const pr = profileCore({ owner: owner, unsafe: unsafe, selfAgent: selfAgent });
+      if (!pr.error && pr.text.indexOf('[已写入]') !== -1 && fs.existsSync(pf)) {
+        lines.push('（画像不存在，已自动生成一次，见下）');
+        lines.push('```markdown');
+        lines.push(fs.readFileSync(pf, 'utf8').trim());
+        lines.push('```');
+      } else {
+        lines.push('（该身份暂无画像；可运行 yotta-memory profile 生成）');
+      }
+    }
+  } else {
+    lines.push('（未声明身份，跳过画像；先 iam 登记后可生成）');
+  }
+  lines.push('');
+  lines.push('## 3. 近期记忆（按活跃度前 ' + limit + ' 条）');
+  lines.push('');
+  const recent = [];
+  for (const r of roots) {
+    for (const e of ensureIndex(r)) {
+      if (classifyRead(e, owner, '', unsafe, selfAgent) === 'denied') continue;
+      recent.push({ e: e, v: vitality(e) });
+    }
+  }
+  recent.sort(function (a, b) { return b.v - a.v; });
+  const recentShown = recent.slice(0, limit);
+  if (!recentShown.length) lines.push('（暂无记忆）');
+  for (const h of recentShown) {
+    lines.push('- [' + h.e.type + '] ' + h.e.subject + ': ' + h.e.statement);
+  }
+  lines.push('');
+  lines.push('## 4. 边界提醒（BOUND）');
+  lines.push('');
+  const bounds = [];
+  for (const r of roots) {
+    for (const e of ensureIndex(r)) {
+      if (e.type !== 'BOUND') continue;
+      if (classifyRead(e, owner, '', unsafe, selfAgent) === 'denied') continue;
+      bounds.push(e);
+    }
+  }
+  if (!bounds.length) lines.push('（无）');
+  for (const e of bounds) lines.push('- ' + (e.subject || '边界') + ': ' + e.statement);
+  lines.push('');
+  lines.push('## 5. 承诺 / 锚点（COMMIT）');
+  lines.push('');
+  const commits = [];
+  for (const r of roots) {
+    for (const e of ensureIndex(r)) {
+      if (e.type !== 'COMMIT') continue;
+      if (classifyRead(e, owner, '', unsafe, selfAgent) === 'denied') continue;
+      commits.push(e);
+    }
+  }
+  if (!commits.length) lines.push('（无）');
+  for (const e of commits) lines.push('- ' + (e.subject || '承诺') + ': ' + e.statement);
+  return { error: false, exitCode: 0, text: lines.join('\n') };
+}
+function cmdContext(opts) {
+  const r = contextCore(opts);
+  console.log(r.text);
+  if (r.exitCode) process.exit(r.exitCode);
+}
+
 // ---- config 命令 ----
 function cmdConfigSet(key, value) {
   if (key !== 'memory_home') { console.error('未知配置项: ' + key + '（可用: memory_home）'); process.exit(2); }
@@ -802,6 +1044,7 @@ function mcpTools() {
     { name: 'export', description: '导出全部记忆到引擎主机上的 JSON 文件。out 可选（默认 <记忆库>/yottamemory-export-<日期>.json）', inputSchema: { type: 'object', properties: { out: { type: 'string' } } } },
     { name: 'import', description: '从引擎主机上的 JSON 文件导入记忆。src 为文件路径（可绝对路径，或相对记忆库目录）', inputSchema: { type: 'object', properties: { src: { type: 'string' } }, required: ['src'] } },
     { name: 'agent_info', description: '查看当前智能体身份与登记状态（远端读经 token 校验的 X-Agent-Id；本机读 YOTTA_AGENT_ID）。开工先确认「我是谁」，禁止从记忆里抄别人的 ID', inputSchema: { type: 'object', properties: {} } },
+    { name: 'profile', description: '生成当前智能体的用户画像（只读聚合 private/<owner>/ 下 PREF/BOUND/COMMIT 原文，零推断，写入 private/<owner>/profile.md）。owner 默认当前智能体', inputSchema: { type: 'object', properties: { owner: { type: 'string' } } } },
   ];
 }
 function callTool(name, args, ctx) {
@@ -849,7 +1092,19 @@ function callTool(name, args, ctx) {
       if (agents[id]) reg = 'agents.json 已登记（host=' + agents[id].host + '）';
       else if (tokens[id]) reg = 'tokens.json 已登记（远端）';
       const profile = findSelfProfile(root, id);
-      return { text: '当前智能体身份: ' + id + '\n登记状态: ' + reg + '\n自我档案: ' + (profile || '未写入（本地引擎主机执行 yotta-memory iam ' + id + '）'), error: false };
+      let rel = '';
+      if (profile) {
+        const kv = selfProfileKv(root, id);
+        if (kv.agent_name) rel += '\n显示名: ' + kv.agent_name;
+        if (kv.user_name) rel += '\n用户: ' + kv.user_name;
+        if (kv.relationship) rel += '\n关系: ' + kv.relationship;
+      }
+      return { text: '当前智能体身份: ' + id + '\n登记状态: ' + reg + '\n自我档案: ' + (profile || '未写入（本地引擎主机执行 yotta-memory iam ' + id + '）') + rel, error: false };
+    }
+    if (name === 'profile') {
+      const ownerArg = args.owner ? String(args.owner) : '';
+      const r = profileCore({ owner: ownerArg || agent, selfAgent: agent });
+      return { text: r.text, error: r.error };
     }
     return { text: '未知工具: ' + name, error: true };
   } catch (e) {
@@ -960,8 +1215,11 @@ function cmdServeStdio() {
   process.stdin.on('end', function () { process.exit(0); });
 }
 
-// ---- lan 命令（Windows 计划任务管理开机自启 serve）----
+// ---- lan 命令（Windows 开机自启管理 serve）----
+// 双机制：① schtasks 计划任务（默认，需相应权限）；② 非管理员（Access denied）自动降级为
+// 用户级 Startup 静默自启（VBS sh.Run <autostart.cmd>, 0, False + autostart.cmd；node 路径 process.execPath 自动探测，0.5.4）
 const LAN_TASK_NAME = 'YottaMemoryServe';
+const LAN_GEN_MARKER = 'Generated by yotta-memory lan enable';
 function lanTaskRunCmd(opts) {
   const host = opts.host || '0.0.0.0';
   const port = opts.port || 8787;
@@ -969,59 +1227,158 @@ 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 lanStartupDir() {
+  // 测试/高级用途可用 YOTTA_LAN_STARTUP_DIR 覆盖（默认用户级 Startup 目录，免管理员）
+  if (process.env.YOTTA_LAN_STARTUP_DIR) return process.env.YOTTA_LAN_STARTUP_DIR;
+  const base = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+  return path.join(base, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup');
+}
+function lanAutostartDir() {
+  // 产品自有目录 ~/.yottamemory/autostart/（引擎数据目录内，非系统配置）；测试可用 YOTTA_LAN_AUTOSTART_DIR 覆盖
+  if (process.env.YOTTA_LAN_AUTOSTART_DIR) return process.env.YOTTA_LAN_AUTOSTART_DIR;
+  return path.join(os.homedir(), '.yottamemory', 'autostart');
+}
+function lanVbsPath() { return path.join(lanStartupDir(), 'yotta-memory-serve.vbs'); }
+function lanAutostartCmdPath() { return path.join(lanAutostartDir(), 'yotta-memory-autostart.cmd'); }
+function lanLogPath(opts) {
+  if (process.env.YOTTA_LAN_LOG_FILE) return process.env.YOTTA_LAN_LOG_FILE;
+  return path.join(os.homedir(), '.yottamemory', 'serve-' + (opts.port || 8787) + '.log');
+}
+function lanAutostartCmdContent(opts) {
+  const host = opts.host || '0.0.0.0';
+  const port = opts.port || 8787;
+  const q = (p) => '"' + String(p).replace(/"/g, '""') + '"';
+  // 生成文件用纯 ASCII（避免 cmd/VBS 按系统代码页读取中文注释乱码）
+  return '@echo off\r\n'
+    + 'chcp 65001 >nul\r\n'
+    + 'rem ' + LAN_GEN_MARKER + '; remove with: yotta-memory lan disable\r\n'
+    + q(process.execPath) + ' ' + q(__filename) + ' serve --host ' + host + ' --port ' + port + ' >> ' + q(lanLogPath(opts)) + ' 2>&1\r\n';
+}
+function lanVbsContent() {
+  return "' " + LAN_GEN_MARKER + '; remove with: yotta-memory lan disable\r\n'
+    + 'Set sh = CreateObject("WScript.Shell")\r\n'
+    + 'sh.Run "' + String(lanAutostartCmdPath()).replace(/"/g, '""') + '", 0, False\r\n';
+}
+function lanInstallStartup(opts) {
+  fs.mkdirSync(lanAutostartDir(), { recursive: true });
+  fs.writeFileSync(lanAutostartCmdPath(), lanAutostartCmdContent(opts), 'utf8');
+  fs.mkdirSync(lanStartupDir(), { recursive: true });
+  // VBS 用 UTF-16LE+BOM：wscript 按 Unicode 读取，中文路径不乱码（纯 ANSI 读取会按系统代码页误读）
+  fs.writeFileSync(lanVbsPath(), '\ufeff' + lanVbsContent(), 'utf16le');
+}
+function lanRemoveStartupFiles() {
+  // 只删除带产品标记的生成文件，绝不误删用户自己的 Startup 文件
+  const removed = [];
+  for (const f of [lanVbsPath(), lanAutostartCmdPath()]) {
+    try {
+      if (lanFileHasMarker(f)) { fs.unlinkSync(f); removed.push(f); }
+    } catch (e) { /* 单个文件失败不阻断其它清理 */ }
+  }
+  return removed;
+}
+function lanFileHasMarker(f) {
+  try {
+    if (!fs.existsSync(f)) return false;
+    const buf = fs.readFileSync(f);
+    const m8 = Buffer.from(LAN_GEN_MARKER, 'utf8');
+    const m16 = Buffer.from(LAN_GEN_MARKER, 'utf16le');
+    return buf.indexOf(m8) !== -1 || buf.indexOf(m16) !== -1;
+  } catch (e) { return false; }
+}
+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) {
   if (process.platform !== 'win32') {
-    console.error('lan 命令当前仅支持 Windows（计划任务）；本机平台: ' + process.platform);
+    console.error('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + process.platform);
     process.exit(2);
   }
   const trigger = opts.onstart ? 'onstart' : 'onlogon';
   const tr = lanTaskRunCmd(opts);
   try {
     child_process.execFileSync('schtasks', ['/create', '/tn', LAN_TASK_NAME, '/tr', tr, '/sc', trigger, '/f'], { stdio: 'inherit' });
+    console.log('已注册开机自启: 计划任务 ' + LAN_TASK_NAME + '（触发器 ' + trigger + '）');
+    console.log('运行命令: ' + tr);
+    console.log('备注: 服务不会立刻启动，需重启/重新登录后自动启动；如需现在运行请执行 yotta-memory serve');
+    return;
   } catch (e) {
-    console.error('注册计划任务失败（ONSTART 需要管理员权限；ONLOGON 一般不需要；如仍失败请用管理员终端执行）: ' + String((e && e.stderr) || (e && e.message) || e).split(/\r?\n/)[0]);
-    process.exit(1);
+    const firstLine = String((e && e.stderr) || (e && e.message) || e).split(/\r?\n/)[0];
+    if (isSchtasksAccessDenied(e)) console.error('计划任务注册被拒绝（当前用户非管理员，Access denied）: ' + firstLine);
+    else console.error('计划任务注册失败（当前环境不可用计划任务）: ' + firstLine);
+    console.log('自动改用用户级 Startup 静默自启（免管理员）...');
+    try {
+      lanInstallStartup(opts);
+    } catch (e2) {
+      console.error('写 Startup 自启失败: ' + String((e2 && e2.message) || e2).split(/\r?\n/)[0]);
+      console.error('请用管理员终端执行 yotta-memory lan enable，或将以下命令手动加入启动项: ' + tr);
+      process.exit(1);
+    }
+    console.log('已启用用户级 Startup 静默自启（无需管理员）');
+    console.log('启动脚本: ' + lanVbsPath());
+    console.log('启动命令: ' + lanAutostartCmdPath());
+    console.log('日志: ' + lanLogPath(opts));
+    console.log('备注: 服务不会立刻启动，需重新登录后自动启动；如需现在运行请执行 yotta-memory serve');
+    console.log('提示: 如需改回计划任务，请用管理员终端重新执行 yotta-memory lan enable');
+    return;
   }
-  console.log('已注册开机自启: 计划任务 ' + LAN_TASK_NAME + '（触发器 ' + trigger + '）');
-  console.log('运行命令: ' + tr);
-  console.log('备注: 服务不会立刻启动，需重启/重新登录后自动启动；如需现在运行请执行 yotta-memory serve');
 }
 function cmdLanDisable() {
   if (process.platform !== 'win32') {
-    console.error('lan 命令当前仅支持 Windows（计划任务）；本机平台: ' + process.platform);
+    console.error('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + process.platform);
     process.exit(2);
   }
+  let sawError = false;
+  let removedAny = false;
   try {
-    child_process.execFileSync('schtasks', ['/delete', '/tn', LAN_TASK_NAME, '/f'], { stdio: ['ignore', 'pipe', 'ignore'] });
+    child_process.execFileSync('schtasks', ['/delete', '/tn', LAN_TASK_NAME, '/f'], { stdio: ['ignore', 'pipe', 'pipe'] });
+    console.log('已移除开机自启计划任务 ' + LAN_TASK_NAME);
+    removedAny = true;
   } catch (e) {
     const msg = String((e && e.stderr) || (e && e.message) || e);
-    if (msg.indexOf('cannot find the path') !== -1 || msg.indexOf('没有找到') !== -1) {
-      console.log('未启用: 计划任务 ' + LAN_TASK_NAME + ' 不存在，无需移除');
-      return;
+    if (!/cannot find the (path|file)|没有找到|找不到|不存在/i.test(msg)) {
+      console.error('移除计划任务失败: ' + msg.split(/\r?\n/)[0]);
+      sawError = true;
     }
-    console.error('移除计划任务失败: ' + msg.split(/\r?\n/)[0]);
-    process.exit(1);
   }
-  console.log('已移除开机自启计划任务 ' + LAN_TASK_NAME);
+  for (const f of lanRemoveStartupFiles()) {
+    console.log('已移除 Startup 自启文件: ' + f);
+    removedAny = true;
+  }
+  if (!removedAny && !sawError) console.log('未启用: 未发现任何自启配置（计划任务与 Startup 文件均不存在）');
+  if (sawError) process.exit(1);
 }
 function cmdLanStatus() {
   if (process.platform !== 'win32') {
-    console.log('lan 命令当前仅支持 Windows（计划任务）；本机平台: ' + process.platform);
+    console.log('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + process.platform);
     return;
   }
+  let taskFound = false;
   try {
     const out = child_process.execFileSync('schtasks', ['/query', '/tn', LAN_TASK_NAME, '/fo', 'LIST', '/v'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
-    console.log('已启用: 计划任务 ' + LAN_TASK_NAME + ' 存在');
+    taskFound = true;
+    console.log('计划任务 ' + LAN_TASK_NAME + ': 已启用');
     const re = /^(状态|Status)\s*:\s*(.+)$/;
     for (const line of String(out).split(/\r?\n/)) {
       const m = re.exec(line.trim());
-      if (m) console.log(m[1] + ': ' + m[2]);
+      if (m) console.log('  ' + m[1] + ': ' + m[2]);
     }
   } catch (e) {
-    console.log('未启用: 计划任务 ' + LAN_TASK_NAME + ' 不存在（可用 yotta-memory lan enable 注册）');
+    console.log('计划任务 ' + LAN_TASK_NAME + ': 未启用');
   }
+  const vbsOk = lanFileHasMarker(lanVbsPath());
+  const cmdOk = lanFileHasMarker(lanAutostartCmdPath());
+  if (vbsOk && cmdOk) {
+    console.log('Startup 静默自启（免管理员）: 已启用');
+    console.log('  启动脚本: ' + lanVbsPath());
+    console.log('  启动命令: ' + lanAutostartCmdPath());
+  } else if (vbsOk || cmdOk) {
+    console.log('Startup 静默自启: 部分残留（建议执行 yotta-memory lan disable 后重新 lan enable）');
+  } else {
+    console.log('Startup 静默自启（免管理员）: 未启用');
+  }
+  if (!taskFound && !vbsOk && !cmdOk) console.log('未启用任何开机自启（可用 yotta-memory lan enable 注册）');
 }
-
 // ---- usage / main ----
 function usage() {
   console.log([
@@ -1031,7 +1388,9 @@ function usage() {
     '  yotta-memory init [--project] [--dir <目录>]  初始化记忆库（默认用户级；--dir 显式指定位置）',
     '  yotta-memory config set memory_home <目录>  持久记住记忆库位置',
     '  yotta-memory config get                   查看当前配置与生效位置',
-    '  yotta-memory remember <type> <subject> <statement> [--owner <id>]   写入记忆',
+    '  yotta-memory remember <type> <subject> <statement> [--owner <id>] [--verify] [--no-hint]   写入记忆（--verify 写后回读校验；--no-hint 关闭类型启发式提示）',
+    '  yotta-memory profile [--owner <id>]    生成用户画像（聚合 private/<owner>/ 原文，零推断，写 profile.md）',
+    '  yotta-memory context [--limit N] [--owner <id>]  生成开工上下文包（身份+画像+近期记忆+边界+承诺，stdout 不落盘）',
     '  yotta-memory recall [关键词] [--type T] [--limit N] [--agent <id>] [--owner <id>] [--all] [--unsafe]  检索（索引+TF，读取分区；--agent 仅表示“以该身份检索/模拟”，跨智能体私密读取需 --unsafe / 授权）',
     '  yotta-memory forget <文件或文件名>         删除一条记忆',
     '  yotta-memory archive [--days 180] [--threshold 0.4]  归档（盖棺分+年龄）',
@@ -1039,12 +1398,12 @@ function usage() {
     '  yotta-memory export [--out 文件.json]      导出全部记忆',
     '  yotta-memory import <文件.json>            导入记忆',
     '  yotta-memory whoami                       查看当前智能体身份与登记状态（读 YOTTA_AGENT_ID / X-Agent-Id，不猜不默认）',
-    '  yotta-memory iam <id> [--force]           登记本智能体唯一身份并自动落自我档案（agents.json；ID 必须唯一）',
+    '  yotta-memory iam <id> [--name <显示名>] [--user <用户名>] [--relationship <关系>] [--force]  登记本智能体唯一身份并自动落自我档案（agents.json；ID 必须唯一）',
     '  yotta-memory token new --agent <id> [--force]  生成/重置某智能体访问 token（同 ID 已被其它来源占用需 --force 覆盖）',
     '  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）',
+    '  yotta-memory lan enable [--onstart] | disable | status  开机自启管理（Windows 计划任务，默认 ONLOGON；非管理员自动降级用户级 Startup 静默自启）',
     '  yotta-memory --version                    版本',
     '',
     '类型: FACT(公共共享) / PREF(偏好) / BOUND(边界) / COMMIT(承诺)',
@@ -1059,7 +1418,7 @@ function main() {
   if (!args.length) { usage(); return; }
   const opts = {};
   const positional = [];
-  const valueOpts = new Set(['--type', '--limit', '--days', '--out', '--owner', '--agent', '--threshold', '--scope', '--host', '--port', '--dir']);
+  const valueOpts = new Set(['--type', '--limit', '--days', '--out', '--owner', '--agent', '--threshold', '--scope', '--host', '--port', '--dir', '--name', '--user', '--relationship']);
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
     if (a === '--version' || a === '-v') { console.log(VERSION); return; }
@@ -1071,6 +1430,8 @@ function main() {
     else if (a === '--stdio') opts.stdio = true;
     else if (a === '--onstart') opts.onstart = true;
     else if (a === '--force') opts.force = true;
+    else if (a === '--verify') opts.verify = true;
+    else if (a === '--no-hint') opts.noHint = true;
     else if (valueOpts.has(a)) {
       const v = args[++i];
       if (a === '--type') opts.type = v;
@@ -1084,6 +1445,9 @@ function main() {
       else if (a === '--host') opts.host = v;
       else if (a === '--port') opts.port = parseInt(v, 10) || 8787;
       else if (a === '--dir') opts.dir = v;
+      else if (a === '--name') opts.name = v;
+      else if (a === '--user') opts.user = v;
+      else if (a === '--relationship') opts.relationship = v;
     } else if (a.startsWith('--')) {
       console.error('未知选项: ' + a);
       process.exit(2);
@@ -1109,6 +1473,8 @@ function main() {
     case 'forget': cmdForget(rest[0]); break;
     case 'archive': cmdArchive(opts); break;
     case 'reindex': cmdReindex(); break;
+    case 'profile': cmdProfile(opts); break;
+    case 'context': cmdContext(opts); break;
     case 'export': cmdExport(opts.out); break;
     case 'import': cmdImport(rest[0]); break;
     case 'token': {
@@ -1143,6 +1509,8 @@ module.exports = {
   projectRoot: projectRoot,
   rememberCore: rememberCore,
   recallCore: recallCore,
+  profileCore: profileCore,
+  contextCore: contextCore,
   forgetCore: forgetCore,
   archiveCore: archiveCore,
   mcpTools: mcpTools,
@@ -1155,4 +1523,16 @@ module.exports = {
   collectEntryFiles: collectEntryFiles,
   migrateLayout: migrateLayout,
   typeSubdir: typeSubdir,
+  lanTaskRunCmd: lanTaskRunCmd,
+  lanStartupDir: lanStartupDir,
+  lanAutostartDir: lanAutostartDir,
+  lanVbsPath: lanVbsPath,
+  lanAutostartCmdPath: lanAutostartCmdPath,
+  lanLogPath: lanLogPath,
+  lanAutostartCmdContent: lanAutostartCmdContent,
+  lanVbsContent: lanVbsContent,
+  lanInstallStartup: lanInstallStartup,
+  lanRemoveStartupFiles: lanRemoveStartupFiles,
+  lanFileHasMarker: lanFileHasMarker,
+  isSchtasksAccessDenied: isSchtasksAccessDenied,
 };

package/package.json

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

package/references/protocol.md

@@ -1,4 +1,4 @@
-# yotta-memory 协议规范 v0.5.3
+# yotta-memory 协议规范 v0.6.0
 
 > 本文件定义 yotta-memory 记忆标准：存储位置、目录结构、文件格式、类型体系与 CLI 命令参考。
 > 目标：任何支持 Agent Skills 开放标准的智能体，装完即可读写同一份记忆。
@@ -22,7 +22,8 @@
 │   └── <owner>/            # 每个智能体一个子目录
 │       ├── prefs/          # PREF 偏好（该 owner 私密）
 │       ├── bounds/         # BOUND 边界（该 owner 私密）
-│       └── commits/        # COMMIT 承诺（该 owner 私密）
+│       ├── commits/        # COMMIT 承诺（该 owner 私密）
+│       └── profile.md      # 用户画像（profile 命令生成，零推断，可再生成）
 ├── .archive/               # 归档区（archive 命令移入）
 ├── index.json              # 反向索引 + TF 打分（见下方说明）
 ├── agents.json             # 智能体身份登记表（iam 写入，唯一性强制）
@@ -37,7 +38,7 @@
 
 - **agent ID 必须全局唯一**：`iam <id>` 写入 `agents.json`（记忆库根目录），唯一性强制——ID 已被其它主机 / 来源（含远端 token 登记）占用则拒绝，确认是同一智能体才 `--force`。
 - **当次身份声明**：`whoami` / MCP `agent_info` 读「当次声明身份」——本机 `YOTTA_AGENT_ID`（stdio 由 MCP 配置 `env` 注入，CLI 用 `--agent`/环境变量）；远端 `X-Agent-Id` 请求头（经 token 绑定校验）。不猜不默认。
-- **自我档案**：`iam` 自动写一条 PREF `subject=自我接入档案`（owner=自己），statement 为 `; ` 分隔的 key:value——`agent_id / host / memory_home / mcp_mode(stdio|http) / engine_url(仅远端) / token(仅远端；本机不存 token)`。
+- **自我档案**：`iam` 自动写一条 PREF `subject=自我接入档案`（owner=自己），statement 为 `; ` 分隔的 key:value——`agent_id / host / memory_home / mcp_mode(stdio|http) / engine_url(仅远端) / token(仅远端；本机不存 token)`，可含 `agent_name / user_name / relationship`（`iam --name/--user/--relationship` 写入）。
 - **私密记忆必须有 owner**：PREF / BOUND / COMMIT 写入时未声明身份（owner 空）直接拒绝（公共 FACT 不受影响），从机制上防止「抄别人的 ID」。
 
 ## 3. 文件格式
@@ -111,14 +112,39 @@ immutable: false
 | 命令 | 行为 |
 |---|---|
 | `init [--project]` | 创建目录结构；默认用户级，`--project` 建项目级 |
-| `remember <type> <subject> <statement> [--owner <id>]` | 写入；同 subject+statement 已存在则只更新 `updated`；`--owner` 标注归属 |
+| `remember <type> <subject> <statement> [--owner <id>] [--verify] [--no-hint]` | 写入；同 subject+statement 已存在则只更新 `updated`；`--owner` 标注归属；`--verify` 写后回读校验；`--no-hint` 关闭类型启发式提示 |
 | `recall [关键词] [--type T] [--limit N] [--agent <id>] [--owner <id>] [--all] [--unsafe]` | 索引+TF 打分匹配；读取分区过滤；越界（读其它智能体私密）默认拒绝，需 grant / identity=user / `--unsafe` 授权；项目级优先；默认 50 条 |
 | `forget <文件>` | 删除（按路径或文件名）|
 | `archive [--days 180] [--threshold 0.4]` | 按盖棺分+年龄移入 `.archive/`（`vitality < threshold` 且超过 N 天）|
 | `reindex` | 全量扫描重建 `index.json`（手动改 .md 后校正）|
 | `export [--out f.json]` | 导出全部记忆为 JSON |
-| `import <f.json>` | 从 JSON 导入（幂等）|
+| `import <f.json>` | 从 JSON 导入（幂等）|
+| `profile [--owner <id>]` | 用户画像聚合（零推断，写 `private/<owner>/profile.md`；跨 owner 默认拒绝）|
+| `context [--limit N] [--owner <id>]` | 开工上下文包（stdout：身份 + 画像 + 近期记忆 + 边界 + 承诺）|
+| `iam <id> [--name] [--user] [--relationship] [--force]` | 登记身份 + 自我档案（可选扩展显示名 / 用户 / 关系）|
 
+
+### profile（用户画像聚合，v0.6.0）
+
+- `profile [--owner <id>]`：扫描 `private/<owner>/{prefs,bounds,commits}`，按 type + subject + tags 归组，输出各条 statement 原文 + confidence + 最近访问，写 `private/<owner>/profile.md`。
+- 零推断：引擎只做结构化归组与原文呈现，不做语义推断；画像结论由承载 AI 依据 SKILL「记忆守则」内部形成。
+- 权限：profile.md 属私密区（按 owner）；跨 owner 生成默认拒绝（exit 3），需 `--owner user` / `--unsafe` / grant 授权。
+- profile.md 为生成物，可随时重新生成；不进入 index.json。
+
+### context（开工上下文包，v0.6.0）
+
+- `context [--limit N] [--owner <id>]`：stdout 输出开工上下文包（不落盘），五段：
+  1. 身份：agent_id / agent_name / user_name / relationship / host / memory_home（读自我档案）
+  2. 用户画像摘要：profile.md（不存在则自动生成一次或降级跳过）
+  3. 近期记忆：按 vitality（活跃度）排序前 N 条（默认 10），读取分区过滤
+  4. 边界提醒：BOUND 全列（可读范围内）
+  5. 承诺 / 锚点：COMMIT 全列（可读范围内）
+
+### remember / iam 扩展（v0.6.0）
+
+- `remember ... --verify`：写后自动回读校验（recall 命中刚写入条目），输出「已写回读 OK」。
+- `remember ... --no-hint`：关闭类型启发式提示。默认开启：statement 含主观/关系词（用户 / 偏好 / 喜欢 / 关系 / 称呼 等）且 type=FACT 时 stdout 提示「疑似用户偏好 / 关系，建议 PREF」，仅提示不拦截。
+- `iam <id> [--name <显示名>] [--user <用户名>] [--relationship <关系>] [--force]`：自我档案 PREF 扩展 `agent_name / user_name / relationship`；不带新参数行为与 0.4.2 一致。
 ### 去重与更新
 
 - remember 时若同 `type + subject + statement` 已存在，仅刷新 `updated`，不产生重复文件。