Merge commit 'af0b120d7a180920e7f46e6ca49177db4cd9731d'

# Conflicts:
#	ARCHITECTURE.md
#	STRUCTURE.md
#	crates/mc-module/src/historian.rs
#	crates/mc-module/src/lib.rs
#	crates/mc-module/src/selection.rs
#	crates/mc-module/src/transform.rs
#	crates/mc-store/src/lib.rs
#	packages/dashboard/src/components/shared/CacheTimeline.tsx
#	packages/plugin/scripts/bench-synapse-vs-local.ts
#	packages/plugin/scripts/clone-session.test.ts
#	packages/plugin/scripts/clone-session.ts
#	packages/plugin/scripts/test-synapse-embed.ts
#	packages/plugin/src/config/transform-mode.test.ts
#	packages/plugin/src/config/transform-mode.ts
#	packages/plugin/src/features/magic-context/memory/embedding-synapse.test.ts
#	packages/plugin/src/features/magic-context/memory/embedding-synapse.ts
#	packages/plugin/src/features/magic-context/migrations-v53.test.ts
#	packages/plugin/src/features/magic-context/project-embedding-registry.test.ts
#	packages/plugin/src/hooks/magic-context/compaction-marker-manager.ts
#	packages/plugin/src/hooks/magic-context/rust-mode-transform.test.ts
#	packages/plugin/src/hooks/magic-context/rust-mode-transform.ts
#	packages/plugin/src/hooks/magic-context/shadow-sender.test.ts
#	packages/plugin/src/hooks/magic-context/shadow-sender.ts
#	packages/plugin/src/hooks/magic-context/tag-messages.ts
#	packages/plugin/src/hooks/magic-context/transform-postprocess-phase.test.ts
#	packages/plugin/src/hooks/magic-context/transform-postprocess-phase.ts
#	packages/plugin/src/hooks/magic-context/transform.ts
#	packages/plugin/src/plugin/rpc-handlers.test.ts
#	packages/plugin/src/plugin/rpc-handlers.ts
#	packages/plugin/src/plugin/tool-registry.ts

Author: ualtinok

.alfonso/release-notes/v0.32.3.md

@@ -0,0 +1,14 @@
+# v0.32.3
+
+Patch release focused on prompt-cache cost around history compaction boundaries.
+
+## Cache stability
+
+- Fixed a double cache bust that occurred when the compaction boundary advanced on large sessions: the pass that moved the boundary and the following pass could serve different renderings of the summary marker, paying an avoidable full-prefix re-read (typically 100K+ tokens) on every boundary move. The marker representation is now reconciled deterministically on every pass, so a boundary move costs exactly one bust.
+- Marker rows are now written with deterministic identifiers, making retries after interrupted writes converge on the same rows instead of duplicating them.
+- Concurrent processes sharing a session (for example a TUI attached alongside a running server) now serve identical marker renderings instead of briefly diverging.
+
+## Fixes
+
+- The synthetic history head is identified structurally rather than by metadata, preventing mispositioned summary markers next to system-delivered notices.
+- Sessions without a frozen ctx_reduce availability verdict no longer render a tagged summary marker that could change once the verdict settles.

ARCHITECTURE.md

@@ -13,12 +13,13 @@ Magic Context is an `@opencode-ai/plugin` (entry `src/index.ts`) that rewrites t
 - **Runtime SQLite backend** (`src/shared/sqlite.ts`): `bun:sqlite` under Bun, `node:sqlite` (`DatabaseSync`) under Node (Pi) and Electron (Desktop). The non-Bun branch adds a savepoint-aware `transaction()` shim and `readonly`→`readOnly` mapping; otherwise identical. No native module, no prebuild.
 - **Pi parity:** `packages/pi-plugin/` mirrors OpenCode semantics, importing shared core from `@magic-context/core`. Intentional divergences are tracked in `packages/pi-plugin/PARITY.md`. Provider prefixes are translated between canonical (OpenCode) and Pi configuration models via `src/shared/harness-provider-map.ts` at configuration read/write edges to keep shared model configurations portable. Pi implements session state inheritance on branch clone forks by copying filtered tags, compartments, and pending marker states, whereas OpenCode `/fork` does not yet inherit context state.
 - **Rust module / subc integration.** A harness-agnostic Rust workspace in `crates/` re-implements the cache-stability transform and autonomous historian to run under the subconscious daemon (`subc`), communicating via the `@cortexkit/subc-client` library on the TypeScript side and wire v2 protocols on the Rust side.
