mempipeline 0.8.0__tar.gz

mempipeline-0.8.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

mempipeline-0.8.0/PKG-INFO

@@ -0,0 +1,317 @@
+Metadata-Version: 2.4
+Name: mempipeline
+Version: 0.8.0
+Summary: 1-writer + N-contributors + unlimited-readers shared memory write pipeline: atomic idempotent writes, pluggable audit, staging ingest gate.
+Author: mempipeline contributors
+License-Expression: Apache-2.0
+Keywords: memory,agent,pipeline,audit,idempotent,staging
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mempipeline
+
+**Local-first shared memory for AI agents.** One writer distills, N contributors stage, unlimited readers recall — every write atomic, idempotent, audited, version-chained. **Your memory files never leave your machine.**
+
+**本地方优先的 AI Agent 共享记忆管线**：单一写者蒸馏、N 投稿者闸门投稿、无限读者召回。每次写入原子、幂等、可审计、版本链可回滚——**记忆正本永不出本机**。
+
+![ci](https://github.com/18DU1019/mempipeline/actions/workflows/ci.yml/badge.svg)
+![license](https://img.shields.io/badge/license-Apache--2.0-blue)
+
+## Why mempipeline
+
+Most agent-memory solutions are cloud APIs: convenient, but your memory — the distilled record of your decisions — lives on someone else's server. mempipeline takes the opposite bet: memory is plain Markdown on your own disk, with the discipline of a production database.
+
+| | mempipeline | Cloud APIs (Mem0 / Zep / Letta Cloud) |
+|---|---|---|
+| **Data residency** | plain Markdown files on your disk; nothing leaves the machine | memory stored in vendor cloud |
+| **Auditability** | append-only audit log + SHA-256 version chain, rollback-ready | opaque |
+| **Idempotent writes** | identical stable body is never rewritten (content-hash skip) | N/A |
+| **Feedback loop** | distill → recall closed in-repo; adopt/judge trust-overlay wiring left to your orchestration layer (APIs provided) | store/retrieve only |
+| **Retrieval** | ngram TF-IDF + SQLite inverted index; optional local bge-m3 hybrid | managed embeddings |
+| **Best fit** | single machine, single operator, privacy-first | teams, multi-tenant, hosted scale |
+
+**Honest trade-offs**: no hosted dashboard, no multi-tenant sync, no managed embeddings. If you need vendor-managed scale across a team, use the clouds. If you need your memory to stay *yours* — auditable, portable, version-chained — keep reading.
+
+## 30-second quick start
+
+Install from source (PyPI package coming soon):
+
+```bash
+git clone https://github.com/18DU1019/mempipeline.git
+cd mempipeline
+python -c "import mempipeline; print('ok')"
+```
+
+Write a memory (writer side), fully self-contained:
+
+```python
+from pathlib import Path
+from tempfile import mkdtemp
+from mempipeline.audit import FileAudit
+from mempipeline.engine import write_atomic
+from mempipeline.protocol import Note
+
+mem_root = Path(mkdtemp()) / "mem"          # any directory you own
+audit = FileAudit(mem_root / ".." / "audit" / "log.md",
+                  mem_root / ".." / "audit" / "manifest.json", mem_root)
+note = Note(title="Rule", summary="demo", tier="medium", importance=0.6, body="body")
+out = mem_root / "02-中期记忆" / "项目会话-规则-ab1234cd.md"
+out.parent.mkdir(parents=True, exist_ok=True)
+status, _ = write_atomic(out, note.to_frontmatter() + "\n\n" + note.body + "\n", audit)
+# status == "wrote" (first write); rewrite the same body -> "skipped" (idempotent)
+```
+
+Recall it (reader side):
+
+```python
+from mempipeline.recall import MemoryRecall
+hits = MemoryRecall(mem_root).recall("rule keywords")   # [(path, score), ...]
+```
+
+---
+
+**Shared-memory *write* pipeline for the 1-writer / N-contributor /
+unlimited-reader model.** Atomic idempotent writes, a pluggable audit
+backend, and a staging ingest gate — with zero private paths baked in.
+
+`mempipeline` is a **library**: `engine` (atomic idempotent writes),
+`ingest` (staging gate), `audit` (pluggable backends), plus read-side
+modules — ngram TF-IDF recall
+(`mempipeline.recall`, with an optional SQLite inverted-index fast path), semantic
+hybrid retrieval (`semantic.py`), timeline graph (`timegrap.py`),
+bidirectional cross-referencing (`crossref.py`), the PDCA Check signal
+layer (`recall_golden.py`), and a recall-degradation diagnosis & Act
+suggestion surface (`act.py`, human-triggered, Act off by default).
+CLI orchestration (one-command recall with a judge feedback loop) sits
+in the operator's own automation layer — build yours on top of these APIs.
+
+## Model
+
+| Role        | Capability                               | Channel              |
+|-------------|------------------------------------------|----------------------|
+| **Writer**  | the single one who distills into mirror  | engine                |
+| **Contributor** | drops authored note to staging gate | ingest               |
+| **Reader**  | reads mirror, never writes back          | any read-only API     |
+
+All paths are injected by the caller; nothing is hard-coded.
+
+## Install / import
+
+```bash
+pip install mempipeline
+# or: clone and add the folder to sys.path, then `import mempipeline`
+```
+
+## Quick start
+
+```python
+from pathlib import Path
+from mempipeline.audit import FileAudit
+from mempipeline.engine import write_atomic
+from mempipeline.protocol import Note
+
+mem_root = Path("./example_data/mem")
+audit = FileAudit(
+    log_path=mem_root / ".." / "audit" / "log.md",
+    manifest_path=mem_root / ".." / "audit" / "manifest.json",
+    root_dir=mem_root,
+)
+
+note = Note(title="Rule", summary="demo", tier="medium", importance=0.6, body="body")
+out = mem_root / "02-中期记忆" / "项目会话-规则-ab1234cd.md"
+status, wrote = write_atomic(out, note.to_frontmatter() + "\n\n" + note.body + "\n", audit)
+assert status == "wrote"      # first write
+status, _ = write_atomic(out, note.to_frontmatter() + "\n\n" + note.body + "\n", audit)
+assert status == "skipped"    # idempotent: same stable body, no rewrite
+```
+
+> Run the zero-dependency end-to-end suite locally: `python test_mempipeline.py`
+
+### N contributors via staging
+
+Drop authored Markdown (with `title` / `summary` / `memory_tier` /
+`source_agent` frontmatter) into a staging dir, then:
+
+```python
+from mempipeline.ingest import ingest
+ingest(
+    staging_dir=Path("./example_data/staging"),
+    mem_root=mem_root,
+    tier_dirs={"long": "01-长期记忆", "medium": "02-中期记忆"},
+    audit=audit,
+    on_ingest=lambda out: print("git add --", out),
+)
+```
+
+## Design pillars
+
+- **Atomic + idempotent** — writes go through a temp file + `os.replace`;
+  identical stable body (timestamps stripped) is skipped, never rewritten.
+- **Audit is a pluggable backend** — default `FileAudit` (append-only log +
+  external fingerprint manifest); swap in a DB/API backend behind the same
+  `AuditBackend` interface.
+- **Data-decoupled** — `protocol` owns the frontmatter contract; every path
+  is injected. Nothing here knows your vault.
+
+## SQLite inverted-index fast path (P1-A2)
+
+`recall.MemoryRecall` does a full-disk read + full IDF recompute on every
+query. For large mirrors that is O(N) per query. `recall.TFIDFIndex` is a
+zero-embedding SQLite inverted index that moves that cost to an explicit
+`build()`:
+
+```python
+from pathlib import Path
+from mempipeline.recall import MemoryRecall, TFIDFIndex
+
+idx = TFIDFIndex(Path("./recall.db"))
+idx.build(mem_root)                 # one-time scan; idempotent (skips indexed docs)
+m = MemoryRecall(mem_root, index=idx)   # fast path: no normalization, or index normalized with the same synonym table
+```
+
+- `recall()` returns the same `(path, score)` shape as `MemoryRecall`, so the
+  index is a drop-in fast path, not a second retrieval strategy. On any query
+  error it falls back to the full scan.
+- When `synonyms` normalization is active on `MemoryRecall`, the fast path
+  survives only if the index was built with the same synonym table
+  (`TFIDFIndex` normalizes documents at `build()` time and queries at recall
+  time, so a same-table injection stays isomorphic to the full scan);
+  a foreign-table index falls back to the full scan. The built-in
+  `recall.DEFAULT_SYNONYMS` table is what the panel/semantic gates use.
+- `governance.governance_health()` is a separate read-only snapshot (status
+  distribution, candidate backlog & oldest-stale age) for rendering the
+  governance-review pane.
+
+`mempipeline-panel` exposes the optional `--tfidf-db` flag to feed the index
+into the served recall path.
+
+## Time-dimension graph (P2)
+
+`mempipeline.timegrap` is a **read-only** scanner that clusters notes into
+timelines and traces how a topic evolves over time.
+
+- **Subject clustering** - `subject_key(title)` normalizes a title into a
+  stable cluster key (strips whitespace / punctuation / stop chars), so the
+  same topic keeps one theme even when titles differ in wording or
+  punctuation. Summaries never participate in the key, so *drifted*
+  notes (whose conclusion changed) still land in the same timeline and
+  can be seen as drift.
+- **Timeline playback** - each cluster yields a chronologically ascending
+  `TopicTimeline`; `recall()` returns the paths in time order,
+  `spans_days()` gives the span.
+- **Evolution signals** - per node, derived read-only: `first` /
+  `continued` / `revived` (gap >= `gap_days`, default 90) / `same_day`, plus
+  a `relation` of `duplicate` / `drift` / `stable` from bigram-Jaccard
+  summary similarity against the previous note (thresholds
+  `dup_threshold` / `drift_threshold`, both configurable and recorded on
+  each signal).
+- **Time benchmark fallback** - `updated`/`created` frontmatter win; missing
+  fields fall back to file mtime with an explicit `time_src` tag for
+  auditability.
+- **Project isolation** - pass `projects=[...]` to constrain the scan; no
+  cross-project leakage.
+
+Example:
+
+```python
+from mempipeline.timegrap import build_timeline
+timelines = build_timeline(mem_root)          # {subject_key: TopicTimeline}
+for sk, tl in timelines.items():
+    print(sk, tl.spans_days(), [sig["flag"] for sig in tl.signals])
+```
+
+## Timeline signals into governance candidates (P3-③)
+
+`governance.scan_stale_notes(mem_root, ..., timeline=...)` optionally accepts a
+`timeline` built by `build_timeline`; the lifecycle signals are then merged
+into the same P1 candidate list (still **no** automatic state change - Act
+stays human-triggered):
+
+- `conclusion_drift` (previous summary bigram similarity below `drift_threshold`)
+  surfaces as a `re-review` candidate;
+- `revived` (resumed after a gap >= `gap_days`) surfaces as a `review`
+  candidate, with a concurrent conclusion drift folded in as detail.
+
+Last mile: the caller builds the timeline and passes it in, so candidates are
+deduped by path against the stale-archive base list. No new metric system is
+introduced - only the time-dimension signals already validated in P2.
+
+---
+
+## 中文使用说明
+
+### 定位与三种身份
+
+`mempipeline` 是「1 写者 + N 投稿 + 无限读」模型的**写侧**管线。镜像是一个分层的 Markdown 目录；读侧能力（TF-IDF 召回 / 语义混合检索 / 时间图谱 / 交叉引用 / golden 检核）在本仓库内，外部蒸馏与控层脚本在运行台脚本目录（distill / sediment / audit_core）。
+
+| 身份 | 能力 | 通道 | 落点 |
+|---|---|---|---|
+| **写者** | 唯一有资格直接蒸馏进镜像 | `engine.write_atomic` | 幂等原子写 |
+| **投稿者** | 把带 frontmatter 的笔记丢到闸门 | `ingest.ingest` | staging 熔合 |
+| **读者** | 只读镜像、永不回写 | `distill-mem` 的 inject/recall | 任意只读接口 |
+
+所有路径由调用方注入，**零硬编码私有路径**。
+
+### 快速接入（四步）
+
+1. **配置路径**：复制 `config.example.py` 为 `config.py`，改 `MEM_ROOT` / `STAGING_DIR` / `STAGING_ROOT` / `AUDIT_LOG` / `MANIFEST` / `TIER_DIRS`。其中 `STAGING_ROOT` 为面板投稿位根，缺省回落 `MEMPIPELINE_STAGING` 环境变量或中性默认值；`config.py` 已被 `.gitignore` 排除，仅 `config.example.py` 样例入库。
+2. **写者**（蒸馏进镜像）：
+   ```python
+   from pathlib import Path
+   from mempipeline.audit import FileAudit
+   from mempipeline.engine import write_atomic
+   from mempipeline.protocol import Note
+
+   mem = Path("./example_data/mem")
+   audit = FileAudit(mem / ".." / "audit" / "log.md",
+                     mem / ".." / "audit" / "manifest.json", mem)
+   note = Note(title="规则", summary="单笔风险≤1ATR", tier="long",
+               importance=0.9, body="正文。")
+   out = mem / "01-长期记忆" / "项目会话-规则-ab12cd34.md"
+   s, _ = write_atomic(out, note.to_frontmatter() + "\n\n" + note.body + "\n", audit)
+   # s == "wrote"（首次）→ 再写同稳定正文 → s == "skipped"（幂等跳过）
+   ```
+3. **投稿者**（staging 熔合）：把带 `title`/`summary`/`memory_tier`/`source_agent` frontmatter 的裸 md 放入 staging 目录，再
+   ```python
+   from mempipeline.ingest import ingest
+   ingest(staging, mem, {"long": "01-长期记忆", "medium": "02-中期记忆"},
+          audit, on_ingest=lambda o: print("git add --", o))
+   ```
+4. **读者**：用本仓库 `recall.MemoryRecall`（ngram TF-IDF + 同义归一）或 `semantic.hybrid_recall`（bge-m3 + RRF 融合）做召回；时间演化用 `timegrap.build_timeline`（P2）；交叉引用用 `crossref.find_related`。大镜像可先用 `recall.TFIDFIndex.build()` 建 SQLite 倒排，再注入 `MemoryRecall(index=...)` 走快路径（无归一、或索引与实例用同一张同义表双侧归一时保持快路径；异表索引回落全扫，口径一致）。
+
+### DQ 转义契约（2026-08-27 起生效）
+
+写侧序列化时，**frontmatter 的字符串字段一律输出 YAML 双引号标量（无条件引号）**：
+
+```text
+---
+title: "2026"            # 纯数字字符串，仍读回 str，不会被解析成 int
+summary: "a # b：含冒号"   # 含 # 的串，不会被当注释截断
+source_agent: "writer"
+---
+importance: 0.9          # 数值字段保持裸值
+```
+
+两点原因：
+
+1. **指示符歧义**：plain 标量内 `#`（行首或前有空白）会被 YAML 当注释起始，`title: a # b` 解析成 `a`，值被静默截断。
+2. **schema 类型失真**：YAML 1.2 core schema 把未加引号的纯数字/布尔字符串解析成 int/bool——`title: 2026` 读回是 int 而非 str。
+
+配套：`ingest._parse_fm` 解析投稿 frontmatter 时会**剥匹配的外层引号**，故投稿端写引号或不写引号都兼容。转义顺序为 `\\` → `\"` → `\n\r\t`，全部合法 Double-Quoted 序列。
+
+### 安全与幂等契约（2026-09-01 起生效）
+
+**`project_id` 安全边界**：落盘路径由 `safe_project_id` 校验，仅放行 `[\w.-]+`；含 `/`、`\`、`..` 或其它非法字符的 `project_id` 一律回落 `legacy`/`global`，防止路径穿越与绝对路径逃逸。投稿端若依赖带子目录的 `project_id`，须改用合法字符。
+
+**`content_key` 幂等判据**：稳定正文 SHA-256 截断由 8 位提高至 12 位 hex，降低碰撞概率。迁移影响：升级前已用 8 位 key 落库的笔记，重写同一正文时因 key 变化会被判为新笔记而重复写入；如有需要，可对既有笔记按稳定正文重建 key 一次，或接受单次重复后由人工清理。
+
+**`stable_body` 豁免字段（2026-09-11 P3-0 起）**：稳定正文剔除 `updated:` 与 `created:` 两行。`updated` 是实时字段，参入会让幂等失效；`created` 是后加字段（P3-0 起写者落盘前回填），参入会让存量笔记首次带 created 重写时被判为新笔记。其余 frontmatter 字段（含 `status`）参与稳定正文——一次状态迁移会改变 content_key，属设计语义：状态是实质变化，该次写回为预期写入，不适用幂等跳过。
+
+## License
+
+Apache-2.0. See [LICENSE](LICENSE).