wicked-garden 12.48.0 → 12.50.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": 136,
+    "skills": 138,
     "fork_skills": 69,
     "hooks": 13,
     "specialists": 7
@@ -24,6 +24,7 @@
     "domain-extractor": ["domain-extractor"],
     "domain-modeler": ["domain-modeler"],
     "draft": ["draft"],
+    "editor-scaffold": ["editor-scaffold"],
     "engineering": ["architecture", "backend", "debugging", "docs", "engineering", "frontend", "integration", "large-scale-migration", "patch", "system-design", "unit-test-quality"],
     "engineering-api-documentarian": ["engineering-api-documentarian"],
     "engineering-migration-engineer": ["engineering-migration-engineer"],
@@ -33,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, real multi-model second opinions. 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.48.0"}], "version": "12.48.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.50.0"}], "version": "12.50.0"}

package/.claude-plugin/plugin.json

@@ -1,9 +1,9 @@
 {
   "name": "wicked-garden",
-  "version": "12.48.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), real multi-model second opinions (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.",
+  "version": "12.50.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.4.0",
+  "wicked_ledger_version": "^0.6.0",
   "wicked_bus_version": "^2.0.0",
   "author": {
     "name": "Mike Parcewski",

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [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).**
+
+## [12.49.0] — 2026-10-11
+
+### Added
+- **`wicked-garden-editor-scaffold`: build, check and install an artifact editor plugin (X3, PR #1269).** A new skill plus `scripts/editor/`.
+- **Inventory-report codebook (crew#721, PR #1266).** An enumerating step says whether its list is complete.
+
+### Fixed
+- **QE acceptance inside a governed crew run records into the run's ledger, not the worktree (wicked-crew#951, PR #1270).** When `WICKED_QE_LEDGER_DIR` is set, it is the ledger root. A governed run hands its QE unit the run's own ledger, outside the worktree, this way.
+  - The preflight config check, setup's scaffold and `config.json`, accept's evidence dir, the executor and reviewer briefs, and the vault-record argument all use that root.
+  - accept resolves it through wicked-ledger's `resolveLedgerRoot`.
+  - Before, a governed `qe accept` wrote `<worktree>/.wicked-qe`; the run's guard discarded it, the PASS with it, and delivery was refused.
+
+### Changed
+- **`wicked_ledger_version` is `^0.6.0`** (PR #1270): `resolveLedgerRoot` honours `WICKED_QE_LEDGER_DIR`. The QE runner requires wicked-ledger `^0.5.0` (PR #1267).
+- Docs: guidance and the site say what ships, and what blocks vs what advises (PR #1265). Python 3.15 (PR #1268).
+
 ## [12.48.0] — 2026-10-09
 
 ### Added

package/README.md

@@ -32,11 +32,11 @@ Most plugins try to boss them around — re-implement planning, impose a workflo
 | refactors on a hope and a prayer | renames across files as a **graph operation**, not find-replace roulette → wicked-patch |
 | forgets everything at `exit` | remembers what session 1 decided when you're in session 47 → the mem domain over wicked-estate |
 | re-derives *how to work in this repo* every task — which file owns the bug, the wiring step, the test command | loads the repo's own playbooks (`fix-bug`/`add-feature`/`verify`…), generated from HEAD → wicked-understanding |
-| asks *itself* for a second opinion | convenes a **real multi-model panel** (Antigravity / Codex / …) → the jam skill's `council` action |
+| asks *itself* for a second opinion | convenes a **review panel** → the jam skill's `council` action: usable external CLIs (Antigravity / Codex / …) take the seats; with fewer than two it fills them with isolated same-family workers and **labels them as weaker diversity**, and below two isolated seats it reports *no quorum* instead of synthesizing |
 | re-derives WCAG/CWE/SOC2 from memory every time | loads the rubric on demand, ships it to any repo |
-| grades its own homework | author ≠ executor ≠ reviewer → evidence-gated testing |
+| grades its own homework | author ≠ executor ≠ reviewer as separate workers → evidence-gated testing (the `qe` domain) |
 
-The throughline: **done is re-derived, not asserted.** Verdicts you can trust on the first read — not green checkmarks you can't.
+The throughline: **done is re-derived, not asserted** — wherever the gate actually runs. Which entry paths block and which only advise is spelled out in [What blocks, what advises](#what-blocks-what-advises).
 
 ## What it's *not*
 
@@ -106,14 +106,14 @@ Optional, lights up the code graph: **wicked-estate** (single binary; `wicked-es
 ## Try it
 
 ```bash
-# Just work — the hook applies the right rigor underneath, quietly
+# Just work — in Claude Code the plugin's hook reads the work's shape and suggests the rigor (advisory)
 "implement caching for the dashboard"
 
 # Or reach for a gap-filler on purpose — everything is a skill now
 /wicked-garden-prove                              # re-derive "done" from evidence (fail-closed)
 /wicked-garden-search blast-radius emit_event     # impact, incl. edges grep can't see
 /wicked-garden-engineering-patch rename oldField newField  # deterministic, graph-driven
-/wicked-garden-jam council "redis or memcached?"  # a panel that isn't just you
+/wicked-garden-jam council "redis or memcached?"  # a panel; it says which seats were external models
 
 # Stamp the evidence gate into ANY repo (runs with no wicked-garden installed)
 /wicked-garden-prove compile ~/path/to/repo --trigger ci
@@ -121,6 +121,24 @@ Optional, lights up the code graph: **wicked-estate** (single binary; `wicked-es
 
 ---
 
+## What blocks, what advises
+
+"Done is re-derived" is a property of the **gate**, not of every surface the toolkit touches. What a
+false "done" runs into depends on the host and the entry path:
+
+| Host · entry path | Blocks | Only advises |
+|---|---|---|
+| **Any host — the gate, invoked** (`wicked-garden-prove`, an archetype's produces-gate → `scripts/qe/vault_gate.py`) | Re-hashes the recorded evidence and re-runs its verifier through `wicked-vault`: a false claim is **rejected**, an unresolvable backend **fails closed** (`gate: "unavailable"`). Hard gates also need an attestation under an explicit `--actor` that differs from the author's — a local label, not an authenticated identity. The verdict stops whatever acts on it. | With `--no-require`, a backend that cannot run falls back to the claim-only tracker and says so (`claim-only`, not re-derived); a working backend still re-derives. |
+| **Claude Code — plugin hooks** (plain conversation, "just work") | `PreToolUse` denies a few specific tool calls: native `EnterPlanMode` (always — planning goes through the archetype playbooks), writes to `MEMORY.md` / the auto-memory dir, build-phase writes on a high-complexity crew project with no challenge artifacts, a `phase_manager.py approve` whose gate preflight fails, a worktree cwd leak, and — only in `strict` mode (default `warn`) — invalid task metadata (`WG_TASK_METADATA`) and orphan state writes (`WG_BUS_EMIT_LINT`). Prompts are held until `/wicked-garden-core setup` completes. | Everything else. The archetype detector **steers** (it does not gate), the Stop-time claim sentinel is a fail-open **nudge** when a "done/passing" claim has no verdict for HEAD, `TaskCompleted` never blocks, and output governance is advisory. A completion claim is **not** blocked unless a gate is run. |
+| **Codex · OpenCode · Pi · Antigravity — skills only** (`npx wicked-installer install-<cli> wicked-garden`) | Nothing by itself: no plugin hooks are installed on those hosts. | The skill text tells the agent to run the gate; it blocks only when the agent does run it (and the launcher + `wicked-vault` are present). |
+| **Compiled repo gate** (`/wicked-garden-prove compile <repo> --trigger hook,ci`) | `.wicked/gate.py` fails the **git pre-push hook / CI job** it is wired into, with no wicked-garden installed. | Without a trigger it is a script you run by hand. |
+| **wicked-crew governed run** | crew's engine decides each gated phase deny-dominates, on the layers that actually ran — deterministic floors, repo checks, policies, a judge. Review moves to a distinct seat when the roster has an eligible one; team runs refuse without one. | An ordinary run on a too-small roster keeps review on the creator seat and labels it "evaluator ≠ creator not held"; a pinned floor with no distinct judge is labelled "floor only"; a phase nothing gated is "approved by default, not verified". |
+
+Garden's own daemon `/council` endpoint is a single-model synthesis (v0.1); the multi-model panel is
+the jam skill's `council` action above.
+
+---
+
 ## Build on it
 
 The catalog is open: ship your own domain pack — a `wicked-pack.json`
@@ -141,7 +159,7 @@ Full author guide: [`docs/extending.md`](docs/extending.md).
 ## Principles
 
 - **Don't fight the harness.** Fill the gaps; never re-implement what it already does well.
-- **Done is re-derived, not asserted.** Every gate recomputes the evidence; the gates that matter are signed by someone who isn't the author.
+- **Done is re-derived, not asserted.** Every gate recomputes the evidence; the gates that matter need an attestation recorded under an actor other than the author (a declared label, not an authenticated identity).
 - **Steering, not blocking.** Rigor follows the shape of the work, applied only where it earns its keep.
 - **Enforcement that travels.** The gate compiles into any repo and runs without wicked-garden present.
 - **Borrow the harness's primitives.** Extend `TaskCreate`/`Task()`/skills/hooks — don't rebuild them.

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/docs/extending.md

@@ -97,6 +97,16 @@ Manifest `spec: 2` keeps every spec-1 field and adds two arrays. A spec-1 pack s
 wicked-studio and first-party blocks are core presets. Example (garden's own spec-2 fixture):
 [`tests/fixtures/packs/acme-terms/`](../tests/fixtures/packs/acme-terms/).
 
+**Building an editor-only pack.** The `wicked-garden-editor-scaffold` skill writes one
+(`scripts/editor/scaffold.py`), from a template that already speaks `wicked.editor/1`; `scripts/editor/pin.py`
+re-pins the entry hash after each edit; `scripts/editor/conformance.py` runs the plugin's conformance
+cases in headless Chromium inside studio's own conformance host page; and `scripts/editor/install.py`
+stages the pack under `~/.wicked/editors/<name>/current/` and installs it into a wicked-crew daemon,
+which re-runs `pack check` and the conformance cases itself before it records the editor (fail closed:
+no headless browser is a refusal). A pack that also ships skills or blocks is not installable yet: their
+own approval step is still to come. The governed route is the `editor-plugin` workflow (studio
+Settings → Developer → Create an editor plugin).
+
 ## Validate: the shipped conformance gate
 
 ```bash

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.48.0",
+  "version": "12.50.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}