wicked-garden 12.51.1 → 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.1"}], "version": "12.51.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.52.0"}], "version": "12.52.0"}

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-garden",
-  "version": "12.51.1",
+  "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,14 @@
 
 ## [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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-garden",
-  "version": "12.51.1",
+  "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/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