memorytalk 5.0.1__tar.gz → 5.0.2__tar.gz

{memorytalk-5.0.1 → memorytalk-5.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memorytalk
-Version: 5.0.1
+Version: 5.0.2
 Summary: memory.talk v5 — work / collections / user 三个顶层对象的工作台:跑 code agent 的 work 树,git 分层的认知层,注册的团队成员
 Project-URL: Homepage, https://github.com/memory-co/memory.talk
 Project-URL: Repository, https://github.com/memory-co/memory.talk

{memorytalk-5.0.1 → memorytalk-5.0.2}/docs/api/v5/README.md

@@ -34,6 +34,7 @@
 | `GET` | `/api/users/me` | 我是谁:X-Memory-Talk-User 对应的 user 档案(没带 → null) |
 | `GET` | `/api/users/{name}` | 一个 user 的档案 + 建的 / 动过的 work、最近的提交 |
 | `PUT` | `/api/users/{name}` | 改档案(display_name / email) |
+| `GET` | `/api/collections/config` | collections.json 本体 + 它的 git 历史(层的变化史) |
 | `GET` | `/api/collections/layers` | 有哪些层(最底在前)、各自的 schema 与行为 |
 | `POST` | `/api/collections/layers` | 加一个用户层:一份 schema YAML |
 | `GET` | `/api/collections/managed` | 某个 work 管的所有对象;不传 work = 没人管的对象 |

{memorytalk-5.0.1 → memorytalk-5.0.2}/docs/api/v5/collections.md

@@ -2,7 +2,7 @@
 
 认知层。层由 schema 定义(内置 origin / issue / card,可加用户层);对象 = 带后缀的目录 `<path>.<层>/`,放在树的任何位置;origin = 不带后缀的文件。每个写动作一个 `[层名]` 提交,落在 `layer/<层>` 上再 merge 进 `stack`;碰了别的层的路径被守卫拒绝(409 `guard`)。机制见 [designs collections.md](../../designs/v5/collections.md) / [collections-layer.md](../../designs/v5/collections-layer.md) / [manager.md](../../designs/v5/manager.md)。
 
-`{path:path}` 直接放在 URL 里(可含 `/` 和中文)。固定子路径(`layers` `tree` `search` `manager` `managed` `history` `act`)先于 `{layer}`。
+`{path:path}` 直接放在 URL 里(可含 `/` 和中文)。固定子路径(`layers` `config` `tree` `search` `manager` `managed` `history` `act`)先于 `{layer}`。
 
 ---
 
@@ -28,15 +28,26 @@
 {"name": "decision", "schema_yaml": "layer: decision\nformat: markdown+frontmatter\ntitle: title\nfields:\n  title: {type: string, required: true}\n  issue: {type: ref, layer: issue}\n", "reason": ""}
 ```
 
-**201** 返回 LayerInfo。副作用:`schemas/decision.yaml` 进最底层(一个 `[origin]` 提交)、根上的 `layers` 文件加一行、新分支 `layer/decision` 从始祖出发。重启后仍在。已存在 → 409。类型只有 `string` `int` `bool` `"list[string]"` `ref` `"list[ref]"`(带 `[` 的要加引号)。
+**201** 返回 LayerInfo。副作用:`collections.json` 的 `layers[]` 多一项(schema 内嵌、`added_at`),一个 `[origin]` 提交;新分支 `layer/decision` 从始祖出发。重启后仍在。已存在 → 409。类型只有 `string` `int` `bool` `"list[string]"` `ref` `"list[ref]"`(带 `[` 的要加引号)。
 
 ---
 
 ## 树、检索、目录
 
+### GET /api/collections/config
+
+`collections.json` 本体 + 它的提交历史(层的变化史):
+
+```json
+{"config": {"version": 1, "layers": [{"name": "origin", "builtin": true}, {"name": "issue", "builtin": true}, {"name": "card", "builtin": true},
+                                        {"name": "decision", "schema": {"format": "…", "fields": {…}}, "added_at": "…"}]},
+ "history": [{"sha": "…", "author": "alice", "date": "…", "subject": "[origin] collections: add layer decision", "body": "Reason: …"},
+             {"sha": "…", "subject": "[origin] collections: init", …}]}
+```
+
 ### GET /api/collections/tree?path=
 
-浏览一个目录:对象折成一项(`kind: object`,`path` 不含后缀)、普通目录、origin 文件。`manager.json` / `layers` / `schemas/` 不列。
+浏览一个目录:对象折成一项(`kind: object`,`path` 不含后缀)、普通目录、origin 文件。`manager.json` / `collections.json` 不列。
 
 ```json
 [{"name": "配置", "path": "memory.talk/配置", "kind": "dir", "layer": null},

{memorytalk-5.0.1 → memorytalk-5.0.2}/docs/designs/v5/collections-layer.md

@@ -6,7 +6,7 @@
 - v5 collections(层即 collectbase 的 layer;Collections 是认知层的容器): [collections.md](collections.md)
 - v5 manager(任何层的任何目录都可以放 `manager.json`): [manager.md](manager.md)
 - v5 issue / card(两个内置层,照着看就是范例): [issue.md](issue.md) / [card.md](card.md)
-- collectbase `layers` 文件与 `cb init`(层的清单和顺序在这里): [cli.md](https://github.com/memory-co/collectbase/blob/main/docs/v2/works/cli.md)
+- collectbase 的 `layers` 锚定文件(memory.talk 对应的是仓库根的 `collections.json`): [cli.md](https://github.com/memory-co/collectbase/blob/main/docs/v2/works/cli.md)
 
 ---
 
@@ -16,12 +16,12 @@
 
 | 问题 | 答案落在哪 |
 |---|---|
-| **叫什么** | 层名:`layers` 文件里一行、分支 `layer/<名>`、提交前缀 `[名]` |
+| **叫什么** | 层名:`collections.json` 的 `layers[]` 里一项、分支 `layer/<名>`、提交前缀 `[名]` |
 | **住哪** | 路径:这个层的文件都在哪个目录下(和别的层不相交) |
 | **长什么样** | schema:一个对象是一个什么格式的文件、有哪些字段、哪个是标题、哪些是引用 |
-| **排在哪** | 层序:它在 `layers` 里的位置——比谁更接近记录、比谁更接近结论 |
+| **排在哪** | 层序:它在 `collections.json` 的 `layers[]` 里的位置——比谁更接近记录、比谁更接近结论 |
 
-落下来就是两个文件:**`layers` 里加一行**(collectbase 的事),**`schemas/<名>.yaml` 写一份**(memory.talk 的事)。不写代码。
+落下来就是**仓库根 `collections.json` 的 `layers[]` 里多一项**——名字、schema 内嵌、什么时候加的;一次最底层的提交,`git log collections.json` 就是层的变化史。不写代码。你手里写的还是一份 YAML 字段表(`memory.talk collection layers add <名> --schema <file>`),系统把它嵌进 `collections.json`。
 
 ---
 
@@ -42,7 +42,7 @@
 schema 说清一个对象是什么样的文件。最小的一份:
 
 ```yaml
-# schemas/decision.yaml
+# 写成 YAML 交给 `collection layers add`;落进 collections.json 时就是这份的 JSON
 layer: decision
 object: <名>.decision/decision.md       # 对象 = 带后缀的目录,本体文件叫 decision.md;<名> 由人起,放哪都行
 format: markdown+frontmatter             # 或 json
@@ -139,15 +139,15 @@ schema:      title / hypothesis / setup / result / verdict(supports | refutes |
 
 ## 6. 改层、删层
 
-- **改 schema**:加字段随时加(老对象没有那个字段就是空);删字段、改类型要先把老对象迁过来——那是一次 `[名]` 提交,历史里看得见。schema 文件本身也在 Collections 里(最底层,和 `layers` 一起),改它也是提交。
-- **加层**:`layers` 加一行 + 一份 schema;collectbase 从当前 HEAD 开分支,从此这一层的历史开始。之前的历史不受影响。
-- **删层**:collectbase 说层是可以停的(分支留着不动);memory.talk 侧把它从 `layers` 拿掉,通用端点就不再暴露它,文件和历史都在。**不删对象**——删了也在 git 里,但没必要。
+- **改 schema**:加字段随时加(老对象没有那个字段就是空);删字段、改类型要先把老对象迁过来——那是一次 `[名]` 提交,历史里看得见。schema 就在 `collections.json` 里(最底层),改它也是提交。
+- **加层**:`collections.json` 的 `layers[]` 加一项(带 schema);新分支从始祖出发,从此这一层的历史开始。之前的历史不受影响。
+- **删层**:collectbase 说层是可以停的(分支留着不动);memory.talk 侧把它从 `collections.json` 拿掉,通用端点就不再暴露它,文件和历史都在。**不删对象**——删了也在 git 里,但没必要。
 
 ---
 
 ## 7. 这篇有意不定的事
 
-- **schema 文件放哪、归哪层**:本篇按「Collections 最底层,和 `layers` 并列」写(它是机制不是内容)。要不要单独一个 `schemas/` 目录,还是每层目录里一份 `schema.yaml`——后者「层和它的定义在一起」更好看,但底层改不动上层目录里的文件,得想清楚归属。
+- ~~schema 文件放哪、归哪层~~:已定——没有单独的 schema 文件,schema 内嵌在 `collections.json` 的 `layers[]` 里,整份文件归最底层。
 - **schema 语言**:上面用的是 YAML 字段表。要不要直接用 JSON Schema(表达力强、工具多,但对人不友好)——倾向 YAML 字段表 + 少数约定,真不够再说。
 - **引用要不要校验存在**:`decision.issue` 指向一个不存在的 issue,写的时候拒绝还是放行。倾向写时校验存在、删时不级联(同 [collections.md §7](collections.md))。
 - **通用端点的形状**:`/api/collections/<层>/<id>` 一套,内置层的 `/api/issues/…` `/api/cards/…` 是不是它上面的别名。

{memorytalk-5.0.1 → memorytalk-5.0.2}/docs/designs/v5/collections.md

@@ -68,7 +68,7 @@ issue 和 card **只是两个内置的 layer**。它们的对象模型([issue.md
 
 - **每个 layer 自己一条历史。** `git log layer/card` 只有卡的变化,`git log layer/issue` 只有辩论序列;`git log --first-parent stack` 是全部认知的时间线,每一行自带 `[issue]` / `[card]` 标注。裸 git 里这些要靠路径过滤去拼,而且分支上什么都混在一起。
 - **layer 与 layer 之间路径不相交,由 hook 守着。** 一个声明 `[card]` 的提交碰了某个 `.issue/` 目录里的文件,当场拒绝——包括 `--no-verify`、`reset`、`cherry-pick` 都绕不过。这就是 collectbase 说的「认知卫生」在 memory.talk 里的形态:**不会有一次提交把「争的过程」和「争完的结论」搅在一起**。
-- **layer 是可加的,不用改代码。** collectbase 的 `layers` 文件就是 layer 的清单;加一层 = 加一个名字。memory.talk 在这上面只多要一样东西:**schema**——这个 layer 的文件长什么样。于是「我想记一种新东西」(决策记录、实验日志、人物档案……)变成写一份 schema,而不是往 backend 里加一个包。
+- **layer 是可加的,不用改代码。** collectbase 用根上的 `layers` 文件当锚定;memory.talk 对应的是根上的 **`collections.json`**——整个 collections 的配置 + `layers[]` 清单(最底在前),用户层的 schema 内嵌在自己那一项里。它被 git 追踪、归最底层,`git log collections.json` 就是层的变化史;加一层 = 这份文件多一项。于是「我想记一种新东西」(决策记录、实验日志、人物档案……)变成写一份 schema,而不是往 backend 里加一个包。
 
 一句话:**collectbase 管「层怎么在 git 里成立」,memory.talk 管「每一层里的文件是什么」。**
 
@@ -146,7 +146,7 @@ git log --first-parent stack
 | 提交信息 | `card: write …` / `issue: argue …` | `[card] write …` / `[issue] argue …`(动词不变,层名前置) |
 | 跨对象的决定 | 一个 commit | 两个相邻提交 + 同一个 `Decision:` trailer(§6) |
 | 历史 | `git log -- <path>` | 同,外加 `git log layer/<名>` 看整层 |
-| 加一种新对象 | 改代码 | 写一份 schema + `layers` 里加一行 |
+| 加一种新对象 | 改代码 | 写一份 schema,嵌进 `collections.json` 的 `layers[]` |
 | 谁改不动谁 | 靠代码纪律 | hook 守着:上层改不动下层,跨层提交被拒 |
 
 collections-store.md 的两条原则不变:**认知层进 git,现场层用裸文件**。Collections 只是把「进 git」这一半做成了有层语义的。

{memorytalk-5.0.1 → memorytalk-5.0.2}/docs/designs/v5/manager.md

@@ -107,7 +107,7 @@ manager 机制不规定动作。但把它接到 v5 已有的几条线上,会自
 | issue.md §4 派出论证 work | `positions[].spawned_works` | 不变——派出是 issue 的领域动作,不是 manager 机制的事;派出的 work 默认挂在 manager work 下 |
 | work 树的父子 | 只表达「事怎么拆」 | 同时是**隐式的 manager 链**:子的变动默认打到父 |
 | issue / card 的存储形态 | `issues/<id>.json`、`cards/**/<slug>.md`,按层分目录 | 都变成**带后缀的目录**,放哪都行:`<名>.issue/issue.json`、`<名>.card/card.md`,自己目录里可放 `manager.json`([collections.md §1](collections.md)) |
-| collectbase 分层 | `[issue]` / `[card]` 各自路径 | `manager.json` 是**机制文件**(同 collectbase 的 `layers`),不是证据:在 `.issue/` 里随 `[issue]` 提交,在 `.card/` 里随 `[card]` 提交,在普通文件夹里归最底层但**不受 444 保护**——memory.talk 把它登记为机制例外 |
+| collectbase 分层 | `[issue]` / `[card]` 各自路径 | `manager.json` 是**机制文件**(同 `collections.json`),不是证据:在 `.issue/` 里随 `[issue]` 提交,在 `.card/` 里随 `[card]` 提交,在普通文件夹里归最底层但**不受 444 保护**——memory.talk 把它登记为机制例外 |
 
 ---
 

{memorytalk-5.0.1 → memorytalk-5.0.2}/docs/structure/v5/collections.md

@@ -16,10 +16,10 @@
   HEAD → stack;工作树跟着 stack(只为了人能 ls / cat,服务从不读它)
 ```
 
-- **始祖** = 第一个提交,只有根上的 `layers` 文件(一行一层,最底在前)。所有分支从它出发。
+- **始祖** = 第一个提交,只有根上的 `collections.json`:`{"version": 1, "layers": [{"name": "origin", "builtin": true}, …]}`,最底在前;用户层的项内嵌 `schema` 和 `added_at`。所有分支从它出发;`git log collections.json` = 层的变化史。
 - **一个动作一个提交**,信息以 `[层名]` 开头;跨层的决定是两个相邻提交 + 同一个 trailer。`git log --first-parent stack` 是全部认知的时间线;`git log layer/<层>` 是那一层的。
 - **守卫**(写时,plumbing 内):① 后缀 / 机制规则说这个路径该归哪层,和声明的层不符 → 拒;② 路径已在别的层的树里 → 拒。所以 `[card]` 提交碰不到 `.issue/` 里的东西。
-- **机制文件**:`layers`、`schemas/<层>.yaml` 归最底层;`manager.json` 归它所在目录按后缀规则算出的层。它们的变动不投递。
+- **机制文件**:`collections.json` 归最底层;`manager.json` 归它所在目录按后缀规则算出的层。它们的变动不投递,也不出现在 tree / 目录里。
 - 全部 plumbing(hash-object / update-index / write-tree / commit-tree / update-ref),不需要工作树、不装 hook——服务进程是唯一写者。
 
 ## 对象:带后缀的目录
@@ -30,7 +30,7 @@
 | id | 文件路径 | `path`(不含后缀) | `path` | `path` |
 | 格式 | 原文 | JSON | markdown + frontmatter | schema 定 |
 | 标题 | 文件名 | `question` | `title` | schema 的 `title` |
-| 层序 | 0(最底) | 1 | 2 | 之上,按 `layers` 顺序 |
+| 层序 | 0(最底) | 1 | 2 | 之上,按 `collections.json` 的 `layers[]` 顺序 |
 
 对象目录里还可以放 `manager.json`(谁管它)和附件。目录树按主题组织,原文、`.issue/`、`.card/` 并排。
 
@@ -122,7 +122,7 @@ frontmatter 只有 `key: value` 行;`links` 逗号分隔;空值不写。读出
 
 ### 用户层的 schema
 
-`schemas/<名>.yaml`,在仓库最底层:
+写成 YAML 交给 `POST /api/collections/layers`,系统把它嵌进 `collections.json` 的 `layers[]`:
 
 ```yaml
 layer: decision

{memorytalk-5.0.1 → memorytalk-5.0.2}/docs/structure/v5/filesystem.md

@@ -6,8 +6,7 @@
 ~/.memory.talk/                       ← MEMORY_TALK_HOME
 ├── collections/                      ← 分层 git 仓库(认知层),见 collections.md
 │   ├── .git/                         ←   refs/heads/layer/{origin,issue,card,…}、refs/heads/stack;HEAD → stack
-│   ├── layers                        ←   层清单,一行一层,最底在前(始祖提交里就有)
-│   ├── schemas/<层>.yaml             ←   用户层的 schema(最底层)
+│   ├── collections.json              ←   锚定:整个 collections 的配置 + layers[](最底在前,用户层内嵌 schema);始祖提交只有它;git 历史 = 层的变化史
 │   ├── manager.json                  ←   根:管一切(可选)
 │   └── <按主题组织的目录树>/          ←   原文、.issue/、.card/、.<用户层>/ 并排
 │       ├── manager.json              ←   这一片归谁管(可选,任何目录)

{memorytalk-5.0.1 → memorytalk-5.0.2}/memorytalk/backend/README.md

@@ -39,7 +39,7 @@ memorytalk/backend/           # 服务本体;memorytalk/cli.py 是它的命令
 │   │   ├── repo.py           #     分层 git(自己实现):layer/<名> 权威分支 + stack merge 视图 + 路径归属守卫;纯 plumbing
 │   │   ├── manager.py        #     manager.json:最近祖先解析
 │   │   ├── catalog.py        #     一层的目录(按目录树列标题)+ 召回文本
-│   │   └── __init__.py       #     CollectionsService:层的装载(内置 + schemas/*.yaml)、对象 CRUD、历史、检索、树、行为、manager、投递到收件箱
+│   │   └── __init__.py       #     CollectionsService:层的装载(内置 + collections.json 里内嵌 schema 的用户层)、对象 CRUD、历史、检索、树、行为、manager、投递到收件箱
 │   └── store/                #   装配 —— docs/designs/v5/provider.md
 │       └── __init__.py       #     StoreService:按 MEMORY_TALK_STORE 选 provider,按族建 work 仓储
 │
@@ -47,7 +47,7 @@ memorytalk/backend/           # 服务本体;memorytalk/cli.py 是它的命令
 │   ├── fs.py                 #   FileSystemProvider(read/write/append/list/…,能力 local_path)+ LocalFS
 │   └── db.py                 #   DatabaseProvider(表定义 + 链式 select/insert/update/delete,方言在内)+ SQLite
 │
-├── layers/                   # 每个内置 layer 一个文件;用户层来自仓库里的 schemas/<name>.yaml
+├── layers/                   # 每个内置 layer 一个文件;用户层来自仓库根 collections.json 里内嵌的 schema
 │   ├── _spec.py              #   LayerSpec:名字 + 形态(后缀 / 本体文件 / 格式)+ schema + 行为
 │   ├── _user.py              #   YAML 字段表 → LayerSpec(用户层,无行为)
 │   ├── origin.py             #   最底层:不带后缀的一切,原文

{memorytalk-5.0.1 → memorytalk-5.0.2}/memorytalk/backend/controllers/collections.py

@@ -35,6 +35,11 @@ def add_layer(req: LayerCreate, svc: CollectionsService = Depends(collections),
     return svc.add_layer(req.name, req.schema_yaml, req.reason, c)
 
 
+@router.get("/config", summary="collections.json 本体 + 它的 git 历史(层的变化史)")
+def config(svc: CollectionsService = Depends(collections)) -> dict:
+    return {"config": svc.anchor(), "history": [r.model_dump() for r in svc.anchor_history()]}
+
+
 @router.get("/tree", response_model=list[TreeItem], summary="浏览目录树:对象(带后缀的目录折成一项)、目录、origin 文件")
 def tree(path: str = "", svc: CollectionsService = Depends(collections)):
     return svc.tree(path)

{memorytalk-5.0.1 → memorytalk-5.0.2}/memorytalk/backend/layers/__init__.py

@@ -3,11 +3,11 @@
 from __future__ import annotations
 
 from ._spec import LayerSpec
-from ._user import from_yaml
+from ._user import from_dict, from_yaml, schema_from_yaml
 from .card import LAYER as CARD
 from .issue import LAYER as ISSUE
 from .origin import LAYER as ORIGIN
 
 BUILTIN: list[LayerSpec] = [ORIGIN, ISSUE, CARD]
 
-__all__ = ["LayerSpec", "BUILTIN", "from_yaml"]
+__all__ = ["LayerSpec", "BUILTIN", "from_yaml", "from_dict", "schema_from_yaml"]

{memorytalk-5.0.1 → memorytalk-5.0.2}/memorytalk/backend/layers/_user.py

@@ -13,9 +13,20 @@ _TYPES: dict[str, Any] = {"string": str, "int": int, "bool": bool, "ref": str,
                           "list[string]": list[str], "list[ref]": list[str]}
 
 
-def from_yaml(text: str) -> LayerSpec:
+def schema_from_yaml(text: str) -> dict:
     doc = yaml.safe_load(text) or {}
-    name = doc["layer"]
+    if "layer" not in doc:
+        raise ValueError("schema 里要有 layer: <名字>")
+    return doc
+
+
+def from_yaml(text: str) -> LayerSpec:
+    doc = schema_from_yaml(text)
+    return from_dict(doc["layer"], doc)
+
+
+def from_dict(name: str, doc: dict) -> LayerSpec:
+    """collections.json 里内嵌的 schema → LayerSpec。"""
     fmt = "markdown" if str(doc.get("format", "markdown+frontmatter")).startswith("markdown") else "json"
     fields: dict[str, FieldSpec] = {}
     refs: dict[str, str] = {}

{memorytalk-5.0.1 → memorytalk-5.0.2}/memorytalk/backend/services/collections/__init__.py

@@ -19,7 +19,7 @@ from .manager import FILE as MANAGER_FILE
 from .manager import ManagerIndex, manager_path
 from .repo import GuardError, Repo
 
-SCHEMAS_DIR = "schemas"
+CONFIG_FILE = "collections.json"
 
 
 class CollectionsError(RuntimeError):
@@ -60,16 +60,25 @@ class CollectionsService:
             if b.name not in names:
                 names.append(b.name)
         self.repo.ensure_layers(names)
+        cfg = self.repo.config()
         specs: dict[str, LayerSpec] = {}
-        for name in names:
+        for entry in cfg["layers"]:
+            name = entry["name"]
             if name in builtin:
                 specs[name] = builtin[name]
+            elif "schema" in entry:
+                specs[name] = layer_pkg.from_dict(name, entry["schema"])
             else:
-                text = self.repo.read(f"{SCHEMAS_DIR}/{name}.yaml")
-                if text is None:
-                    raise CollectionsError("bad_layer", f"层 {name} 在 layers 里,但没有 {SCHEMAS_DIR}/{name}.yaml", 500)
-                specs[name] = layer_pkg.from_yaml(text.decode())
-        self.layers, self.order = specs, names
+                raise CollectionsError("bad_layer", f"collections.json 里的层 {name} 既不是内置的,也没有 schema", 500)
+        self.layers, self.order = specs, [e["name"] for e in cfg["layers"]]
+
+    def anchor(self) -> dict:
+        """collections.json 本体。"""
+        return self.repo.config()
+
+    def anchor_history(self):
+        """collections.json 的提交历史 = 层的变化史(在最底层分支上)。"""
+        return self.repo.log(self.repo.layer_ref(self.order[0]), CONFIG_FILE)
 
     def layer(self, name: str) -> LayerSpec:
         try:
@@ -83,19 +92,22 @@ class CollectionsService:
     def add_layer(self, name: str, schema_yaml: str, reason: str, ctx: Ctx) -> LayerInfo:
         if name in self.layers:
             raise CollectionsError("exists", f"层已存在:{name}", 409)
-        spec = layer_pkg.from_yaml(schema_yaml)
-        if spec.name != name:
-            raise CollectionsError("bad_layer", f"schema 里的 layer 是 {spec.name!r},不是 {name!r}")
-        # schema 文件归最底层(机制,不是证据);然后重跑 init 把新层加在最上
-        self.repo.commit(self.order[0], f"[{self.order[0]}] layer: add {name}\n\n{('Reason: ' + reason) if reason else ''}".strip(),
-                         {f"{SCHEMAS_DIR}/{name}.yaml": schema_yaml.encode()}, [], layer_of=self.layer_of_path)
-        self.repo.ensure_layers([*self.order, name])
+        schema = layer_pkg.schema_from_yaml(schema_yaml)
+        if schema.get("layer", name) != name:
+            raise CollectionsError("bad_layer", f"schema 里的 layer 是 {schema.get('layer')!r},不是 {name!r}")
+        layer_pkg.from_dict(name, schema)                     # 先校验能不能解析
+        entry = {"name": name, "schema": {k: v for k, v in schema.items() if k != "layer"}, "added_at": _now()}
+        msg = f"[{self.order[0]}] collections: add layer {name}" + (f"\n\nReason: {reason}" if reason else "")
+        try:
+            self.repo.add_layer(entry, msg, author=self.author_of(ctx.user))
+        except GuardError as e:
+            raise CollectionsError("guard", str(e), e.status) from None
         self._load_layers()
         return self.layers[name].info(self.order.index(name))
 
     def layer_of_path(self, repo_path: str) -> str:
         """一个仓库路径归哪层:第一个带 `.<层>` 后缀的目录段说了算;都没有 → 最底层。"""
-        if repo_path == "layers" or repo_path.startswith(SCHEMAS_DIR + "/"):
+        if repo_path == CONFIG_FILE:
             return self.order[0]                      # 机制文件归最底层
         for seg in repo_path.split("/"):
             for name, spec in self.layers.items():
@@ -124,7 +136,7 @@ class CollectionsService:
         spec = self.layer(layer)
         out = []
         for repo_path in self.repo.tree(prefix):
-            if repo_path == "layers" or repo_path.startswith(SCHEMAS_DIR + "/") or repo_path.endswith(MANAGER_FILE):
+            if repo_path == CONFIG_FILE or repo_path.endswith(MANAGER_FILE):
                 continue
             if spec.format == "raw" and self.layer_of_path(repo_path) != spec.name:
                 continue
@@ -164,7 +176,7 @@ class CollectionsService:
         seen: dict[str, TreeItem] = {}
         for repo_path in self.repo.tree(prefix):
             rest = repo_path[len(prefix):].lstrip("/") if prefix else repo_path
-            if not rest or rest in ("layers",) or rest.startswith(SCHEMAS_DIR):
+            if not rest or rest == CONFIG_FILE:
                 continue
             head = rest.split("/", 1)[0]
             full = f"{prefix}/{head}" if prefix else head
@@ -306,7 +318,7 @@ class CollectionsService:
         """变动打到 manager work 的收件箱;没人管 → home/unmanaged.jsonl;自己造成的不投给自己。"""
         seen = set()
         for f in files:
-            if f == MANAGER_FILE or f.endswith("/" + MANAGER_FILE) or f == "layers" or f.startswith(SCHEMAS_DIR + "/"):
+            if f == MANAGER_FILE or f.endswith("/" + MANAGER_FILE) or f == CONFIG_FILE:
                 continue                                   # 机制文件的变动不投递
             m = self.managers.resolve(f)
             spec = self.layers[layer]

{memorytalk-5.0.1 → memorytalk-5.0.2}/memorytalk/backend/services/collections/repo.py

@@ -12,6 +12,7 @@
 """
 from __future__ import annotations
 
+import json
 import os
 import subprocess
 import tempfile
@@ -21,7 +22,11 @@ from pathlib import Path
 
 from memorytalk.backend.models.collections import Revision
 
-ANCHOR = "layers"                     # 根上的层清单:一行一个,最底在前
+
+def _dump(cfg: dict) -> bytes:
+    return (json.dumps(cfg, ensure_ascii=False, indent=2) + "\n").encode()
+
+ANCHOR = "collections.json"           # 根上的配置:整个 collections 的配置 + 层清单(最底在前);git 历史 = 层的变化史
 
 
 class GuardError(RuntimeError):
@@ -129,18 +134,23 @@ class Repo:
         sha = self._git("rev-list", "--max-parents=0", self.stack, check=False).split()
         return sha[0] if sha else None
 
-    def layers(self) -> list[str] | None:
+    def config(self) -> dict | None:
+        """collections.json(从 stack 树里读,不读工作区)。"""
         if self.resolve(self.stack) is None:
             return None
         data = self.read(ANCHOR)
-        return [l.strip() for l in data.decode().splitlines() if l.strip()] if data else None
+        return json.loads(data) if data else None
+
+    def layers(self) -> list[str] | None:
+        cfg = self.config()
+        return [l["name"] for l in cfg["layers"]] if cfg else None
 
     def ensure_layers(self, names: list[str]) -> None:
-        """无则建拓扑;有则把缺的层补上(新层分支从始祖出发,layers 文件在最底层更新)。"""
+        """无则建拓扑;有则把缺的内置层补上(新层分支从始祖出发,collections.json 在最底层更新)。"""
         cur = self.layers()
         if cur is None:
-            text = "\n".join(names) + "\n"
-            tree = self.write_tree({ANCHOR: Entry("100644", self.hash_object(text.encode()), ANCHOR)})
+            cfg = {"version": 1, "layers": [{"name": n, "builtin": True} for n in names]}
+            tree = self.write_tree({ANCHOR: Entry("100644", self.hash_object(_dump(cfg)), ANCHOR)})
             start = self.commit_tree(tree, [], f"[{names[0]}] collections: init\n\nlayers: {', '.join(names)}")
             for n in names:
                 self.update_ref(self.layer_ref(n), start)
@@ -155,9 +165,20 @@ class Repo:
         for n in missing:
             if self.resolve(self.layer_ref(n)) is None:
                 self.update_ref(self.layer_ref(n), start)
-        new = [*cur, *missing]
+        cfg = self.config()
+        cfg["layers"] += [{"name": n, "builtin": True} for n in missing]
         self.commit(cur[0], f"[{cur[0]}] collections: add layers {', '.join(missing)}",
-                    {ANCHOR: ("\n".join(new) + "\n").encode()}, [], layer_of=lambda p: cur[0])
+                    {ANCHOR: _dump(cfg)}, [], layer_of=lambda p: cur[0])
+
+    def add_layer(self, entry: dict, message: str, author=None) -> None:
+        """在 collections.json 的 layers[] 末尾加一层(最上),并从始祖开一条分支。"""
+        cfg = self.config()
+        cfg["layers"].append(entry)
+        start = self.anchor()
+        if self.resolve(self.layer_ref(entry["name"])) is None:
+            self.update_ref(self.layer_ref(entry["name"]), start)
+        bottom = cfg["layers"][0]["name"]
+        self.commit(bottom, message, {ANCHOR: _dump(cfg)}, [], layer_of=lambda p: bottom, author=author)
 
     # ------------------------------------------------------------ 归属
 

{memorytalk-5.0.1 → memorytalk-5.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memorytalk"
-version = "5.0.1"
+version = "5.0.2"
 description = "memory.talk v5 — work / collections / user 三个顶层对象的工作台:跑 code agent 的 work 树,git 分层的认知层,注册的团队成员"
 readme = "README.md"
 requires-python = ">=3.10"

memorytalk-5.0.2/tests/README.md

@@ -0,0 +1,19 @@
+# tests
+
+**场景化**:每个目录一个场景,自带 `README.md`(在测什么 / 不在这测什么 / fixture 来源)和 `test.py`;test.py 里每个函数只断言一件事,函数名就是结论。目录按层分:`providers/` `collections/` `works/` `work_servers/` `adapters/` `users/` `cli/`。
+
+```
+pip install -e ".[dev]" && pytest          # 全部
+pytest tests/collections/layer_guard        # 单个场景
+```
+
+## 公共 fixture(`conftest.py`)
+
+| fixture | 给什么 |
+|---|---|
+| `home` | 临时 `MEMORY_TALK_HOME` / workspace / 各平台会话记录根 / 独立 tmux socket;**按 `fs` 和 `sqlite` 两种 store 各跑一遍**(参数化) |
+| `client` | 直连 ASGI 的 `TestClient`;已注册 `alice` / `bob` / `carol`;`.json()` 解掉响应信封(成功给 `data`,出错给整个信封) |
+| `svc` | `client.app.state`:`collections` / `works` / `users` / `work_servers` / `store`,给要直接碰服务层的场景 |
+| `H(user)` | 返回带 `X-Memory-Talk-User` 的 headers 的小函数 |
+
+需要 tmux 的场景标了 `needs_tmux`,机器上没有就跳过。

memorytalk-5.0.2/tests/_util.py

@@ -0,0 +1,2 @@
+"""场景共用的小工具(conftest 里的函数导出一份,避免 import conftest)。"""
+from tests.conftest import git_authors, git_log  # noqa: F401

memorytalk-5.0.2/tests/adapters/claude_code/README.md

@@ -0,0 +1,12 @@
+# adapters / claude_code — agent 把手读 Claude Code 的会话记录
+
+## 这个场景在测什么
+`claude://<cwd>` 的会话是终端 + 把手多一项 `rounds`:按 cwd 编码定位 `~/.claude/projects/<cwd>/*.jsonl`,
+只认成员创建之后出现的记录;user / assistant 消息解析成 round(tool_result → tool,isMeta → system,sidechain 跳过);
+`GET …/rounds` 先同步再读,append-only、按 uuid 去重、增量追加。
+
+## 不在这测什么
+- Codex / Kimi 的格式 → 各自场景
+
+## fixture 来源
+`client`、`home`;PATH 里放一个假 `claude`(只要 tmux 能起);`needs_tmux`。

memorytalk-5.0.2/tests/adapters/claude_code/test.py

@@ -0,0 +1,65 @@
+"""adapters/claude_code -- rounds from ~/.claude/projects. See README.md."""
+import json
+import os
+import time
+
+import pytest
+
+from tests.conftest import needs_tmux
+
+pytestmark = needs_tmux
+
+
+@pytest.fixture
+def agent(client, home, monkeypatch):
+    bindir = home / "bin"; bindir.mkdir()
+    fake = bindir / "claude"; fake.write_text("#!/bin/sh\nsleep 60\n"); fake.chmod(0o755)
+    monkeypatch.setenv("PATH", f"{bindir}:{os.environ['PATH']}")
+    w = client.post("/api/works", json={"goal": "让 agent 干活"}).json()
+    proj = home / "ws" / "proj"; proj.mkdir(parents=True)
+    s = client.post(f"/api/works/{w['id']}/sessions", json={"uri": f"claude://{proj}"}).json()
+    time.sleep(0.05)
+    d = home / "claude" / str(proj).replace("/", "-"); d.mkdir(parents=True)
+    return w, s, proj, d / "sess.jsonl"
+
+
+ROWS = [
+    {"type": "user", "uuid": "u1", "timestamp": "2026-09-05T10:00:00Z", "message": {"content": [{"type": "text", "text": "把配置改成环境变量"}]}},
+    {"type": "assistant", "uuid": "a1", "message": {"content": [{"type": "text", "text": "好"}, {"type": "tool_use", "name": "Edit", "input": {"f": "config.py"}}]}},
+    {"type": "user", "uuid": "u2", "toolUseResult": {}, "message": {"content": [{"type": "tool_result", "content": "ok"}]}},
+    {"type": "user", "uuid": "u3", "isMeta": True, "message": {"content": "caveat"}},
+    {"type": "user", "uuid": "u4", "isSidechain": True, "message": {"content": "旁支"}},
+]
+
+
+def _write(path, rows, mode="w"):
+    with open(path, mode) as f:
+        f.write("".join(json.dumps(r) + "\n" for r in rows))
+
+
+def test_agent_session_has_rounds_capability(agent):
+    _, s, _, _ = agent
+    assert s["scheme"] == "claude" and "rounds" in s["handle"]["capabilities"]
+
+
+def test_no_transcript_yet_means_no_rounds(client, agent):
+    w, s, _, _ = agent
+    assert client.get(f"/api/works/{w['id']}/sessions/{s['id']}/rounds").json() == []
+
+
+def test_roles_are_classified_and_sidechain_skipped(client, agent):
+    w, s, _, path = agent
+    _write(path, ROWS)
+    rounds = client.get(f"/api/works/{w['id']}/sessions/{s['id']}/rounds").json()
+    assert [(r["id"], r["role"]) for r in rounds] == [("u1", "human"), ("a1", "assistant"), ("u2", "tool"), ("u3", "system")]
+    assert "[Edit]" in rounds[1]["text"]
+
+
+def test_rounds_are_deduplicated_and_appended(client, agent, svc):
+    w, s, _, path = agent
+    _write(path, ROWS)
+    client.get(f"/api/works/{w['id']}/sessions/{s['id']}/rounds")
+    assert len(client.get(f"/api/works/{w['id']}/sessions/{s['id']}/rounds").json()) == 4       # 再读不重复
+    _write(path, [{"type": "assistant", "uuid": "a2", "message": {"content": [{"type": "text", "text": "改完了"}]}}], "a")
+    assert client.get(f"/api/works/{w['id']}/sessions/{s['id']}/rounds").json()[-1]["id"] == "a2"
+    assert len(svc.works.repo.read(w["id"], "rounds", sub=s["id"])) == 5                         # append-only 的流

memorytalk-5.0.2/tests/adapters/codex/README.md

@@ -0,0 +1,8 @@
+# adapters / codex — 读 Codex 的 rollout 记录
+
+## 这个场景在测什么
+`CodexAdapter`:按 `session_meta.cwd` 匹配工作目录找到 `rollout-*.jsonl`;`user_message` / `agent_message` / `function_call` /
+`function_call_output` 解析成 round,`task_started` 之类的控制事件跳过。纯解析,不起 tmux。
+
+## fixture 来源
+`home`(临时的 codex 记录根)。

memorytalk-5.0.2/tests/adapters/codex/test.py

@@ -0,0 +1,34 @@
+"""adapters/codex -- rollout parsing. See README.md."""
+import json
+from pathlib import Path
+
+from memorytalk.backend.services.work_servers.adapters import CodexAdapter
+
+ROWS = [
+    {"type": "session_meta", "payload": {"cwd": "/w/p"}},
+    {"type": "event_msg", "timestamp": "t1", "payload": {"type": "user_message", "message": "hi"}},
+    {"type": "event_msg", "timestamp": "t2", "payload": {"type": "task_started"}},
+    {"type": "response_item", "timestamp": "t3", "payload": {"type": "function_call", "name": "shell", "arguments": "ls"}},
+    {"type": "response_item", "timestamp": "t4", "payload": {"type": "function_call_output", "output": "a b"}},
+    {"type": "event_msg", "timestamp": "t5", "payload": {"type": "agent_message", "message": "done"}},
+]
+
+
+def _rollout(home):
+    root = home / "codex" / "2026" / "09" / "05"; root.mkdir(parents=True)
+    p = root / "rollout-2026-09-05T10-00-00-abc.jsonl"
+    p.write_text("".join(json.dumps(r) + "\n" for r in ROWS))
+    return p
+
+
+def test_find_matches_by_cwd(home):
+    p = _rollout(home)
+    ad = CodexAdapter(home / "codex")
+    assert ad.find(Path("/w/p"), 0) == p
+    assert ad.find(Path("/other"), 0) is None
+
+
+def test_rounds_keep_conversation_and_tools_skip_control_events(home):
+    p = _rollout(home)
+    assert [(r.role, r.text) for r in CodexAdapter(home / "codex").rounds(p)] == [
+        ("human", "hi"), ("assistant", "[shell] ls"), ("tool", "[result] a b"), ("assistant", "done")]

memorytalk-5.0.2/tests/adapters/kimi/README.md

@@ -0,0 +1,8 @@
+# adapters / kimi — 读 Kimi Code 的 wire 记录
+
+## 这个场景在测什么
+`KimiAdapter`:`~/.kimi-code/sessions/wd_*/session_*/state.json` 的 `workDir` 匹配工作目录,记录在 `agents/main/wire.jsonl`;
+`turn.prompt` → human,loop event 里 `content.part`(text / think)→ assistant,`tool.call` / `tool.result` → 工具调用与结果。
+
+## fixture 来源
+`home`(临时的 kimi 记录根)。