Cowork の永続メモリは、更新日ではなく検算で鮮度を判定します

---
name: reference-data-path
description: 参照データの正本は _reference_data/ 配下です
type: reference
verify:
  kind: readable                          # 読めて中身があるか
  target: data/_reference_data/keywords.txt
---
参照データを読むときは _reference_data/ を見ます。

---
name: wallpaper-batch-order
description: 派生生成は分類より先に走らせます
type: project
verify:
  kind: grep                              # 実装側にその順序が残っているか
  target: scripts/batch.sh
  pattern: "derive_before_classify"
---
順序を入れ替えると分類が空振りします。

---
name: why-manual-approval
description: 不可逆な操作は自分で押すという線引き
type: feedback
verify:
  kind: none                              # 対応物を持たない事実です
---
記録は自動、確定は手動。

#!/usr/bin/env python3
"""永続メモリの主張を、参照する直前に検算します。"""
from __future__ import annotations
 
import re
import subprocess
import sys
from dataclasses import dataclass
from pathlib import Path
 
FM = re.compile(r"\A---\n(.*?)\n---\n", re.S)
 
 
def parse_frontmatter(text: str) -> dict:
    """依存なしで 2 階層までの frontmatter を読む簡易パーサです。"""
    m = FM.match(text)
    if not m:
        return {}
    data: dict = {}
    parent = None
    for raw in m.group(1).splitlines():
        if not raw.strip() or raw.lstrip().startswith("#"):
            continue
        indent = len(raw) - len(raw.lstrip())
        if ":" not in raw:
            continue
        key, _, value = raw.strip().partition(":")
        value = value.strip().strip('"').strip("'")
        if indent == 0:
            if value == "":
                parent = key          # ネストの親（verify: など）
                data[key] = {}
            else:
                parent = None
                data[key] = value
        elif parent:
            data[parent][key] = value
    return data
 
 
@dataclass
class Result:
    name: str
    status: str        # fresh / stale / unverifiable
    reason: str
 
 
def verify(spec: dict, root: Path) -> tuple[str, str]:
    kind = spec.get("kind", "none")
 
    if kind == "none":
        # 判断や線引きは対応物を持たないので検算しません
        return "unverifiable", "検算対象なし（判断・原則）"
 
    if kind == "readable":
        p = root / spec["target"]
        if not p.exists():
            return "stale", f"存在しません: {spec['target']}"
        try:
            head = p.read_bytes()[:4096]
        except OSError as e:
            return "stale", f"読めません: {e.__class__.__name__}"
        # 改行 1 バイトだけのファイルは -s も先頭バイト検査も通ってしまいます
        if not head.strip():
            return "stale", f"中身が空でした: {spec['target']}"
        return "fresh", "読めて中身があります"
 
    if kind == "grep":
        p = root / spec["target"]
        if not p.exists():
            return "stale", f"存在しません: {spec['target']}"
        pattern = spec.get("pattern", "")
        if re.search(pattern, p.read_text(errors="replace")):
            return "fresh", f"一致: /{pattern}/"
        return "stale", f"一致しません: /{pattern}/"
 
    if kind == "command":
        proc = subprocess.run(
            spec["target"], shell=True, cwd=root,
            capture_output=True, timeout=int(spec.get("timeout", 20)),
        )
        if proc.returncode == 0:
            return "fresh", "終了コード 0"
        return "stale", f"終了コード {proc.returncode}"
 
    return "unverifiable", f"未知の kind: {kind}"
 
 
def scan(memory_dir: Path, root: Path) -> list[Result]:
    results: list[Result] = []
    for path in sorted(memory_dir.glob("*.md")):
        fm = parse_frontmatter(path.read_text(errors="replace"))
        if not fm:
            results.append(Result(path.stem, "unverifiable", "frontmatter がありません"))
            continue
        spec = fm.get("verify")
        if not isinstance(spec, dict):
            results.append(Result(fm.get("name", path.stem), "unverifiable", "verify 未定義"))
            continue
        status, reason = verify(spec, root)
        results.append(Result(fm.get("name", path.stem), status, reason))
    return results
 
 
def main() -> int:
    memory_dir = Path(sys.argv[1] if len(sys.argv) > 1 else "memory")
    root = Path(sys.argv[2] if len(sys.argv) > 2 else ".")
    results = scan(memory_dir, root)
    mark = {"fresh": "OK   ", "stale": "STALE", "unverifiable": "SKIP "}
    for r in results:
        print(f"{mark[r.status]} {r.name}: {r.reason}")
    stale = [r for r in results if r.status == "stale"]
    print(f"\nfresh={sum(1 for r in results if r.status=='fresh')} "
          f"stale={len(stale)} "
          f"unverifiable={sum(1 for r in results if r.status=='unverifiable')}")
    return 1 if stale else 0
 
 
if __name__ == "__main__":
    raise SystemExit(main())

$ python3 memcheck.py memory .
OK    reference-data-path: 読めて中身があります
STALE wallpaper-batch-order: 一致しません: /derive_before_classify/
SKIP  why-manual-approval: 検算対象なし（判断・原則）
 
fresh=1 stale=1 unverifiable=1
$ echo $?
1

$ printf '\n' > data/_reference_data/keywords.txt   # 改行だけのファイル
$ [ -s data/_reference_data/keywords.txt ] && echo "[ -s ] => true (サイズは 1 バイト)"
[ -s ] => true (サイズは 1 バイト)

try:
    results = scan(memory_dir, root)
except Exception as e:                       # 検算基盤の障害は「全部信用しない」へ倒します
    print(f"verifier failed, holding all memories: {e}", file=sys.stderr)
    results = [Result(p.stem, "stale", "verifier error")
               for p in sorted(memory_dir.glob("*.md"))]

#!/usr/bin/env python3
"""検算を通ったメモリだけを本文つきで渡し、落ちたものは見出しだけ残します。"""
from pathlib import Path
from memcheck import parse_frontmatter, scan
 
 
def build_context(memory_dir: Path, root: Path) -> str:
    status = {r.name: r for r in scan(memory_dir, root)}
    fresh_blocks, held_blocks = [], []
 
    for path in sorted(memory_dir.glob("*.md")):
        text = path.read_text(errors="replace")
        fm = parse_frontmatter(text)
        name = fm.get("name", path.stem)
        body = text.split("---", 2)[-1].strip()
        r = status.get(name)
        if r is None or r.status == "stale":
            # 黙って捨てません。「あったが今は信用できない」ことを見えるようにします
            held_blocks.append(f"- {name}: 保留（{r.reason if r else '判定なし'}）")
        else:
            fresh_blocks.append(f"## {name}\n{body}")
 
    out = "\n\n".join(fresh_blocks)
    if held_blocks:
        out += "\n\n## 保留中の記憶（本文は渡していません）\n" + "\n".join(held_blocks)
    return out
 
 
if __name__ == "__main__":
    print(build_context(Path("memory"), Path(".")))

## reference-data-path
参照データを読むときは _reference_data/ を見ます。
 
## why-manual-approval
記録は自動、確定は手動。
 
## 保留中の記憶（本文は渡していません）
- wallpaper-batch-order: 保留（一致しません: /derive_before_classify/）