@yottameta/yotta-memory 0.5.4 → 0.6.1

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,6 +40,7 @@
 | **轻量零依赖** | 无 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` 注册开机自启（Windows：优先计划任务；非管理员自动降级用户级 Startup 静默自启）；MCP 工具集与 CLI 一致（8 个工具），管理动作不远程暴露 |
@@ -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**：一键生成开工上下文包——多智能体接入铁律 + 身份 + 用户画像摘要 + 近期记忆（按 importance 排序）+ 边界提醒 + 承诺 / 锚点；支持 `--budget` 字符预算（token 恒定，不随记忆膨胀）。
+- **记忆守则**：SKILL.md 内置规则层（类型红线 / 主动捕获触发信号 / 了解用户三阶段四手法 / 心理学底座与对齐 / 底线与边界 / 宿主隔离 / 反模式），让 AI「越用越懂」有章法。
+
 ### 检索：索引 + 中文分词打分
 
 - `remember` 时自动构建 `index.json` 索引；recall 用 TF 打分排序，中文按 bigram 分词，不用额外模型。
@@ -100,7 +109,7 @@
 
 ### 智能体接入
 
-把技能装进智能体后，SKILL.md 会自动教会智能体一套工作流：**开工 `recall` 恢复上下文 → 重要信息 `remember` 落盘 → 收工归档**。也可在对话中直接说「记住 XXX」「上次说到哪了」「记一笔」触发。
+把技能装进智能体后，SKILL.md 会自动教会智能体一套工作流：**开工 `context` 主注入（身份 + 画像 + 近期记忆 + 边界 + 承诺）→ 重要信息 `remember` 落盘 → 收工归档**，并遵循「记忆守则」（类型红线 / 触发信号 / 底线 / 宿主隔离）。也可在对话中直接说「记住 XXX」「上次说到哪了」「记一笔」触发。
 
 ### 便携记忆盘（记忆库即引擎）
 
@@ -174,15 +183,17 @@ 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>] [--source <来源>] [--weight <0..>] [--verify] [--no-hint]` | 写入记忆（同 subject+statement 自动更新；--owner 标注归属；--source 记录来源；--weight 重要性权重、去重取 max；--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>] [--budget N]` | 生成开工上下文包（身份 + 多智能体铁律 + 画像 + 近期记忆 + 边界 + 承诺；--budget 近期记忆字符预算，token 恒定）|
 | `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 开机即启需管理员；非管理员自动降级用户级 Startup 静默自启）|