+- **Experimental Rust runtime mode.** Gated by `transform_mode: "rust"`, routes the entire Magic Context transform pipeline for a project through the ck-mc Rust module over subc. The TypeScript layer serves as a coordinator that manages state sync, ordinal tracking, and Last Known Good (LKG) fallbacks.
 
 ## Layers
 
-- **Bootstrap** (`src/index.ts`): load config, register hidden agents + hooks + tools, start RPC server, dream-timer, auto-update checker; detect conflicting plugins (DCP / OMO / OpenCode auto-compaction) and disable the runtime if any is active.
-- **Adapters** (`src/plugin/`): hook wrappers, tool registry, RPC handlers, dream-timer lifecycle, per-session hook construction.
-- **Runtime** (`src/hooks/magic-context/`): the transform pipeline, postprocess phase, event/command handlers, system-prompt injection, compartment runners, decay rendering, strip-and-replay, nudges, m[0]/m[1] injection, and the shadow-transform sender (a flag-gated dev lane that mirrors transform passes to the Rust subc module using the `@cortexkit/subc-client` library, paging large cold-start state_sync seeds into batches under 512KiB to stay under transport limits).
+- **Bootstrap** (`src/index.ts`): load config, register hidden agents + hooks + tools, start RPC server, dream-timer, auto-update checker; detect conflicting plugins (DCP / OMO / OpenCode auto-compaction) and disable the runtime if any is active. Begins the boot quiet period (`packages/plugin/src/plugin/boot-quiet.ts`) to defer background maintenance, and runs asynchronous startup database opens and schema migration retries (`openDatabaseAsync`).
+- **Adapters** (`src/plugin/`): hook wrappers, tool registry, RPC handlers, dream-timer lifecycle, per-session hook construction, and the `rustToolBackends` tool-routing layer when running in Rust mode.
+- **Runtime** (`src/hooks/magic-context/`): the transform pipeline, postprocess phase, event/command handlers, system-prompt injection, compartment runners, decay rendering, strip-and-replay, nudges, m[0]/m[1] injection, and the shadow-transform sender (a flag-gated dev lane that mirrors transform passes to the Rust subc module using the `@cortexkit/subc-client` library, paging large cold-start state_sync seeds into batches under 512KiB to stay under transport limits). When `transform_mode` is set to `"rust"`, delegates execution to `rust-mode-transform.ts` which synchronizes database state via `module-state-sync.ts`, maps message ordinals via `module-wire.ts`, and falls back to LKG (Last Known Good) transform state replays via `lkg-slot.ts` and `lkg-replay.ts` on failures.
 - **Feature services** (`src/features/magic-context/`): storage, scheduler, tagger, memory, dreamer, sidekick, git-commit + message FTS indexes, unified search, overflow detection, session-project mapping and backfill, migrations, clone-state copy helpers (`src/features/magic-context/storage-clone.ts`), project identity resolution (resolves `git:<sha>` or fallback `dir:<md5-12>` identifiers, caching directory fallbacks, and utilizing a cooldown period for transient git errors).
 - **Tools** (`src/tools/`): `ctx_reduce`, `ctx_expand`, `ctx_note`, `ctx_memory`, `ctx_search`. Gating: when `memory.enabled` is false, `ctx_memory` is not registered (on Pi, it registers but refuses queries for memory-off projects), and all memory-related guidance is stripped from the system prompt.
 - **Config + shared** (`src/config/`, `src/shared/`): Zod config (deep-merge raw JSONC before validation; invalid leaves fall back to defaults with warnings, never disable the plugin). **Project-tier trust boundaries** (`src/config/project-security.ts`) strip unsafe fields from untrusted repository configs before merge — preventing escalation via `sqlite` PRAGMAs, hidden-agent reprogramming (`prompt`, `tools`), `embedding` destinations, or developer-only shadow transform settings. Project-level compaction thresholds are raise-only to prevent cloned repos from forcing extra historian cost. Also includes logger, data paths, SQLite selector, harness id, RPC transport, conflict detector, tag-transcript primitive (shared with Pi), provider-id translation map (`src/shared/harness-provider-map.ts`), and exit-abort listener coordinator (`src/shared/exit-abort-registry.ts`).
@@ -143,7 +144,7 @@ Background maintenance (V2: per-task cron scheduling). A process-wide 15-min tim
 
 ## Storage & migrations
 
