wicked-garden 12.51.0 → 12.52.0

package/.claude-plugin/marketplace.json

@@ -1 +1 @@
-{"name": "wicked-garden", "owner": {"name": "Mike Parcewski"}, "plugins": [{"name": "wicked-garden", "source": "./", "description": "Your coding agent already plans and swarms \u2014 Wicked Garden is the curated toolkit for what it can't: proof-not-claims gates, code links grep can't see, deterministic refactor, cross-session memory, multi-model second opinions (fallback seats labelled). Don't fight the harness; fill its gaps. The gate needs wicked-vault (a self-contained infra peer, installed directly) and re-derives through garden's built-in engine; estate/bus are opt-in layers (wicked-testing and wicked-brain are retired \u2014 QE ships in-catalog as the qe domain, memory lives in wicked-estate).", "version": "12.51.0"}], "version": "12.51.0"}
+{"name": "wicked-garden", "owner": {"name": "Mike Parcewski"}, "plugins": [{"name": "wicked-garden", "source": "./", "description": "Your coding agent already plans and swarms \u2014 Wicked Garden is the curated toolkit for what it can't: proof-not-claims gates, code links grep can't see, deterministic refactor, cross-session memory, multi-model second opinions (fallback seats labelled). Don't fight the harness; fill its gaps. The gate needs wicked-vault (a self-contained infra peer, installed directly) and re-derives through garden's built-in engine; estate/bus are opt-in layers (wicked-testing and wicked-brain are retired \u2014 QE ships in-catalog as the qe domain, memory lives in wicked-estate).", "version": "12.52.0"}], "version": "12.52.0"}

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-garden",
-  "version": "12.51.0",
+  "version": "12.52.0",
   "description": "Your coding agent's harness already plans and swarms; Wicked Garden is the curated toolkit for what it can't do alone. Proof, not claims \u2014 gates re-derive 'done' through the internal loom engine (fail-closed, independently attested via wicked-vault), so a self-asserted pass can't lie its way green. Relationships grep can't see \u2014 the wicked-estate code graph + injected bus/dispatch/capability/archetype edges power blast-radius & lineage. Plus deterministic multi-file refactor (wicked-patch), cross-session memory + knowledge (the mem domain over wicked-estate), multi-model second opinions (fallback seats labelled) (jam:council), portable expertise as on-demand skill-refs, and evidence-gated testing (the in-catalog qe domain). It reads the shape of your work to apply the right rigor \u2014 steering, not a pipeline \u2014 then gets out of the way. The compiler stamps a self-contained evidence gate into any repo that runs with no wicked-garden installed. Don't fight the harness; fill its gaps. The evidence gate requires wicked-vault, a self-contained infra peer wicked-garden installs directly; wicked-bus is an opt-in layer \u2014 install what you'll use, the toolkit works without the rest.",
   "wicked_vault_version": "^0.5.0",
   "wicked_ledger_version": "^0.6.0",

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [12.52.0] — 2026-10-11
+
+### Changed
+- **Learn indexing reads what merged and replaces a topic by its source (PR #1280).**
+  - `scripts/learn/index.py --ref <ref>` reads `.wicked/knowledge/` at a git ref, never the working copy. wicked-crew's learn schedule passes `origin/<default>`.
+  - When estate advertises `knowledge.forget` (estate K1+K2), each topic becomes one `knowledge.ingest {replace_source: true}` carrying `observed_at` and `source_rev`, and a topic with nothing left is forgotten by its source.
+  - An older estate keeps the per-revision scope fallback.
+
+## [12.51.1] — 2026-10-11
+
+### Fixed
+- **Memory scope is the checkout, not the cwd (w9-memfix2, codex post-merge review of #1274).** `project:<name>` now comes from the git checkout (a linked worktree resolves to its main checkout), so recalling from `app/src` sees what was stored from `app/`; `WICKED_ESTATE_MEMORY_SCOPE` is the configured project for both capture and recall. Two unrelated checkouts with the same name still share a scope unless one is configured.
+- **The durability gate keeps durable constants and constraints.** A version is refused only next to release status ("released 2.4.1"), so "keep SQLite >= 3.35.0 because RETURNING" is stored; a hex run counts as a commit SHA only when long (>= 12) or in commit context, so a CRC32 polynomial or a colour is kept.
+- **repo-learn no longer submits unapprovable knowledge proposals.** Estate promotes only `memory` and `policy:*`, so the shim refuses `kind_type: "knowledge"` and repo-learn lists those objects as pending in its report until estate's knowledge proposal type ships.
+
 ## [12.51.0] — 2026-10-11
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-garden",
-  "version": "12.51.0",
+  "version": "12.52.0",
   "type": "module",
   "description": "Curated toolkit for what AI coding agents can't do alone: evidence-gated work, codegraph relationships, deterministic multi-file refactor, multi-model second opinions, and cross-session memory. Installs as a Claude Code plugin.",
   "keywords": [

package/scripts/_context_backend.py

@@ -77,9 +77,6 @@ def _memory_scope() -> str:
     its ancestors (root-scoped memories included) but not other projects.
     Override via WICKED_ESTATE_MEMORY_SCOPE.
     """
-    pinned = os.environ.get("WICKED_ESTATE_MEMORY_SCOPE", "").strip()
-    if pinned:
-        return pinned
     import _estate_client
 
     return _estate_client.project_scope()

package/scripts/_estate_client.py

@@ -963,15 +963,49 @@ def context(
     return call("ContextBundle", args, timeout=timeout)
 
 
-def project_scope() -> str:
-    """The current project's memory scope, ``project:<cwd-basename>``.
+def checkout_root() -> Optional[Path]:
+    """The git checkout the cwd is in, resolved through linked worktrees.
 
-    The one default for both directions: memories are stored here, and recall
-    sees this scope plus its ancestors (root-scoped memories included). Reading
-    every project's memories is an explicit opt-in (``scope_prefix: ""``).
+    Walks up to the nearest ``.git``. A linked worktree's ``.git`` is a file
+    (``gitdir: <main>/.git/worktrees/<name>``): its project is the MAIN checkout,
+    so a run worktree shares the repo's memories. None outside any checkout.
     """
     try:
-        name = Path.cwd().name or "unknown"
+        here = Path.cwd().resolve()
+    except OSError:
+        return None
+    for d in (here, *here.parents):
+        git = d / ".git"
+        if git.is_dir():
+            return d
+        if git.is_file():
+            try:
+                line = git.read_text(encoding="utf-8").strip()
+            except OSError:
+                return d
+            gitdir = line[len("gitdir:"):].strip() if line.startswith("gitdir:") else ""
+            marker = f"{os.sep}.git{os.sep}worktrees{os.sep}"
+            norm = gitdir.replace("/", os.sep)
+            return Path(norm.split(marker)[0]) if marker in norm else d
+    return None
+
+
+def project_scope() -> str:
+    """The current project's memory scope: one identity for capture AND recall.
+
+    ``WICKED_ESTATE_MEMORY_SCOPE`` (the configured project) wins; else
+    ``project:<checkout name>`` from :func:`checkout_root` (stable across
+    subdirectories and worktrees); else ``project:<cwd-basename>``. Two
+    unrelated checkouts with the same name share a scope unless one is
+    configured. Recall sees this scope plus its ancestors (root-scoped
+    memories included); every project is the explicit ``scope_prefix: ""``.
+    """
+    pinned = os.environ.get("WICKED_ESTATE_MEMORY_SCOPE", "").strip()
+    if pinned:
+        return pinned
+    root = checkout_root()
+    try:
+        name = (root.name if root else Path.cwd().name) or "unknown"
     except OSError:
         name = "unknown"
     return f"project:{name}"
@@ -1051,6 +1085,13 @@ def propose(
     run's `WICKED_RUN_PROJECT` supplies): an unscoped proposal is refused here
     with the shape-error code, so it never lands project-less in the queue.
     """
+    if kind_type == "knowledge":
+        # Gate (DES-memory-vs-knowledge K3): estate's approve promotes only memory + policy:*,
+        # so a knowledge proposal would strand in the queue. Lift when estate ships the type.
+        return {"ok": False, "code": -32602,
+                "reason": 'kind_type "knowledge" is not approvable yet (estate promotes only '
+                          'memory and policy:*): keep the object in your report under '
+                          '"knowledge (pending)"; do not re-file it as a memory'}
     facets = _scope_facets_to_run_project(facets)
     project = (facets or {}).get("project")
     if not isinstance(project, str) or not project.strip():

package/scripts/learn/index.py

@@ -4,14 +4,16 @@
     wicked-garden run scripts/learn/index.py --repo <checkout> [--name <repo name>] [--slug <slug>] [--dry-run]
 
 Reads ``.wicked/knowledge/<slug>/`` from the checkout (run it on the default branch: index what was
-MERGED, never an open pull request) and, per topic, REPLACES the estate scope ``learn:<repo>/topic:<slug>``:
-``knowledge.erase`` of that scope, then one ``knowledge.ingest`` whose chunks are the topic's ACTIVE
-claims (each chunk ends with its sources and observed dates) and the README's sections. A retired,
-superseded or contradicted claim therefore leaves recall at the next index.
+MERGED, never an open pull request) and, per topic, REPLACES its knowledge in estate: one
+``knowledge.ingest {replace_source: true}`` (source ``repo:<repo>/.wicked/knowledge/<slug>``, scope
+``learn:<repo>/topic:<slug>``, ``observed_at`` = the topic's refreshed_at, ``source_rev`` = its tree hash)
+whose chunks are the topic's ACTIVE claims (each chunk ends with its sources and observed dates) and the
+README's sections. A retired, superseded or contradicted claim therefore leaves recall at the next
+index; a topic with nothing left is forgotten by its source (``knowledge.forget``).
 
-When the estate binary has no ``knowledge.erase`` yet, the topic is ingested under a per-revision
-scope ``learn:<repo>/topic:<slug>/rev:<tree hash>`` instead and the output says ``"replace": "unavailable"``
-(an older revision stays recallable until estate can erase it).
+When estate does not advertise ``knowledge.forget`` (before estate K1+K2), the topic is ingested under a
+per-revision scope ``learn:<repo>/topic:<slug>/rev:<tree hash>`` instead and the output says
+``"replace": "unavailable"`` (an older revision stays recallable until estate can replace it).
 
 Never from inside a governed run: a run's estate is read-only, and learned knowledge reaches the
 store only after its pull request merged. Prints one JSON object ``{ok, repo, topics: [{slug, scope,
@@ -77,40 +79,72 @@ def topic_payload(repo: Path, name: str, d: Path) -> dict:
         "source": f"repo:{name}/.wicked/knowledge/{t.slug}",
         "chunks": chunks,
         "tree_hash": tree_hash(d),
+        # when the topic was last researched (topic.json refreshed_at, else created_at)
+        "observed_at": (t.meta.get("refreshed_at") or t.meta.get("created_at")) if isinstance(t.meta, dict) else None,
         "read_errors": t.errors,
     }
 
 
-def index_topic(client, p: dict) -> dict:
+def index_topic(client, p: dict, tools: list | None = None) -> dict:
+    """Replace one topic in estate. With ``knowledge.forget`` advertised (estate K1+K2), the topic's
+    source is replaced in place (``knowledge.ingest {replace_source: true}``, carrying ``observed_at``
+    and ``source_rev``), and a topic with nothing left to index is forgotten by its source. Without
+    it, the topic is ingested under a per-revision scope and the output says so."""
     out = {"slug": p["slug"], "scope": p["scope"], "chunks": len(p["chunks"]), "tree_hash": p["tree_hash"]}
     if p["read_errors"]:
         out["read_errors"] = p["read_errors"]
-    if p["read_errors"]:
         out["ingested"] = False
-        out["reason"] = "the topic could not be fully read; its indexed scope is left as it was"
+        out["reason"] = "the topic could not be fully read; its indexed knowledge is left as it was"
         return out
-    erased = client.call("knowledge.erase", {"scope_prefix": p["scope"]}, timeout=30.0)
-    if erased is None:
-        out["replace"] = "unavailable"
-        out["scope"] = f"{p['scope']}/rev:{p['tree_hash']}"
-    else:
-        out["replace"] = "erased"
-        out["erased"] = erased
+    replace = "knowledge.forget" in (tools if tools is not None else client.list_tools())
     if not p["chunks"]:
         out["ingested"] = False
         out["reason"] = "no active claims and no README to index"
+        if replace:
+            forgotten = client.call("knowledge.forget", {"source": p["source"]}, timeout=30.0)
+            out["replace"] = "forgotten" if forgotten is not None else "forget-failed"
+            out["forgotten"] = forgotten
+            out["ok"] = forgotten is not None
         return out
-    res = client.call("knowledge.ingest", {"title": p["title"], "chunks": p["chunks"], "scope": out["scope"],
-                                           "source": p["source"]}, timeout=60.0)
+    args = {"title": p["title"], "chunks": p["chunks"], "source": p["source"]}
+    if replace:
+        out["replace"] = "replaced"
+        args.update(scope=p["scope"], replace_source=True, source_rev=p["tree_hash"])
+        if p.get("observed_at"):
+            args["observed_at"] = p["observed_at"]
+    else:
+        out["replace"] = "unavailable"
+        out["scope"] = f"{p['scope']}/rev:{p['tree_hash']}"
+        args["scope"] = out["scope"]
+    res = client.call("knowledge.ingest", args, timeout=60.0)
     out["ingested"] = res is not None
     if res is None:
         out["reason"] = "estate knowledge.ingest failed or estate is unreachable"
     return out
 
 
+def materialize(repo: Path, ref: str, dest: Path) -> None:
+    """Copy ``.wicked/knowledge/`` as it is at git ``ref`` (e.g. ``origin/main``: what MERGED) into
+    ``dest``, so the index reads the merged tree, never the checkout's working copy."""
+    listing = subprocess.run(["git", "-C", str(repo), "ls-tree", "-r", "-z", "--name-only", ref, "--", ".wicked/knowledge"],
+                             capture_output=True, timeout=30)
+    if listing.returncode != 0:
+        raise RuntimeError(f"git ls-tree {ref} failed: {listing.stderr.decode('utf-8', 'replace').strip()[:200]}")
+    for rel in filter(None, listing.stdout.decode("utf-8", "replace").split("\0")):
+        blob = subprocess.run(["git", "-C", str(repo), "show", f"{ref}:{rel}"], capture_output=True, timeout=30)
+        if blob.returncode != 0:
+            raise RuntimeError(f"git show {ref}:{rel} failed")
+        target = dest / rel
+        if not target.resolve().is_relative_to(dest.resolve()):
+            raise RuntimeError(f"refusing a path outside the index root: {rel}")
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_bytes(blob.stdout)
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
     parser.add_argument("--repo", type=Path, default=Path("."))
+    parser.add_argument("--ref", help="read the knowledge at this git ref (e.g. origin/main) instead of the working tree")
     parser.add_argument("--name", help="the repository name in the scope (default: origin's name, else the directory)")
     parser.add_argument("--slug")
     parser.add_argument("--dry-run", action="store_true", help="print what would be indexed; touch no store")
@@ -123,13 +157,27 @@ def main(argv: list[str] | None = None) -> int:
                           "learned knowledge is indexed from the merged default branch (DES-learn-workflow §4.2)"}))
         return 2
     name = args.name or repo_name(repo)
+    if args.ref:
+        import tempfile
+        with tempfile.TemporaryDirectory(prefix="learn-index-") as tmp:
+            try:
+                materialize(repo, args.ref, Path(tmp))
+            except (RuntimeError, OSError, subprocess.SubprocessError) as e:
+                print(json.dumps({"ok": False, "repo": name, "reason": str(e)}))
+                return 1
+            return _run(client, Path(tmp), name, args)
+    return _run(client, repo, name, args)
+
+
+def _run(client, repo: Path, name: str, args) -> int:
     payloads = [topic_payload(repo, name, d) for d in topic_dirs(repo, args.slug)]
     if args.dry_run:
         print(json.dumps({"ok": True, "repo": name, "dry_run": True,
                           "topics": [{k: v for k, v in p.items() if k != "chunks"} | {"chunks": len(p["chunks"])} for p in payloads]}, indent=2))
         return 0
-    results = [index_topic(client, p) for p in payloads]
-    ok = all(r.get("ingested") or (not r["chunks"] and "read_errors" not in r) for r in results)
+    tools = client.list_tools()
+    results = [index_topic(client, p, tools) for p in payloads]
+    ok = all(r.get("ingested") or (not r["chunks"] and "read_errors" not in r and r.get("ok", True)) for r in results)
     print(json.dumps({"ok": ok, "repo": name, "topics": results}, indent=2))
     return 0 if ok else 1
 

package/scripts/mem/estate_memory.py

@@ -135,15 +135,11 @@ def _default_intent():
     (the umbrella, e.g. ``wicked`` for ``wicked/wicked-estate``). Outside a git
     checkout: {} (unfaceted memories only, as before).
     """
-    try:
-        here = Path.cwd().resolve()
-    except OSError:
+    root = _estate_client.checkout_root()
+    if root is None:
         return {}
-    for d in (here, *here.parents):
-        if (d / ".git").exists():
-            project = (os.environ.get("WICKED_RUN_PROJECT") or "").strip() or d.parent.name
-            return {k: v for k, v in (("repo", d.name), ("project", project)) if v}
-    return {}
+    project = (os.environ.get("WICKED_RUN_PROJECT") or "").strip() or root.parent.name
+    return {k: v for k, v in (("repo", root.name), ("project", project)) if v}
 
 
 def _memory_recall_args(args, query, budget):
@@ -209,11 +205,21 @@ def _parse_budget(args):
 # narration and status never reach the store even when the judgment slips.
 MIN_CONTENT_CHARS = 40
 _HEX_RUN = re.compile(r"\b[0-9a-f]{7,40}\b")
+# A hex run is a commit id when it is long (>= 12) or sits in commit context; a short one
+# alone (a CRC32 polynomial, a colour) is a constant, and constants are durable.
+_COMMIT_CONTEXT = re.compile(
+    r"\b(?:commit|sha|rev(?:ision)?|cherry-?pick(?:ed)?|revert(?:ed)?|fixed in|landed in|merged as"
+    r"|pin(?:ned)?(?: moved)? (?:to|at))\b|@[0-9a-f]{7}", re.I)
+# A version is narration only next to release status ("released 2.4.1", "shipped 0.7.26"); a
+# version constraint ("keep SQLite >= 3.35.0 because RETURNING") is a durable rule.
+_VERSION = re.compile(r"(?<![\w.])v?\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.]+)?(?![.\d])")
+_RELEASE_STATUS = re.compile(
+    r"\b(?:released|shipped|published|tagged|cut|bumped|landed|merged|deployed|rolled out"
+    r"|upgraded to|is out|went out|now on)\b", re.I)
 _NON_DURABLE = (
     (re.compile(r"\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b", re.I),
      "a run/session id (uuid)"),
     # x.y.z, but not a dotted quad (127.0.0.1) or a longer dotted run.
-    (re.compile(r"(?<![\w.])v?\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.]+)?(?![.\d])"), "a version number"),
     # PR #12 / issue #12 / run 38093054271 / core#880 / a bare #880 — not "run 3 retries".
     (re.compile(r"\b(?:pr|pull request|issue|run|job)\s*(?:#\s*\d+|\d{5,})\b"
                 r"|\b[a-z][\w.-]*#\d+\b|(?<![\w&])#\d+\b", re.I), "a PR/issue/run id"),
@@ -235,7 +241,8 @@ def _is_sha(token):
 def durability_rejects(content):
     """Why ``content`` is not a durable learning ([] = it may be stored).
 
-    Deterministic and offline: empty or too-short bodies, commit SHAs, versions,
+    Deterministic and offline: empty or too-short bodies, commit SHAs (long, or
+    in commit context), versions next to release status,
     PR/issue/run ids, PIDs, "today"-style dates, and first-person narration
     ("I'll retry", "going to guess again") are records of a moment; the repo,
     CHANGELOG or tracker already holds those.
@@ -245,8 +252,11 @@ def durability_rejects(content):
         return [f"too short to state a rule, why it holds and when it applies "
                 f"(< {MIN_CONTENT_CHARS} chars)"]
     reasons = []
-    if any(_is_sha(m.group(0)) for m in _HEX_RUN.finditer(text.lower())):
+    shas = [m.group(0) for m in _HEX_RUN.finditer(text.lower()) if _is_sha(m.group(0))]
+    if any(len(h) >= 12 for h in shas) or (shas and _COMMIT_CONTEXT.search(text)):
         reasons.append("a commit SHA")
+    if _VERSION.search(text) and _RELEASE_STATUS.search(text):
+        reasons.append("release status (a version that was shipped/released)")
     reasons += [why for rx, why in _NON_DURABLE if rx.search(text)]
     return reasons
 

package/skills/mem/SKILL.md

@@ -85,7 +85,8 @@ A chat seat asked by wicked-crew to label the operator's decisions reads
 1. Apply the durability test: *would this help a fresh session, on a
    different task, three months from now?* Store a rule, why it holds, and
    when it applies, in 1–3 self-contained sentences. Never store progress or
-   status, versions, SHAs, PR/run ids, PIDs, "today", or what the repo,
+   status, release versions ("shipped 2.4.1"), commit SHAs, PR/run ids, PIDs,
+   "today", or what the repo,
    CHANGELOG or tracker already records. The backend refuses the mechanical
    cases with `not a durable learning`; treat that as "don't store", not as
    an error to work around.

package/skills/mem-capture/SKILL.md

@@ -47,11 +47,14 @@ Reject, and do not rephrase into something that sneaks past:
 
 - progress and status: what you did, are doing or will do ("I'll retry",
   "going to try again", "shipped", "merged", "now green");
-- versions, commit SHAs, PR / issue / run ids, PIDs, ports picked by hand,
+- release versions ("shipped 2.4.1"), commit SHAs, PR / issue / run ids, PIDs,
+  ports picked by hand,
   and anything dated ("today", "this morning");
 - anything the repo, its CHANGELOG or the tracker already records.
 
-The backend refuses the mechanical cases (ids, versions, SHAs, PIDs, "today",
+A version *constraint* ("needs SQLite >= 3.35.0 because …") and a fixed constant
+(a CRC polynomial, a colour) are durable; keep them.
+The backend refuses the mechanical cases (ids, release versions, commit SHAs, PIDs, "today",
 first-person narration, bodies under 40 characters) with
 `not a durable learning`. A refusal means the candidate failed the test:
 drop it, unless it holds a real rule you can state without the moment.

package/skills/repo-learn/SKILL.md

@@ -138,9 +138,12 @@ when the proposal is approved, so the learning is lost):
 - **Knowledge** — how the code works, read from the code (*acquired*, so it is
   knowledge, not memory: DES-memory-vs-knowledge). `kind_type: "knowledge"`; payload
   `{"content": "<1–3 sentences>", "class": "concept", "source": "<repo>:<path>",
-  "source_rev": "<commit sha>"}`. Most repo-learn findings are this kind. Never
-  propose a graph metric (PageRank rank, churn count, blast-radius size): estate's
-  tools re-derive those on demand.
+  "source_rev": "<commit sha>"}`. Most repo-learn findings are this kind. **Not
+  submittable yet:** estate cannot approve a knowledge proposal until its knowledge
+  proposal type ships, so the shim refuses `kind_type: "knowledge"`. List these objects
+  in your report's fenced `json` block under `knowledge (pending)` and leave them out
+  of the `wicked-capture-report` counts. Never propose a graph metric (PageRank rank,
+  churn count, blast-radius size): estate's tools re-derive those on demand.
 - **Memory** — only something *witnessed* while studying (a gotcha you hit, with
   why) or *told* by the operator. Split a mixed finding: "we chose fail-closed
   because of incident X" is memory, "the implementation fails closed" is

package/skills/repo-learn/refs/capture-proposals.md

@@ -71,7 +71,14 @@ estate/steering types — pick the one the rule governs, not a freeform tag.
 ## Knowledge payload (code facts: the usual case)
 
 What you learn by reading code is **acquired**, so it is knowledge, not memory
-(DES-memory-vs-knowledge §3). Propose it as:
+(DES-memory-vs-knowledge §3).
+
+**Not submittable yet.** Estate's `proposal.approve` promotes only `memory` and
+`policy:*`; a knowledge proposal would sit unapprovable in the queue, so the shim
+refuses `kind_type: "knowledge"` (`-32602`) until estate's knowledge proposal type
+ships. Until then, put each object below in your report's fenced `json` block under
+`knowledge (pending)`, and leave them out of the `wicked-capture-report` counts. Do
+not re-file a code fact as a `memory` to get it through. The shape is:
 
 ```json
 {
@@ -120,7 +127,8 @@ implementation fails closed" is knowledge.
   `WICKED_RUN_PROJECT` supplies it.
 - `content` must pass the durability test: a rule, why it holds, and when it
   applies, useful to a fresh session on a different task months from now. No
-  versions, SHAs, PR/run ids or progress notes.
+  release-status versions ("shipped 2.4.1"), commit SHAs, PR/run ids or progress
+  notes. A version *constraint* ("needs SQLite >= 3.35.0 because …") is fine.
 
 ## Policy payload + facets