@@ -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
 ```
 

package/SKILL.md

@@ -1,14 +1,14 @@
 ---
 name: yotta-memory
-description: "元忆 —— 有权限边界的文件式智能体记忆。文件式、零依赖、可 diff/回滚：让任何 AI 智能体活过会话，开工 recall 恢复上下文、重要信息 remember 落盘、收工归档。类型体系 FACT（公共共享）/ PREF / BOUND / COMMIT（私密隔离）。触发：记住、别忘了、记一笔、记忆、remember、recall、跨会话、上次说到、续测、交接、归档、记忆盘、共享记忆、局域网记忆"
-version: 0.5.4
+description: "元忆 —— 有权限边界的文件式智能体记忆。文件式、零依赖、可 diff/回滚：让任何 AI 智能体活过会话，开工 recall 恢复上下文、重要信息 remember 落盘、收工归档。类型体系 FACT（公共共享）/ PREF / BOUND / COMMIT（私密隔离）。触发：记住、别忘了、记一笔、记忆、remember、recall、跨会话、上次说到、续测、交接、归档、记忆盘、共享记忆、局域网记忆、画像、开工上下文、记忆守则、profile、context、越用越懂"
+version: 0.6.1
 license: MIT
 ---
 
 # yotta-memory（元忆）— 有权限边界的文件式智能体记忆
 
 > 一句话：元忆 —— 有权限边界的文件式智能体记忆（不注入、可 diff、能回滚；FACT 共享、PREF / BOUND / COMMIT 私密隔离）。
-> 版本：0.5.4 | 最后更新：2026-08-25
+> 版本：0.6.1 | 最后更新：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,82 @@ 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 +122,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] [--budget 1800]`（远端经 MCP 用 `recall` 补细节）：一键拿到「身份 + 多智能体铁律 + 用户画像摘要 + 近期记忆 + 边界提醒 + 承诺 / 锚点」；`--budget` 控制近期记忆字符预算（token 恒定，不随记忆膨胀）。
+- 无画像时 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,15 +145,17 @@ 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>] [--source <来源>] [--weight <0..>] [--verify] [--no-hint]` | 写入（同 subject+statement 自动更新；--owner 标注归属；--source 记录来源；--weight 重要性权重默认 1.0、去重取 max；--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>] [--budget N]` | 生成开工上下文包（身份 + 多智能体铁律 + 画像 + 近期记忆 + 边界 + 承诺；--budget 近期记忆字符预算，0=不限）|
 | `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 开机即启需管理员；非管理员自动降级用户级 Startup 静默自启）|
@@ -89,14 +168,15 @@ license: MIT
 <root>/
 ├── facts/                    # FACT 事实（公共可共享）
 ├── private/<owner>/<type>/   # PREF / BOUND / COMMIT，按智能体隔离
+├── private/<owner>/profile.md # 用户画像（profile 命令生成，可再生成，零推断）
 ├── .archive/                 # 归档区
 ├── index.json                # 检索索引（tokens = 分词词频，非访问令牌）
 └── agents.json               # 智能体身份登记表（唯一性）
 ```
 
-记忆文件 `<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>/`。
+记忆文件 `<YYYY-MM-DD>-<NNNN>.md`，frontmatter 含 `type / subject / statement / confidence / created / updated / tags / immutable / scope / owner / source / weight / access_count / last_accessed`（`source` 记录来源、`weight` 重要性权重默认 1.0）；正文为记忆内容。旧版根下平铺的 `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` 写入）。
 
 ## 便携记忆盘模式（局域网多机共享）
 
@@ -173,7 +253,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 --budget 1800 # 生成开工上下文包（身份+铁律+画像+近期记忆+边界+承诺，预算控 token）
+yotta-memory iam <id> --name 元忆 --user 老张 --relationship 伙伴   # 自我档案扩展显示名/用户/关系
+```
+
+- `profile` 引擎零推断：只按类型 / 主题 / 标签归组呈现原文，画像结论由 AI 内部形成，不当面贴标签。
+- `context` 是每次会话开工的主注入，替代裸 `recall`；无画像时自动生成一次或降级，不报错；`--budget` 控制近期记忆字符预算（token 恒定）。
+- `remember --verify` 写后回读校验；`remember --no-hint` 关闭「疑似偏好，建议 PREF」的提示。
+
 ### 记忆库位置：本机智能体如何找到记忆
 
 位置解析优先级：`YOTTA_MEMORY_HOME`（环境变量，临时覆盖）> `config.json#memory_home`（`config set memory_home` 持久记住）> 默认 `~/.yottamemory`。
@@ -231,15 +244,17 @@ yotta-memory remember FACT 主题 内容    # 智能体落盘
 | 命令 | 作用 |
 |---|---|
 | `yotta-memory init [--project] [--dir <目录>]` | 初始化记忆库 |