-`storage-db.ts` creates the schema and runs versioned migrations (`migrations.ts`, currently v1–v52). `LATEST_SUPPORTED_VERSION` is a schema fence — it MUST be bumped with every new migration (a unit test asserts it equals the highest migration), and a stale value makes the DB refuse to open after the migration applies. Schema helpers `ensureColumn()` + `healAllNullColumns()` (defined in `storage-schema-helpers.ts` to prevent cycles between `storage-db` and `migrations`) backfill upgraded DBs even if a migration row is lost. New session-scoped tables must be added to `clearSession()`. A bulletproof `MAGIC_CONTEXT_TEST_DATA_DIR` guard keeps the test suite off the live DB (running `bun test` once migrated a live DB and fail-closed running binaries). SQLite binds must use SPREAD positional args, never the array form (`bun:sqlite` binds a lone array positionally; `node:sqlite` reads it as named params and throws). For branch forks in Pi, copy durable session state (compartments, tags, pending operations, and session metadata) to the new session via `copySessionStateForClone()` in `src/features/magic-context/storage-clone.ts`. Run this copy inside an immediate SQLite transaction, filtering and mapping message ordinals and tag composite keys to the copied branch entries, and clearing cached cache bytes to trigger fresh rematerialization.
+`storage-db.ts` creates the schema and runs versioned migrations (`migrations.ts`, currently v1–v53). `LATEST_SUPPORTED_VERSION` is a schema fence — it MUST be bumped with every new migration (a unit test asserts it equals the highest migration), and a stale value makes the DB refuse to open after the migration applies. Schema helpers `ensureColumn()` + `healAllNullColumns()` (defined in `storage-schema-helpers.ts` to prevent cycles between `storage-db` and `migrations`) backfill upgraded DBs even if a migration row is lost. New session-scoped tables must be added to `clearSession()`. A bulletproof `MAGIC_CONTEXT_TEST_DATA_DIR` guard keeps the test suite off the live DB (running `bun test` once migrated a live DB and fail-closed running binaries). SQLite binds must use SPREAD positional args, never the array form (`bun:sqlite` binds a lone array positionally; `node:sqlite` reads it as named params and throws). For branch forks in Pi, copy durable session state (compartments, tags, pending operations, and session metadata) to the new session via `copySessionStateForClone()` in `src/features/magic-context/storage-clone.ts`. Run this copy inside an immediate SQLite transaction, filtering and mapping message ordinals and tag composite keys to the copied branch entries, and clearing cached cache bytes to trigger fresh rematerialization.
 
 ## Session modes
 

STRUCTURE.md

@@ -49,17 +49,17 @@ All paths below are relative to `packages/plugin/` — the published OpenCode np
 **`src/config/`:**
 - Purpose: Parse and validate plugin configuration.
 - Contains: Config loaders, re-exports, and Zod schemas.
-- Key files: `src/config/index.ts`, `src/config/schema/magic-context.ts`, `src/config/schema/agent-overrides.ts`, `src/config/project-security.ts`
+- Key files: `src/config/index.ts`, `src/config/schema/magic-context.ts`, `src/config/schema/agent-overrides.ts`, `src/config/project-security.ts`, `src/config/transform-mode.ts`
 
 **`src/plugin/`:**
 - Purpose: Adapt internal services to OpenCode plugin interfaces.
-- Contains: Hook wrappers, tool registry setup, RPC handlers, dream-timer lifecycle, conflict-warning delivery, per-session hook construction.
-- Key files: `src/plugin/messages-transform.ts`, `src/plugin/event.ts`, `src/plugin/tool-registry.ts`, `src/plugin/hooks/create-session-hooks.ts`, `src/plugin/rpc-handlers.ts`, `src/plugin/dream-timer.ts`, `src/plugin/conflict-warning-hook.ts`
+- Contains: Hook wrappers, tool registry setup, RPC handlers, dream-timer lifecycle, conflict-warning delivery, per-session hook construction, boot quiet period enforcement, and tool backend overrides for Rust mode.
+- Key files: `src/plugin/messages-transform.ts`, `src/plugin/event.ts`, `src/plugin/tool-registry.ts`, `src/plugin/hooks/create-session-hooks.ts`, `src/plugin/rpc-handlers.ts`, `src/plugin/dream-timer.ts`, `src/plugin/conflict-warning-hook.ts`, `src/plugin/boot-quiet.ts`, `src/plugin/rust-tool-backends.ts`
 
 **`src/hooks/`:**
 - Purpose: Hold hook implementations and hook-specific helpers.
