wicked-garden 12.49.0 → 12.51.0

package/.claude-plugin/components.json

@@ -2,7 +2,7 @@
   "_comment": "Issue #328: Component declarations for wicked-garden plugin. Claude Code plugin.json does not yet support inline component declarations beyond path overrides. This manifest documents all components for tooling, validation, and future schema support. When plugin.json gains a 'components' field, merge this data into plugin.json. The plugin is skills-only: former commands/ became actions of consolidated per-domain skills, and former agents/ became standalone context:fork worker skills (enumerated under fork_skills). Regenerate derived blocks with scripts/ci/sync_components.py.",
   "domains": ["agentic", "crew", "data", "demo", "engineering", "jam", "mem", "persona", "platform", "product", "qe", "search"],
   "summary": {
-    "skills": 137,
+    "skills": 138,
     "fork_skills": 69,
     "hooks": 13,
     "specialists": 7
@@ -34,6 +34,7 @@
     "jam": ["jam"],
     "jam-brainstorm-facilitator": ["jam-brainstorm-facilitator"],
     "jam-council": ["jam-council"],
+    "learn": ["learn"],
     "mcp": ["mcp"],
     "mcp-scaffold": ["mcp-scaffold"],
     "mem": ["mem"],

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.49.0"}], "version": "12.49.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.51.0"}], "version": "12.51.0"}

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-garden",
-  "version": "12.49.0",
+  "version": "12.51.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,30 @@
 
 ## [Unreleased]
 
+## [12.51.0] — 2026-10-11
+
+### Fixed
+- **`wicked-garden-qe` setup scaffolds the ledger root with Python (wicked-core#881, wicked-crew#951, PR #1277).** It no longer uses a shell `mkdir` of `$WICKED_QE_LEDGER_DIR`. A governed run's write fence judges a shell write target as written, and the unexpanded variable read as a path inside the worktree, so a governed QE unit's scaffold was refused (rig run 46fb2c04). With wicked-core#889 (core-ts 0.9.2), the QE unit runs garden's pipeline into its own roots.
+
+
+## [12.50.0] — 2026-10-11
+
+### Added
+- **`wicked-garden-learn`: learn a topic or an event into the repository as cited knowledge (PR #1273).** It is the skill behind the `learn` workflow. The run scopes, researches with sources, synthesizes a claims ledger, walks the operator through it in chat, and authors `.wicked/knowledge/<slug>/` plus text-only skills.
+  - Every claim carries its source URL and `observed_at`.
+  - A refresh proposes only changes (confirm, supersede, contradict, retire) and never deletes.
+  - `scripts/learn/check.py` is the deterministic provenance and skill lint.
+  - `scripts/learn/index.py` replaces a topic's estate knowledge scope from merged content, and refuses inside a governed run.
+
+### Changed
+- **The estate client follows estate's paging cursor to the whole answer (estate#279, PR #1272).**
+- **Memory creation keeps learnings, not narration (w9-memfix, PR #1274).**
+  - The Stop hook's regex fact extraction and its auto-memorize drain are removed: `scripts/mem/session_fact_extractor.py`, `scripts/mem/auto_memorize.py`, and the `wicked.garden.fact.extracted` event. They filed about 333 sentence fragments as semantic facts.
+  - `pre_compact` saves a working memory only when tasks are in progress, always scoped `project:<cwd-basename>` (it wrote one empty, unscoped "WIP snapshot" per compaction).
+  - Memory recall (`recall`, `sources`, the hooks' context backend) defaults to the current project and its ancestors; every scope is the explicit `scope_prefix: ""` opt-in. `recall`/`sources` pass the repo intent, so faceted repo-learn memories are reachable, and `sources` labels every item `memory · <kind> · <date> · <scope>` or `knowledge · src <source>`.
+  - `store` / `capture-batch` refuse non-durable content (SHAs, versions, PR/run ids, PIDs, "today", first-person narration, under 40 chars) and source-cited claims (knowledge: use `write`). mem-capture and mem store apply the durability and told/witnessed/decided tests; the event → episode row is gone.
+  - Shim proposals need `facets.project`; repo-learn proposes code facts as `kind_type: "knowledge"` (`content, class, source, source_rev`) and never graph metrics.
+
 ## [12.49.0] — 2026-10-11
 
 ### Added

package/WICKED_GARDEN_BUS_EVENTS.md

@@ -85,12 +85,6 @@ These fields are **stripped automatically** by `_bus.py` before emission:
 |------------|-----------|-------------|
 | `wicked.garden.quality.drift_detected` | `delivery.telemetry` | Cross-session quality metric drifted past baseline threshold (special-cause or >=15% drop) |
 
-### Facts
-
-| Event Type | Subdomain | Description |
-|------------|-----------|-------------|
-| `wicked.garden.fact.extracted` | `facts` | Structured fact extracted from conversation (consumed by the garden-run auto-memorize drain -> estate memory) |
-
 ### Gate
 
 | Event Type | Subdomain | Description |

package/hooks/scripts/pre_compact.py

@@ -5,10 +5,9 @@ PreCompact hook — wicked-garden WIP snapshot before context compression.
 v6: the v5 ticket-rail preservation path (HistoryCondenser + PressureTracker)
 was removed with smaht/v2 in #428. The remaining jobs are:
 1. Stamp SessionState.last_compact_ts (dedup guard)
-2. Save a lightweight WIP memory to the context backend (wicked-estate
-   memory.capture) using SessionState + native in-progress task subjects
-   as the input
-3. Prompt Claude to store any additional memories before context is lost
+2. Save the native in-progress task subjects as a project-scoped working
+   memory (wicked-estate memory.capture), only when there are any
+3. Prompt Claude to store any durable learning before context is lost
 
 Always fails open — any unhandled exception returns {"continue": true}.
 """
@@ -17,7 +16,6 @@ import json
 import os
 import sys
 import time
-import uuid as _uuid_mod
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -62,65 +60,44 @@ def _read_in_progress_tasks(session_id, limit=10):
         return []
 
 
-def _build_wip_markdown(session_state_dict, in_progress):
-    """Format lightweight WIP state as markdown, capped at _MAX_WIP_CHARS."""
+def _build_wip_markdown(active_project, in_progress):
+    """Format the in-progress task state as markdown, capped at _MAX_WIP_CHARS."""
     sections = ["## WIP State (Pre-Compaction)"]
-
-    active_project = session_state_dict.get("active_project") or ""
     if active_project:
         sections.append(f"### Active Project\n{active_project}")
-
-    turn_count = session_state_dict.get("turn_count")
-    if turn_count:
-        sections.append(f"### Turn Count\n{turn_count}")
-
-    if in_progress:
-        items = "\n".join(f"- {s}" for s in in_progress)
-        sections.append(f"### In-Progress Tasks\n{items}")
-
+    items = "\n".join(f"- {s}" for s in in_progress)
+    sections.append(f"### In-Progress Tasks\n{items}")
     content = "\n\n".join(sections)
     if len(content) > _MAX_WIP_CHARS:
         content = content[:_MAX_WIP_CHARS - 3] + "..."
     return content
 
 
-def _save_wip_state(session_id, project):
-    """Save a lightweight WIP memory to the routed context backend.
+def _save_wip_state(session_id):
+    """Save the in-progress task state as a project-scoped working memory.
 
-    v6: no HistoryCondenser ticket rail. Input is SessionState + native
-    in-progress task subjects. The richer v5 snapshot (decisions, file scope,
-    open questions) is gone. S4: the write routes through
-    _context_backend.capture_memory (estate primary).
+    Writes nothing unless the session has real in-progress tasks: a turn count
+    or an active-project name alone is not state worth restoring (that wrote
+    one empty "WIP snapshot" per compaction). The write goes through
+    _context_backend.capture_memory, which always scopes it to the current
+    project; estate expires working memories after 24 h.
+    Returns the memory id, or None when nothing was written.
     """
+    in_progress = [t for t in _read_in_progress_tasks(session_id, limit=10) if str(t).strip()]
+    if not in_progress:
+        _log("context", "debug", "pre_compact.no_wip")
+        return None
+
+    active_project = ""
     try:
         from _session import SessionState
-        state = SessionState.load()
+        active_project = getattr(SessionState.load(), "active_project", "") or ""
     except Exception:
-        state = None
+        pass
 
-    ss_fields = {}
-    if state:
-        ss_fields = {
-            "active_project": getattr(state, "active_project", ""),
-            "active_project_id": getattr(state, "active_project_id", ""),
-            "turn_count": getattr(state, "turn_count", 0),
-            "failure_counts": getattr(state, "failure_counts", None),
-            "bash_count": getattr(state, "bash_count", 0),
-        }
-
-    in_progress = _read_in_progress_tasks(session_id, limit=10)
-
-    # Nothing to save if we have no signal at all
-    if not any(ss_fields.values()) and not in_progress:
-        _log("context", "debug", "pre_compact.empty_wip")
-        return
-
-    content = _build_wip_markdown(ss_fields, in_progress)
-    active_project = ss_fields.get("active_project") or ""
+    content = _build_wip_markdown(active_project, in_progress)
     title = f"WIP: {active_project or 'Session work'} — pre-compaction snapshot"
-
     try:
-        # Estate memory.capture via the context backend.
         from _context_backend import capture_memory
         chunk_id = capture_memory(
             title=title,
@@ -131,8 +108,10 @@ def _save_wip_state(session_id, project):
         if chunk_id:
             _log("context", "verbose", "pre_compact.wip_saved", ok=True,
                  detail={"title": title[:60], "chars": len(content)})
+        return chunk_id
     except Exception as e:
         print(f"[wicked-garden] pre_compact WIP save error: {e}", file=sys.stderr)
+        return None
 
 
 def main():
@@ -148,8 +127,7 @@ def main():
     # Normal-level log fires regardless of log level (AC-07)
     _log("context", "normal", "pre_compact")
 
-    session_id = os.environ.get("CLAUDE_SESSION_ID") or f"sess_{_uuid_mod.uuid4().hex[:8]}"
-    project = os.environ.get("CLAUDE_PROJECT_NAME") or Path.cwd().name
+    session_id = input_data.get("session_id") or os.environ.get("CLAUDE_SESSION_ID") or ""
 
     # Dedup guard: skip WIP save if compaction happened <60s ago
     skip_wip = False
@@ -169,9 +147,10 @@ def main():
     except Exception:
         state = None
 
-    # Save structured WIP state (unless dedup guard triggered)
+    # Save the in-progress task state (unless dedup guard triggered)
+    saved = None
     if not skip_wip:
-        _save_wip_state(session_id, project)
+        saved = _save_wip_state(session_id)
 
     # v6: PressureTracker was deleted with smaht/v2 in #428. There is no
     # cumulative-byte pressure model to reset — the pull-model architecture
@@ -199,9 +178,9 @@ def main():
     print(json.dumps({
         "continue": True,
         "systemMessage": (
-            "[Memory] Context compression imminent. WIP state has been auto-saved. "
-            "After compaction, your WIP will be automatically restored on the next prompt. "
-            f"Store any additional decisions or patterns NOW with {_mem_target}."
+            "[Memory] Context compression imminent. "
+            + ("In-progress task state was saved as a working memory. " if saved else "")
+            + f"Store any durable decision or gotcha NOW with {_mem_target}."
         ),
     }))
 

package/hooks/scripts/stop.py

@@ -2,15 +2,17 @@
 """
 Stop hook — wicked-garden unified session teardown (async, 30s timeout).
 
-Consolidates: crew stop, mem stop, session-end fact emission.
+Consolidates: crew stop, mem stop.
+
+The hook writes no memories: what a session learned is captured on purpose
+(the wicked-garden-mem skill's capture/store actions), never pattern-matched
+out of the transcript.
 
 Flow:
 1. Session outcome check (mismatch report from auto_issue_reporter state)
-2. Automatic memory promotion from native tasks (session_fact_extractor)
-   + auto-memorize drain into estate memory
-3. Persist final SessionState
-4. Event store retention purge
-5. Heavy cadence teardown (telemetry + guard pipeline, once per session)
+2. Persist final SessionState
+3. Event store retention purge
+4. Heavy cadence teardown (telemetry + guard pipeline, once per session)
 
 Always fails open — any unhandled exception returns {"systemMessage": ...}.
 Runs async so it does NOT block the user on exit.
@@ -18,7 +20,6 @@ Runs async so it does NOT block the user on exit.
 
 import json
 import os
-import subprocess
 import sys
 import time
 from pathlib import Path
@@ -248,129 +249,6 @@ def _check_session_outcome() -> list:
 
 
 
-# ---------------------------------------------------------------------------
-# Step 2b: Session-end fact emission → auto-memorize drain (estate memory)
-# ---------------------------------------------------------------------------
-#
-# v6: Session facts are extracted from native Claude tasks
-# (${CLAUDE_CONFIG_DIR:-~/.claude}/tasks/{session_id}/*.json) by
-# scripts/mem/session_fact_extractor.py. This replaces the v5 smaht
-# FactExtractor/HistoryCondenser pipeline deleted in Gate 4 Phase 2 (#428).
-# Emission shape: wicked.garden.fact.extracted events on wicked-bus, drained
-# by the garden-run auto-memorize consumer (scripts/mem/auto_memorize.py),
-# which re-applies its own type/length/dedup policy.
-
-# Fact types eligible for emission — mirrors the auto-memorize policy.
-# The drain will re-check these; this pre-filter keeps bus traffic sensible.
-_EMITTABLE_FACT_TYPES = frozenset({"decision", "discovery"})
-_MIN_FACT_CONTENT_LENGTH = 15
-
-
-def _run_memory_promotion(session_id: str, transcript_path: Optional[str] = None) -> list:
-    """Emit high-value session facts as wicked.garden.fact.extracted events on wicked-bus.
-
-    Reads native task records (TaskCreate/TaskUpdate output) plus the session
-    transcript tail via scripts/mem/session_fact_extractor.py,
-    filters to decisions + discoveries over the length threshold, skips facts
-    this session already emitted (per-session ledger — Stop fires every turn),
-    and emits one event per fact. The garden-run auto-memorize consumer
-    (scripts/mem/auto_memorize.py) persists them to wicked-estate memory.
-
-    Returns a list of message strings (empty when nothing was emitted or the
-    bus is unavailable). Always fails open — exceptions are caught and logged
-    to stderr.
-    """
-    try:
-        # scripts/ is on sys.path via the hook bootstrap; mem is a package
-        # under scripts/ so the qualified import resolves without any
-        # additional sys.path manipulation.
-        from mem.session_fact_extractor import (
-            extract_session_facts,
-            filter_unemitted,
-            mark_emitted,
-        )
-        from _bus import emit_event
-
-        facts = extract_session_facts(session_id, limit=20, transcript_path=transcript_path)
-        facts = filter_unemitted(facts, session_id)
-        if not facts:
-            if os.environ.get("WICKED_DEBUG"):
-                print(
-                    f"[wicked-garden] fact emit: no promotable facts in session {session_id}",
-                    file=sys.stderr,
-                )
-            return []
-
-        emitted = 0
-        emitted_facts = []
-        for fact in facts:
-            if fact.type not in _EMITTABLE_FACT_TYPES:
-                continue
-            if len(fact.content) < _MIN_FACT_CONTENT_LENGTH:
-                continue
-            emit_event(
-                "wicked.garden.fact.extracted",
-                {
-                    "type": fact.type,
-                    "content": fact.content,
-                    "entities": list(fact.entities)[:5] if fact.entities else [],
-                    "source": fact.source or "task",
-                    "session_id": session_id,
-                },
-            )
-            emitted += 1
-            emitted_facts.append(fact)
-
-        if emitted == 0:
-            return []
-        mark_emitted(emitted_facts, session_id)
-        return [f"[Memory] Emitted {emitted} fact event(s); the auto-memorize drain persists eligible ones to estate."]
-
-    except Exception as e:
-        print(f"[wicked-garden] fact emit error: {e}", file=sys.stderr)
-        return []
-
-
-def _run_auto_memorize_drain() -> list:
-    """Drain pending fact events into estate memory (garden-run consumer).
-
-    Replaces wicked-brain's server-side auto-memorize subscriber (S7): spawns
-    scripts/mem/auto_memorize.py, which polls the durable wicked-garden-mem
-    cursor, promotes + dedups each fact, and writes via estate memory.capture.
-    A failed estate write leaves the cursor put (at-least-once — next Stop
-    retries; three failed drains dead-letter the event natively). Always fails
-    open and never blocks session end.
-    """
-    try:
-        from _bus import _check_available
-        if not _check_available():
-            return []
-    except Exception:
-        return []
-    try:
-        script = _PLUGIN_ROOT / "scripts" / "mem" / "auto_memorize.py"
-        if not script.is_file():
-            return []
-        proc = subprocess.run(
-            [sys.executable, str(script), "drain", "{}"],
-            capture_output=True, text=True, timeout=25,
-        )
-        if proc.returncode != 0 or not proc.stdout.strip():
-            return []
-        result = json.loads(proc.stdout.strip().splitlines()[-1])
-        stored = result.get("stored", 0)
-        dead = result.get("dead_lettered", 0)
-        if stored or dead:
-            msg = f"[Memory] Auto-memorized {stored} fact(s) into estate"
-            if dead:
-                msg += f"; {dead} dead-lettered (see `wicked-bus dlq list`)"
-            return [msg + "."]
-        return []
-    except Exception as e:
-        print(f"[wicked-garden] auto-memorize drain error: {e}", file=sys.stderr)
-        return []
-
-
 def _get_turn_count() -> int:
     try:
         from _session import SessionState
@@ -537,30 +415,13 @@ def main():
         # 1. Session outcome check
         outcome_messages = _check_session_outcome()
 
-        # 2b. Automatic memory promotion (fail open — never blocks session end)
-        # KEPT in stop.py per-turn — lightweight (single bus emit per fact),
-        # self-reports cleanly, and the next session's bootstrap relies on
-        # memories being current. Heavy cadence work (decay/consolidation/
-        # telemetry/guard) was extracted in v9.2.15 — see _heavy_cadence.py.
-        promotion_messages = _run_memory_promotion(
-            session_id, input_data.get("transcript_path")
-        )
-
-        # 2c. Auto-memorize drain — the garden-run consumer of the fact events
-        # (it replaced the retired wicked-brain server subscriber at S7).
-        # Durable cursor: events
-        # emitted here (or left over from earlier sessions) land in estate
-        # memory; failures redeliver next Stop.
-        drain_messages = _run_auto_memorize_drain()
-        promotion_messages = promotion_messages + drain_messages
-
-        # 4. Persist session state
+        # 2. Persist session state
         _persist_session_state()
 
-        # 5. Event store retention purge
+        # 3. Event store retention purge
         _purge_old_events()
 
-        # 6. Heavy cadence — Stop is a reliable co-primary carrier of the
+        # 4. Heavy cadence — Stop is a reliable co-primary carrier of the
         # teardown (v9.2.16, #842). SessionEnd fires on <40% of exits (~1% for
         # agents), so it can't be the sole primary. Stop fires every turn and IS
         # reliable, so it now runs the SAME heavy work, guarded by
@@ -600,24 +461,10 @@ def main():
         except Exception:
             pass
 
-        # NOTE (v9.2.15): the [Memory] reflection block was deleted.
-        #   - It had a parser bug: looked for substring "Auto-extracted " but
-        #     _run_memory_promotion emits "Emitted N fact event(s)" — so
-        #     `promoted_count` was ALWAYS 0 and only the fallback prompt-mode
-        #     branch ever fired. The "smart" branching had never executed in
-        #     production.
-        #   - _run_memory_promotion already self-reports when facts are
-        #     auto-extracted ("[Memory] Emitted N fact event(s)..."), so the
-        #     reflection's "store a memory" guidance was duplicate noise.
-        #   - The brainstorm in v9.2.15 chose Option A (delete) over Option B
-        #     (fix the parser + re-gate) because the smart branch is dead
-        #     code defending behavior no user has seen. CLAUDE.md's "Memory
-        #     Management" section already tells Claude to store decisions
-        #     (now via the wicked-garden-mem skill); an end-of-turn reminder
-        #     adds no signal.
-        # `tasks_completed_this_session` is no longer read; the variable
-        # remains in scope above for any future use without breaking the
-        # `session_state` load.
+        # The v9.2.15 [Memory] reflection block is gone (an end-of-turn
+        # "store a memory" reminder added no signal), and since w9-memfix the
+        # hook writes no memories at all. `tasks_completed_this_session` feeds
+        # only the session.end log line below.
         reflection = ""
         # for this session (post-first-Stop) — only join with separator if both
         # halves have content.
@@ -626,7 +473,7 @@ def main():
         # of the turn (avoids clobbering session_ended).
         sentinel_messages = _check_claim_sentinel(input_data)
         outgov_messages = _check_outgov_compliance(input_data)
-        prepend_messages = sentinel_messages + outgov_messages + outcome_messages + promotion_messages + consolidation_messages + telemetry_messages + guard_messages
+        prepend_messages = sentinel_messages + outgov_messages + outcome_messages + consolidation_messages + telemetry_messages + guard_messages
         if prepend_messages and reflection:
             final_message = "\n".join(prepend_messages) + "\n\n" + reflection
         elif prepend_messages:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-garden",
-  "version": "12.49.0",
+  "version": "12.51.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/_bus.py

@@ -290,12 +290,6 @@ BUS_EVENT_MAP: Dict[str, Dict[str, str]] = {
         "subdomain": "crew.yolo",
         "description": "Yolo auto-approval revoked due to scope-increase mutation (audit + observability)",
     },
-    # Garden fact stream — scripts/mem/session_fact_extractor.py → auto-memorize subscriber
-    "wicked.garden.fact.extracted": {
-        "domain": "wicked-garden",
-        "subdomain": "facts",
-        "description": "Structured fact extracted from conversation (consumed by the garden-run auto-memorize drain -> estate memory)",
-    },
     # qe integration — test-lifecycle verdict event (#549, AC-25).
     # Renamed to the wicked-bus SPEC form wicked.test.<noun>.<past-verb>
     # (was wicked.verdict.recorded). Domain stamp rebranded wicked-testing → qe
@@ -429,8 +423,6 @@ _PAYLOAD_DENY_LIST = frozenset({
 # named fields passed through the deny-list unchanged. Keep this list short and
 # justified: every entry is a deliberate carve-out auditable at review time.
 #
-# wicked.garden.fact.extracted — content is the whole point of the event. The brain
-# auto-memorize subscriber requires payload.content to produce a memory.
 # wicked.garden.dispatch.log_entry_appended — `raw_payload` is the canonical JSONL
 # bytes the projector replays into the `dispatch_log_entries` table under
 # Site 1 of the bus-cutover (#746).  Without it the projector cannot
@@ -438,7 +430,6 @@ _PAYLOAD_DENY_LIST = frozenset({
 # only ships an already-on-disk dispatch record (HMAC-signed), so payload
 # inspection here is bounded by what the orphan check already trusts.
 _PAYLOAD_ALLOW_OVERRIDES: Dict[str, frozenset] = {
-    "wicked.garden.fact.extracted": frozenset({"content"}),
     "wicked.garden.dispatch.log_entry_appended": frozenset({"raw_payload"}),
     # Site 2 of bus-cutover (#746): the consensus report and evidence emits
     # carry the canonical on-disk JSON bytes via `raw_payload` so the
@@ -656,8 +647,8 @@ def _sanitize_payload(payload: Dict[str, Any], event_type: str = "") -> Dict[str
 
     Per-event allow overrides (see _PAYLOAD_ALLOW_OVERRIDES) let specific event
     types pass named denied fields through — these are explicit, audited carve-outs
-    for events whose contract requires a denied key (e.g. wicked.garden.fact.extracted
-    must ship content to the brain auto-memorize subscriber).
+    for events whose contract requires a denied key (e.g. the dispatch log's
+    raw_payload, which the projector replays byte-for-byte).
     """
     allow = _PAYLOAD_ALLOW_OVERRIDES.get(event_type, frozenset())
     return {k: v for k, v in payload.items() if k not in _PAYLOAD_DENY_LIST or k in allow}

package/scripts/_context_backend.py

@@ -70,35 +70,29 @@ _RRF_K = 60  # standard reciprocal-rank-fusion constant
 
 
 def _memory_scope() -> str:
-    """Scope for estate memory capture/recall.
+    """Scope for estate memory capture/recall: the current project.
 
-    Default is the root scope (""): estate visibility is ancestor-visible,
-    so root-scope memories are recallable from every scoped query — and the
-    hooks' own captures round-trip. Override via WICKED_ESTATE_MEMORY_SCOPE.
+    Default ``project:<cwd-basename>`` (``_estate_client.project_scope``), so
+    no hook ever writes an unscoped memory, and recall sees this project plus
+    its ancestors (root-scoped memories included) but not other projects.
+    Override via WICKED_ESTATE_MEMORY_SCOPE.
     """
-    return os.environ.get("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()
 
 
 def _memory_scope_prefix() -> Optional[str]:
     """Subtree filter for estate memory recall (estate #98 ``scope_prefix``).
 
-    The ancestor-visible ``scope`` filter alone cannot see leaf-scoped
-    memories — the migrated brain memories live at scopes like
-    ``brain:wicked-garden/doc:<id>`` and were invisible to root recalls.
-    ``scope_prefix`` REPLACES that filter with subtree matching; the default
-    ``""`` (root subtree) sees ALL memories: root + every migrated subtree.
-
-    When the operator pinned a custom recall scope via
-    WICKED_ESTATE_MEMORY_SCOPE, honor it — return None (param omitted,
-    inheritance semantics) so the pin keeps meaning what it meant.
-    Explicit override: WICKED_ESTATE_MEMORY_SCOPE_PREFIX.
+    Default None: the param is omitted and recall uses ancestor inheritance
+    from ``_memory_scope()``. Searching other projects' memories is an
+    explicit opt-in: WICKED_ESTATE_MEMORY_SCOPE_PREFIX ("" = every memory).
     """
-    prefix = os.environ.get("WICKED_ESTATE_MEMORY_SCOPE_PREFIX")
-    if prefix is not None:
-        return prefix
-    if os.environ.get("WICKED_ESTATE_MEMORY_SCOPE"):
-        return None  # custom scope pinned — keep ancestor-visible semantics
-    return ""
+    return os.environ.get("WICKED_ESTATE_MEMORY_SCOPE_PREFIX")
 
 
 def _f(value: Any) -> float:
@@ -163,8 +157,8 @@ def _estate_search(query: str, limit: int = 10, timeout: float = 5.0) -> Optiona
     """Two-call estate retrieval. None = estate unreachable.
 
     knowledge.recall is the primary signal; memory.recall is fused in when it
-    has anything to say — with ``scope_prefix`` (estate #98) so the fusion
-    sees ALL memories, migrated ``brain:…`` subtrees included. An
+    has anything to say, scoped to the current project and its ancestors
+    (``_memory_scope``; other projects only via the explicit prefix opt-in). An
     empty-but-reachable answer is a valid [] — only a dead estate returns
     None. A memory-leg failure (e.g. an older binary rejecting
     ``scope_prefix``) degrades the fusion to knowledge-only — knowledge
@@ -218,8 +212,7 @@ def search(query: str, limit: int = 10, timeout: float = 5.0) -> List[dict]:
 def recall_memories(query: str, limit: int = 10, timeout: float = 5.0) -> List[dict]:
     """Memory-only recall (estate memory.recall).
 
-    Same subtree visibility as the fusion: ``scope_prefix`` (estate #98) so
-    migrated ``brain:…`` leaf memories are recallable here too.
+    Same visibility as the fusion: the current project and its ancestors.
     """
     if not query or not str(query).strip():
         return []