-| `yotta-memory remember <类型> <主题> <内容> [--owner <id>]` | 写入记忆 |
+| `yotta-memory remember <类型> <主题> <内容> [--owner <id>] [--source <来源>] [--weight <0..>] [--verify] [--no-hint]` | 写入记忆（--source 来源；--weight 重要性权重；--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>] [--budget N]` | 开工上下文包（身份+铁律+画像+近期记忆+边界+承诺；--budget 近期记忆字符预算）|
 | `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` | 开机自启管理（Windows：计划任务；非管理员自动降级用户级 Startup 静默自启）|
@@ -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

@@ -5,6 +5,8 @@
 // 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「记忆守则」
+// v0.6.1 新增：灵魂盘机制精髓补齐——context --budget（token 预算，近记忆按剩余预算放行）/ context 内嵌「多智能体接入铁律」段 / remember --source/--weight（来源 + 重要性权重，去重 weight 取 max）/ 近期记忆排序融合 importance（confidence×recency+updated+weight+immutable）
 'use strict';
 
 const fs = require('fs');
@@ -14,7 +16,7 @@ const crypto = require('crypto');
 const http = require('http');
 const child_process = require('child_process');
 
-const VERSION = '0.5.4';
+const VERSION = '0.6.1';
 const TYPES = ['FACT', 'PREF', 'BOUND', 'COMMIT'];
 const TYPE_DIRS = { FACT: 'facts', PREF: 'prefs', BOUND: 'bounds', COMMIT: 'commits' };
 const PUBLIC_DIR = 'facts';
@@ -23,11 +25,14 @@ const PRIVATE_LEAF = ['prefs', 'bounds', 'commits'];
 const ARCHIVE_DIR = '.archive';
 const INDEX_FILE = 'index.json';
 const PRIVATE_TYPES = ['PREF', 'BOUND', 'COMMIT'];
-const FIELD_ORDER = ['type', 'subject', 'statement', 'confidence', 'created', 'updated', 'tags', 'immutable', 'scope', 'owner', 'access_count', 'last_accessed'];
+const FIELD_ORDER = ['type', 'subject', 'statement', 'confidence', 'created', 'updated', 'tags', 'immutable', 'scope', 'owner', 'source', 'weight', 'access_count', 'last_accessed'];
 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() {
@@ -270,6 +275,8 @@ function readEntry(fp, root) {
     access_count: parseInt(meta.access_count || '0', 10) || 0,
     last_accessed: meta.last_accessed || '',
     immutable: meta.immutable === 'true',
+    source: meta.source || '',
+    weight: (parseFloat(meta.weight) > 0 ? parseFloat(meta.weight) : 1.0),
     tokens: buildTokens(subject, statement, tags),
     meta: meta,
   };
@@ -318,6 +325,21 @@ function vitality(meta) {
   if (last) { const d = daysBetween(last, today()); recency = Math.max(0, 1 - Math.floor(d / 30) * 0.2); }
   return 0.4 * conf + 0.3 * accScore + 0.3 * recency;
 }
+// 灵魂盘 importance 融合：confidence × (0.5 + recency) + updated 加分 + weight 乘子 + immutable 加分
+function importanceScore(meta) {
+  const conf = parseFloat(meta.confidence || 1.0);
+  let ageDays = 999;
+  if (meta.created) {
+    const d = daysBetween(meta.created, today());
+    if (!isNaN(d)) ageDays = d;
+  }
+  const recency = 1.0 / (1.0 + Math.max(ageDays, 0) / 180.0);
+  let score = conf * (0.5 + recency);
+  if (meta.updated && meta.created && meta.updated !== meta.created) score += 0.5;
+  const w = parseFloat(meta.weight || 1.0); if (w > 0) score *= w;
+  if (meta.immutable === 'true') score += 2.0;
+  return score;
+}
 function loadGrants(root) {
   const fp = path.join(root, 'grants.json');
   try { return JSON.parse(fs.readFileSync(fp, 'utf8')) || {}; } catch (e) { return {}; }
@@ -382,9 +404,22 @@ function rememberCore(type, subject, statement, opts) {
         const patch = { updated: today() };
         if (owner && !meta.owner) patch.owner = owner;
         if (scope && !meta.scope) patch.scope = scope;
+        if (opts.source && !meta.source) patch.source = opts.source;
+        const w = parseFloat(opts.weight); if (w > 0) patch.weight = Math.max(parseFloat(meta.weight || '1.0') || 1.0, w);
         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 };
       }
     }
   }
@@ -394,11 +429,25 @@ function rememberCore(type, subject, statement, opts) {
     type: t, subject: subj, statement: stmt,
     confidence: 1.0, created: today(), updated: today(),
     tags: [], immutable: false,
-    scope: scope, owner: owner, access_count: 0, last_accessed: '',
+    scope: scope, owner: owner,
+    source: opts.source || '',
+    weight: (parseFloat(opts.weight) > 0 ? parseFloat(opts.weight) : 1.0),
+    access_count: 0, last_accessed: '',
   };
   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); });
@@ -536,7 +585,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);
 }
@@ -608,6 +659,8 @@ function importCore(root, src) {
       updated: meta.updated || today(),
       tags: parseTags(meta.tags),
       immutable: meta.immutable === true || meta.immutable === 'true',
+      source: meta.source || '',
+      weight: (parseFloat(meta.weight) > 0 ? parseFloat(meta.weight) : 1.0),
       scope: meta.scope || defaultScope(t),
       owner: meta.owner || '',
       access_count: parseInt(meta.access_count || '0', 10) || 0,
@@ -698,6 +751,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);
@@ -706,14 +767,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(),
@@ -736,7 +824,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 覆盖。');
@@ -749,8 +837,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);
 }
@@ -772,9 +863,194 @@ 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 budget = opts.budget ? parseInt(opts.budget, 10) : 0;
+  const lines = [];
+  function usedChars() { return lines.reduce(function (s, x) { return s + String(x).length + 1; }, 0); }
+  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('## 1.5 多智能体接入铁律');
+  lines.push('');
+  lines.push('- 可读：A. 公共 FACT（facts/）B. 本智能体私密（private/<owner>/）C. 其它智能体私密 = 禁区（grant / identity=user / --unsafe 显式授权除外）。');
+  lines.push('- 可写：FACT→公共；PREF / BOUND / COMMIT→仅本智能体私密区；禁止写其它智能体私密区。');
+  lines.push('- 违规红线：禁止搜索 / 读取 / 总结其它智能体私密；禁止把用户私密关系 / 心理健康 / 生活隐私写入公共区。');
+  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, s: importanceScore(e) });
+    }
+  }
+  recent.sort(function (a, b) { return b.s - a.s; });
+  const recentShown = recent.slice(0, limit);
+  if (!recentShown.length) lines.push('（暂无记忆）');
+  for (const h of recentShown) {
+    const line = '- [' + h.e.type + '] ' + h.e.subject + ': ' + h.e.statement;
+    if (budget > 0 && usedChars() + line.length > budget) break;
+    lines.push(line);
+  }
+  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); }
@@ -803,6 +1079,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) {
@@ -850,7 +1127,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) {
@@ -1134,7 +1423,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>] [--source <来源>] [--weight <0..>] [--verify] [--no-hint]   写入记忆（--source 记录来源；--weight 重要性权重默认 1.0 去重取 max；--verify 写后回读校验；--no-hint 关闭类型启发式提示）',
+    '  yotta-memory profile [--owner <id>]    生成用户画像（聚合 private/<owner>/ 原文，零推断，写 profile.md）',
+    '  yotta-memory context [--limit N] [--owner <id>] [--budget N]  生成开工上下文包（身份+铁律+画像+近期记忆+边界+承诺；--budget 近期记忆字符预算，0=不限）',
     '  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]  归档（盖棺分+年龄）',
@@ -1142,7 +1433,7 @@ 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',
@@ -1162,7 +1453,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', '--source', '--weight', '--budget']);
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
     if (a === '--version' || a === '-v') { console.log(VERSION); return; }
@@ -1174,6 +1465,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;
@@ -1187,6 +1480,12 @@ 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 === '--source') opts.source = v;
+      else if (a === '--weight') opts.weight = parseFloat(v);
+      else if (a === '--budget') opts.budget = parseInt(v, 10) || 0;
     } else if (a.startsWith('--')) {
       console.error('未知选项: ' + a);
       process.exit(2);
@@ -1212,6 +1511,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': {
@@ -1246,6 +1547,9 @@ module.exports = {
   projectRoot: projectRoot,
   rememberCore: rememberCore,
   recallCore: recallCore,
+  profileCore: profileCore,
+  contextCore: contextCore,
+  importanceScore: importanceScore,
   forgetCore: forgetCore,
   archiveCore: archiveCore,
   mcpTools: mcpTools,

package/package.json

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

package/references/protocol.md

@@ -1,4 +1,4 @@
-# yotta-memory 协议规范 v0.5.4
+# yotta-memory 协议规范 v0.6.1
 
 > 本文件定义 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. 文件格式
@@ -73,6 +74,8 @@ immutable: false
 | `immutable` | 否 | `true` 时 archive 不移动（用户级硬事实）|
 | `scope` | 否 | `public` / `private`，默认按类型（FACT=public，其余 private）|
 | `owner` | 否 | 归属 agent id，默认空；private+owner 非空默认仅供该 owner agent 读取，其它 agent 越界读需 grant 授权、identity=user 或 `--unsafe` |
+| `source` | 否 | 记录来源（如 `对话` / `推断`），`remember --source` 写入 |
+| `weight` | 否 | 重要性权重（默认 1.0，>1 提权 / <1 降权），去重时取 max |
 | `access_count` | 否 | 命中次数，recall 命中展示集时 +1 |
 | `last_accessed` | 否 | 最近访问日期 `YYYY-MM-DD` |
 
@@ -111,14 +114,41 @@ immutable: false
 | 命令 | 行为 |
 |---|---|
 | `init [--project]` | 创建目录结构；默认用户级，`--project` 建项目级 |
-| `remember <type> <subject> <statement> [--owner <id>]` | 写入；同 subject+statement 已存在则只更新 `updated`；`--owner` 标注归属 |
+| `remember <type> <subject> <statement> [--owner <id>] [--source <来源>] [--weight <0..>] [--verify] [--no-hint]` | 写入；同 subject+statement 已存在则更新 `updated` 且 `weight` 取 max；`--source` 记录来源；`--weight` 重要性权重；`--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>] [--budget N]` | 开工上下文包（stdout：身份 + 多智能体铁律 + 画像 + 近期记忆 + 边界 + 承诺；`--budget` 近期记忆字符预算）|
+| `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>] [--budget N]`：stdout 输出开工上下文包（不落盘），含多智能体接入铁律段（可读 A/B/C、可写范围、违规红线）与五段：
+  1. 身份：agent_id / agent_name / user_name / relationship / host / memory_home（读自我档案）
+  2. 用户画像摘要：profile.md（不存在则自动生成一次或降级跳过）
+  3. 近期记忆：按 importance（confidence × recency + updated + weight + immutable）排序前 N 条（默认 10），读取分区过滤；`--budget` 时按剩余字符预算逐条放行（身份/铁律/画像/边界/承诺 必保）
+  4. 边界提醒：BOUND 全列（可读范围内）
+  5. 承诺 / 锚点：COMMIT 全列（可读范围内）
+
+### remember / iam 扩展（v0.6.0）
+
+- `remember ... --verify`：写后自动回读校验（recall 命中刚写入条目），输出「已写回读 OK」。
+- `remember ... --no-hint`：关闭类型启发式提示。默认开启：statement 含主观/关系词（用户 / 偏好 / 喜欢 / 关系 / 称呼 等）且 type=FACT 时 stdout 提示「疑似用户偏好 / 关系，建议 PREF」，仅提示不拦截。
+- `remember ... --source <来源>`：记录来源（如 `对话` / `推断` / `交接`）。
+- `remember ... --weight <0..>`：重要性权重（默认 1.0，>1 提权 / <1 降权）；去重更新时 `weight` 取 max（多次印证自动提权，与灵魂盘 record.py 一致）。
+- `iam <id> [--name <显示名>] [--user <用户名>] [--relationship <关系>] [--force]`：自我档案 PREF 扩展 `agent_name / user_name / relationship`；不带新参数行为与 0.4.2 一致。
 ### 去重与更新
 
 - remember 时若同 `type + subject + statement` 已存在，仅刷新 `updated`，不产生重复文件。