-- Contains: The `magic-context` runtime and the auto-update checker.
-- Key files: `src/hooks/magic-context/hook.ts`, `src/hooks/magic-context/transform.ts`, `src/hooks/magic-context/transform-postprocess-phase.ts`, `src/hooks/magic-context/strip-content.ts`, `src/hooks/auto-update-checker/checker.ts`
+- Contains: The `magic-context` runtime, the auto-update checker, and the Rust-mode execution adapter.
+- Key files: `src/hooks/magic-context/hook.ts`, `src/hooks/magic-context/transform.ts`, `src/hooks/magic-context/transform-postprocess-phase.ts`, `src/hooks/magic-context/strip-content.ts`, `src/hooks/auto-update-checker/checker.ts`, `src/hooks/magic-context/rust-mode-transform.ts`, `src/hooks/magic-context/module-state-sync.ts`, `src/hooks/magic-context/module-wire.ts`
 
 **`src/tui/`:**
 - Purpose: Render Magic Context sidebar and `/ctx-status` / `/ctx-recomp` dialogs inside OpenCode's TUI.
@@ -121,6 +121,7 @@ Unless specified otherwise, TypeScript paths are relative to `packages/plugin/`
 - `src/config/index.ts`: Load and merge config files with field-level fallback for invalid leaves; collect warnings rather than disable the plugin.
 - `src/config/schema/magic-context.ts`: Define defaults and schema rules.
 - `src/config/schema/agent-overrides.ts`: Define overridable built-in agents.
+- `src/config/transform-mode.ts`: Resolve transform mode (TS vs Rust) based on configuration and system capabilities.
 - `assets/magic-context.schema.json`: Generated JSON schema, kept in sync via `scripts/build-schema.ts` and `scripts/release.sh`.
 
 **Core Logic:**
@@ -133,6 +134,14 @@ Unless specified otherwise, TypeScript paths are relative to `packages/plugin/`
 - `src/hooks/magic-context/supersession-reclaim.ts`: Select superseded spent control-plane tool outputs (oldest todowrite, ctx_reduce, zero-value meta calls) and older edit/write calls for the same file under the `smart_drops` configuration flag.
 - `src/hooks/magic-context/edit-marker.ts`: Implement `edit_marker` mode to compress superseded edits, keeping the `filePath` and a region-hint prefix while dropping the bulky output content.
 - `src/hooks/magic-context/shadow-sender.ts`: Mirror finalized transform passes, inputs, and decisions to the Rust module over the subc protocol using the `@cortexkit/subc-client` library (wire v2 protocol via `SubcClient` and `RouteHandle`) under the `shadow_transform` configuration flag. Pages large cold-start state_sync seeds into batches under 512KiB to stay under transport limits.
+- `src/hooks/magic-context/rust-mode-transform.ts`: Orchestrate the experimental Rust transform mode, coordinating state sync and LKG (Last Known Good) fallback/replay logic.
+- `src/hooks/magic-context/module-state-sync.ts`: Synchronize database state (memories, commits, tags, markers) between host (TS SQLite) and subc (Rust).
+- `src/hooks/magic-context/module-wire.ts`: Translate wire messages, ordinals, and normalizations between host and Rust formats.
+- `src/hooks/magic-context/lkg-slot.ts` and `src/hooks/magic-context/lkg-replay.ts`: Capture and replay the Last Known Good (LKG) transformed state on failure/parking.
+- `src/hooks/magic-context/pass-outcome.ts`: Track the outcome of transform passes.
+- `src/hooks/magic-context/emergency-fail-closed.ts`: Handle fail-closed cases under emergency context limit situations.
+- `src/plugin/boot-quiet.ts`: Quiet background maintenance logging on startup.
+- `src/plugin/rust-tool-backends.ts`: Define overrides for tool backends (`ctx_reduce`, `ctx_memory`) when running in Rust mode.
 - `src/hooks/magic-context/inject-compartments.ts`: m[0]/m[1] history layout — `renderM0`/`renderM1`/`materializeM0`/`mustMaterialize` (mirrored in Pi's `inject-compartments-pi.ts`).
 - `src/hooks/magic-context/decay-curve.ts`: Council-validated deterministic tier-decay math (half-life, log-cost tier boundaries, budget pressure).
 - `src/hooks/magic-context/decay-render.ts`: Shared OpenCode+Pi compartment renderer built on the decay curve (replaces the removed LLM compressor).

crates/mc-module/src/decay_render.rs

@@ -367,6 +367,7 @@ pub fn extract_m0_block(m0_text: &str, tag: &str) -> Option<String> {
 mod tests {
     use super::*;
     use serde::Deserialize;
+    use sha2::{Digest, Sha256};
 
     fn comp(
         start: i64,
@@ -657,6 +658,130 @@ mod tests {
         }
     }
 
+    #[test]
+    fn redacted_store_shape_matches_ts_at_real_history_budgets() {
+        #[derive(Deserialize)]
+        struct ShapeFixture {
+            compartments: Vec<RawComp>,
+        }
+        #[derive(Deserialize)]
+        struct DifferentialCase {
+            budget: f64,
+            #[serde(rename = "tsCost")]
+            ts_cost: usize,
+            #[serde(rename = "tsTierCounts")]
+            ts_tier_counts: [usize; 5],
+            #[serde(rename = "bodySha256")]
+            body_sha256: String,
+        }
+        #[derive(Deserialize)]
+        struct DifferentialFixture {
+            cases: Vec<DifferentialCase>,
+        }
+
+        let shape: ShapeFixture =
+            serde_json::from_str(include_str!("../testdata/decay-store-shape.json"))
+                .expect("parse redacted store shape");
+        assert_eq!(
+            shape.compartments.len(),
+            388,
+            "fixture must preserve the store shape"
+        );
+        let compartments: Vec<DecayRenderCompartment> = shape
+            .compartments
+            .iter()
+            .map(|raw| DecayRenderCompartment {
+                start_message: raw.start,
+                end_message: raw.end,
+                title: raw.title.clone(),
+                content: raw.content.clone(),
+                start_date: raw.start_date.clone(),
+                end_date: raw.end_date.clone(),
+                p1: raw.p1.clone(),
+                p2: raw.p2.clone(),
+                p3: raw.p3.clone(),
+                p4: raw.p4.clone(),
+                importance: raw.importance,
+                legacy: raw.legacy,
+            })
+            .collect();
+        let differential: DifferentialFixture =
+            serde_json::from_str(include_str!("../testdata/decay-store-differential.json"))
+                .expect("parse TS differential table");
+        assert_eq!(differential.cases.len(), 4);
+
+        let mut previous_cost = None;
+        for case in &differential.cases {
+            let body = render_decayed_compartments(
+                &compartments,
+                case.budget,
+                mc_tokenizer::estimate_tokens,
+            );
+            let rust_cost = mc_tokenizer::estimate_tokens(&body);
+            assert_eq!(
+                rust_cost, case.ts_cost,
+                "token cost drift at budget {}",
+                case.budget
+            );
+            assert!(
+                rust_cost as f64 <= case.budget || body.is_empty(),
+                "render exceeded budget {} with {} tokens",
+                case.budget,
+                rust_cost
+            );
+            if let Some(previous) = previous_cost {
+                assert!(
+                    rust_cost > previous,
+                    "shrinking budget must not grow rendered cost: previous {previous}, current {rust_cost}"
+                );
+            }
+            previous_cost = Some(rust_cost);
+
+            let digest = Sha256::digest(body.as_bytes());
+            let rust_hash = digest
+                .iter()
+                .map(|byte| format!("{byte:02x}"))
+                .collect::<String>();
+            assert_eq!(
+                rust_hash, case.body_sha256,
+                "byte drift at budget {}",
+                case.budget
+            );
+
+            let sections = if body.is_empty() {
+                Vec::new()
+            } else {
+                body.split("\n\n").collect::<Vec<_>>()
+            };
+            let mut tier_counts = [0usize; 5];
+            for compartment in &compartments {
+                let heading = format!(
+                    "## {}-{}",
+                    compartment.start_message, compartment.end_message
+                );
+                let section = sections
+                    .iter()
+                    .find(|section| section.starts_with(&heading))
+                    .copied();
+                let mut selected = 5usize;
+                for tier in 1..=5u8 {
+                    if render_compartment_at_tier(compartment, tier).as_str()
+                        == section.unwrap_or("")
+                    {
+                        selected = tier as usize;
+                        break;
+                    }
+                }
+                tier_counts[selected - 1] += 1;
+            }
+            assert_eq!(
+                tier_counts, case.ts_tier_counts,
+                "tier drift at budget {}",
+                case.budget
+            );
+        }
+    }
+
     #[test]
     fn render_tight_golden_matches_reference_with_real_estimator() {
         // The budget GUARD path: these cases use budgets tight enough that the TS