@@ -3,6 +3,7 @@ use cortexkit_bus_inmemory::{InMemoryBus, InMemoryConfig};
 mod adoption_recovery;
 mod broca_0_7;
 mod broca_account_change_samples;
+mod broca_compaction_0710;
 mod broca_provider_fallback;
 mod broca_rich_ui_stamp;
 mod broca_tag_rows;
 
@@ -0,0 +1,243 @@
+//! Replay Broca's conformance captures against the 0.7.10 provider.
+use super::*;
+use sha2::{Digest, Sha256};
+
+const ROOT: &str = concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/testdata/broca-compaction-0710/"
+);
+const MANIFEST_SHA256: &str = "c679754e05680772890502cced3e0f1902bad79cce8d2f9569457e991a84c3ed";
+
+fn fixture(name: &str) -> Value {
+    serde_json::from_slice(&std::fs::read(Path::new(ROOT).join(name)).unwrap()).unwrap()
+}
+
+#[test]
+fn checksums_cover_all_31_captured_files() {
+    let manifest = std::fs::read(Path::new(ROOT).join("SHA256SUMS")).unwrap();
+    assert_eq!(format!("{:x}", Sha256::digest(&manifest)), MANIFEST_SHA256);
+    let mut listed = BTreeSet::new();
+    for line in std::str::from_utf8(&manifest).unwrap().lines() {
+        let (expected, name) = line.split_once("  ").unwrap();
+        assert!(listed.insert(name.to_owned()), "duplicate fixture: {name}");
+        let bytes = std::fs::read(Path::new(ROOT).join(name)).unwrap();
+        assert_eq!(format!("{:x}", Sha256::digest(&bytes)), expected, "{name}");
+    }
+    let present: BTreeSet<_> = std::fs::read_dir(ROOT)
+        .unwrap()
+        .map(|entry| entry.unwrap().file_name().into_string().unwrap())
+        .filter(|name| name.ends_with(".json"))
+        .collect();
+    assert_eq!(listed, present);
+    assert_eq!(listed.len(), 31);
+}
+
+fn invalid_params(outcome: HandlerOutcome) -> String {
+    match outcome {
+        HandlerOutcome::Error { code, message }
+        | HandlerOutcome::ErrorWithDetail { code, message, .. } => {
+            assert_eq!(code, "invalid_params");
+            message
+        }
+        other => panic!("expected invalid_params, got {other:?}"),
+    }
+}
+
+fn no_truncate(value: &Value) {
+    match value {
+        Value::Object(fields) => {
+            assert!(!fields.contains_key("truncate"), "{value}");
+            for child in fields.values() {
+                no_truncate(child);
+            }
+        }
+        Value::Array(values) => {
+            for child in values {
+                no_truncate(child);
+            }
+        }
+        _ => {}
+    }
+}
+
+async fn replay_case(case: &str, fetches: usize, notices: usize, models: usize) {
+    let dir = tempfile::tempdir().unwrap();
+    let setup_name = format!("{case}-setup-0.json");
+    let setup = fixture(&setup_name);
+    let params = &setup["params"];
+    let session = params["session"].as_str().unwrap();
+    let harness = params["harness"].as_str().unwrap();
+    let rig = Rig::without_setup(
+        dir.path(),
+        "broca",
+        ("runner", session),
+        (harness, session),
+        |_| {},
+    )
+    .await;
+
+    // The published Setup decoder ignores future fields, not their whole
+    // request. The captured scripted preset is not one ck-mc implements.
+    let decoded: compact::setup::SetupRequest = decode(params).unwrap();
+    assert_eq!(decoded.view_due_max_ms(), Some(30_000));
+    assert_eq!(decoded.ride_wait_max_ms, Some(120_000));
+    assert_eq!(
+        params["view_features"],
+        json!(["truncate", "tag_bytes_edits"])
+    );
+    let known = serde_json::to_value(decoded).unwrap();
+    assert!(known.get("view_features").is_none());
+    let error = invalid_params(rig.h.dispatch_value(7, setup.clone()).await);
+    assert_eq!(error, "unknown provider preset");
+    assert!(load_head(rig.h.store.get().unwrap(), &rig.reference)
+        .unwrap()
+        .is_none());
+    println!("{setup_name}: PASS decode (view_due_max_ms=30000, view_features ignored); handler REJECT invalid_params: {error}");
+
+    // This is a separate compatibility probe, not a rewrite of the capture:
+    // remove only the future member and leave view_due_max_ms unchanged.
+    let mut v0710 = params.clone();
+    v0710.as_object_mut().unwrap().remove("view_features");
+    let decoded: compact::setup::SetupRequest = decode(&v0710).unwrap();
+    assert_eq!(serde_json::to_value(decoded).unwrap(), known);
+    let error = invalid_params(
+        rig.h
+            .dispatch_value(7, json!({"method":"compaction.setup","params":v0710}))
+            .await,
+    );
+    assert_eq!(error, "unknown provider preset");
+    println!("{setup_name}: without view_features, decode PASS (view_due_max_ms=30000); handler REJECT scripted preset");
+
+    for index in 0..notices {
+        let name = format!("{case}-notice-{index}.json");
+        let headers: BTreeMap<String, String> = serde_json::from_value(fixture(&name)).unwrap();
+        let decoded = notice::AdvanceNotice::from_headers(&headers).unwrap();
+        assert_eq!(decoded.to_headers(), headers, "{name}: header lost");
+        let message = cortexkit_bus_trait::Message {
+            subject: notice::event_subject("fixture", "broca", notice::ADVANCED_EVENT),
+            id: bus_id(&decoded.session_ref, "advanced", decoded.seq),
+            digest: decoded.digest().parse().unwrap(),
+            headers,
+        };
+        // Setup was refused. The actual notice handler acknowledges an unknown
+        // conversation without reading the runner or publishing a view.
+        rig.h.advance_compaction("fixture", &message).await.unwrap();
+        assert!(load_head(rig.h.store.get().unwrap(), &decoded.session_ref)
+            .unwrap()
+            .is_none());
+        let mut corrupt = message.clone();
+        corrupt.id.push_str("-wrong");
+        assert!(rig.h.advance_compaction("fixture", &corrupt).await.is_err());
+        println!("{name}: PASS decode and handler (unknown conversation acknowledged)");
+    }
+
+    for index in 0..fetches {
+        let name = format!("{case}-fetch-{index}.json");
+        let capture = fixture(&name);
+        let _: view::ViewGetRequest = decode(&capture["request"]["params"]).unwrap();
+        let answer = response(rig.h.dispatch_value(7, capture["request"].clone()).await);
+        let _: view::ViewGetAnswer = decode(&answer).unwrap();
+        assert_eq!(answer["answer"], "refuse");
+        assert_eq!(answer["code"], "unknown_session");
+        no_truncate(&answer);
+
+        // These captured answers come from a scripted provider, not ck-mc.
+        // An unknown truncate field decodes but cannot supply the action that
+        // the 0.7.10 view validator requires (bytes or drop).
+        let scripted: view::ViewGetAnswer = decode(&capture["answer"]).unwrap();
+        if case == "part_edits_truncate_renders_with_own_tag" {
+            let view::ViewGetAnswer::View { view } = scripted else {
+                panic!("expected a scripted view")
+            };
+            assert_eq!(view.check(), Err(view::ViewProblem::EditAction));
+            println!("{name}: request PASS; ck-mc answer PASS (unknown_session); scripted answer PASS decode, FAIL validation (EditAction)");
+        } else {
+            if let view::ViewGetAnswer::View { view } = scripted {
+                assert_eq!(view.check(), Ok(()), "{name}");
+            }
+            println!("{name}: request PASS; ck-mc answer PASS (unknown_session); scripted answer PASS decode/validation");
+        }
+    }
+
+    for index in 0..models {
+        let name = format!("{case}-model-{index}.json");
+        let rows = fixture(&name);
+        assert!(!rows.as_array().unwrap().is_empty());
+        for row in rows.as_array().unwrap() {
+            assert!(matches!(row["role"].as_str(), Some("user" | "assistant")));
+            assert!(row["content"].is_string());
+        }
+        println!("{name}: N/A model input (Broca -> model, not a ck-mc request/answer)");
+    }
+    assert!(rig.runner.reads.lock().unwrap().is_empty());
+}
+
+macro_rules! case {
+    ($name:ident, $fetches:expr, $notices:expr, $models:expr) => {
+        #[tokio::test]
+        async fn $name() {
+            replay_case(stringify!($name), $fetches, $notices, $models).await;
+        }
+    };
+}
+
+case!(view_due_first_model_uses_view, 1, 2, 1);
+case!(view_due_later_step_retries, 2, 3, 1);
+case!(view_due_refused_fetch_blocks_model, 1, 1, 0);
+case!(part_edits_truncate_renders_with_own_tag, 1, 4, 2);
+case!(part_edits_bytes_render_with_own_tag, 1, 4, 2);
+
+#[tokio::test]
+async fn supported_broca_setup_and_published_edits_never_contain_truncate() {
+    let dir = tempfile::tempdir().unwrap();
+    let rig = Rig::open(
+        dir.path(),
+        "broca",
+        "broca",
+        json!({"serializer_profile":"owned-broca"}),
+    )
+    .await;
+    let setup: compact::setup::SetupAnswer = decode(&rig.state().initial).unwrap();
+    no_truncate(&serde_json::to_value(setup).unwrap());
+    // A supported ck-mc session is a separate publication witness: the captures
+    // omit session.read pages and their scripted Setup is not a ck-mc preset.
+    *rig.runner.entries.lock().unwrap() = (0..40)
+        .map(|n| {
+            ReadMessage::new(
+                n,
+                format!("m{n}"),
+                json!({"role":if n % 2 == 0 {"user"} else {"assistant"},"content":[{"type":"text","text":format!("message {n} ")+&"durable words ".repeat(16)}]}),
+            )
+            .with_tags(vec![tags::PartTag::tagged(format!("m{n}#0"), format!("§{}§", n + 1))])
+        })
+        .collect();
+    rig.notice(1, 100, None).await;
+    rig.queue(&[2]).await;
+    let published = rig
+        .ride("ttl_expired")
+        .await
+        .expect("a reduction publishes");
+    let answer = rig
+        .op(
+            "view.get",
+            json!({"session_ref":rig.reference,"view_version":published.view_version}),
+        )
+        .await;
+    assert_eq!(answer["answer"], "view");
+    let _: view::ViewGetAnswer = decode(&answer).unwrap();
+    no_truncate(&answer);
+    let edits: Vec<_> = answer["view"]["ranges"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .filter_map(|range| range["edits"].as_array())
+        .flatten()
+        .collect();
+    assert!(
+        !edits.is_empty(),
+        "exercise a real edit, not an unchanged view"
+    );
+    assert!(edits
+        .iter()
+        .all(|edit| edit.get("drop").is_some() || edit.get("bytes").is_some()));
+}
@@ -0,0 +1,110 @@
+# Broca compaction-provider 0.7.10 / 0.7.11 decode captures
+
+Source: Broca's five conformance-kit cases, supplied read-only at
+`/Users/ufukaltinok/Work/Projects/CortexKit-scratch/shared-mc-broca/compaction-0710-samples-1031/`.
+The 31 JSON files and `SHA256SUMS` are byte-for-byte copies. Every checksum was
+verified before inspecting the samples. The manifest's own SHA-256 is
+`c679754e05680772890502cced3e0f1902bad79cce8d2f9569457e991a84c3ed` (not a Git ref).
+
+The tests in `src/providers/async_provider/tests/broca_compaction_0710.rs` use
+ck-mc's production dispatch, `providers::decode`, `AdvanceNotice::from_headers`,
+and the actual notice and view-get handlers. There is one test per named case,
+plus fixture-integrity and independent ck-mc publication witnesses. The crate
+pins `cortexkit-role-compaction-provider = 0.7.10` at the deployed ck-mc build's source commit
+`a2ba9a341f52318f48489a7c8ef66196f88b7e3a`. No compatibility shim or production
+behavior change accompanies these fixtures.
+
+## Outcomes and boundaries
+
+- **Setup decoding passes:** `view_due_max_ms = 30000` is understood;
+  `view_features = ["truncate", "tag_bytes_edits"]` is ignored. There is **no
+  strict unknown-field decoding error**. The pinned crate's `CONTRACT.md` §14
+  says: “**Lenient** (unknown fields ignored): `role.describe`, the Setup
+  request, the fields of every answer, the fields of `view.get` and
+  `compaction.ride` requests and of their `overflow`, of a view, its cut and
+  its part edits, and of `ceiling`. Unknown notice and view-ready headers are
+  ignored.” `src/setup.rs` calls `SetupRequest` “Decoded leniently.”
+- **Literal Setup handling fails for a different reason:** all five requests
+  select the kit's `preset: "scripted"`. ck-mc returns
+  `invalid_params: unknown provider preset`, with and without `view_features`.
+  The captures also omit `context_window`, which ck-mc needs for a fresh
+  supported Setup. Tests do not silently change these requests into successful
+  enrollments. These are scripted-provider kit runs, not successful ck-mc runs.
+- All 14 notices decode with every captured header preserved. Production notice
+  handling acknowledges their unknown conversations after checking claim IDs
+  and digests. This is **not** proof of a successful enrolled session replay:
+  Setup failed and these captures contain no `session.read` pages. No new
+  unrecognized notice header is present in this sample set.
+- All six `view.get` requests decode and traverse the real handler. With no
+  enrolled conversation, ck-mc produces `refuse / unknown_session`, which also
+  decodes. Captured answers are from the **scripted provider**, not ck-mc.
+  Five captured answers also pass the pinned view validator. The truncate
+  answer decodes leniently (the unknown field is ignored), then fails
+  `CompactionView::check()` with `ViewProblem::EditAction`: 0.7.10 requires a
+  `bytes` or `drop` action. This is not an inbound ck-mc view or a ck-mc output.
+- No view is published for these literal failed Setups, hence none contains
+  `truncate`. A separate supported `owned-broca` session witness uses
+  a synthetic text transcript, queues a real reduction, fetches its
+  published view, requires nonempty edits, and checks that Setup and view
+  answers contain no `truncate`. ck-mc's range builder emits only `drop` and
+  `bytes` part edits. This witness is not presented as one of the supplied runs.
+- Six `model-*.json` files are Broca-to-model message arrays, **not** ck-mc
+  requests or answers. They are retained and checksummed, but cannot honestly
+  be run through a ck-mc protocol decoder. The supplied 31 files contain no
+  ride requests or Setup answers.
+
+## Per-file results
+
+“PASS / preset FAIL” means decoding passes, but literal handling returns the
+exact unsupported-preset error above. “PASS / unknown” means decoding and actual
+unknown-conversation handling pass. “PASS / view FAIL” distinguishes decoding
+from validation of the scripted answer. These expected failures are asserted;
+a green test suite is not a claim that these runs can enroll with ck-mc.
+
+| File | Decode / handling result |
+| --- | --- |
+| `view_due_first_model_uses_view-setup-0.json` | PASS / preset FAIL |
+| `view_due_first_model_uses_view-fetch-0.json` | Request PASS / unknown; scripted answer PASS |
+| `view_due_first_model_uses_view-notice-0.json` | PASS / unknown |
+| `view_due_first_model_uses_view-notice-1.json` | PASS / unknown |
+| `view_due_first_model_uses_view-model-0.json` | N/A: model-only |
+| `view_due_later_step_retries-setup-0.json` | PASS / preset FAIL |
+| `view_due_later_step_retries-fetch-0.json` | Request PASS / unknown; scripted answer PASS |
+| `view_due_later_step_retries-fetch-1.json` | Request PASS / unknown; scripted answer PASS |
+| `view_due_later_step_retries-notice-0.json` | PASS / unknown |
+| `view_due_later_step_retries-notice-1.json` | PASS / unknown |
+| `view_due_later_step_retries-notice-2.json` | PASS / unknown |
+| `view_due_later_step_retries-model-0.json` | N/A: model-only |
+| `view_due_refused_fetch_blocks_model-setup-0.json` | PASS / preset FAIL |
+| `view_due_refused_fetch_blocks_model-fetch-0.json` | Request PASS / unknown; scripted refusal PASS |
+| `view_due_refused_fetch_blocks_model-notice-0.json` | PASS / unknown |
+| `part_edits_truncate_renders_with_own_tag-setup-0.json` | PASS / preset FAIL |
+| `part_edits_truncate_renders_with_own_tag-fetch-0.json` | Request PASS / unknown; scripted answer PASS / view FAIL (`EditAction`) |
+| `part_edits_truncate_renders_with_own_tag-notice-0.json` | PASS / unknown |
+| `part_edits_truncate_renders_with_own_tag-notice-1.json` | PASS / unknown |
+| `part_edits_truncate_renders_with_own_tag-notice-2.json` | PASS / unknown |
+| `part_edits_truncate_renders_with_own_tag-notice-3.json` | PASS / unknown |
+| `part_edits_truncate_renders_with_own_tag-model-0.json` | N/A: model-only |
+| `part_edits_truncate_renders_with_own_tag-model-1.json` | N/A: model-only |
+| `part_edits_bytes_render_with_own_tag-setup-0.json` | PASS / preset FAIL |
+| `part_edits_bytes_render_with_own_tag-fetch-0.json` | Request PASS / unknown; scripted answer PASS |
+| `part_edits_bytes_render_with_own_tag-notice-0.json` | PASS / unknown |
+| `part_edits_bytes_render_with_own_tag-notice-1.json` | PASS / unknown |
+| `part_edits_bytes_render_with_own_tag-notice-2.json` | PASS / unknown |
+| `part_edits_bytes_render_with_own_tag-notice-3.json` | PASS / unknown |
+| `part_edits_bytes_render_with_own_tag-model-0.json` | N/A: model-only |
+| `part_edits_bytes_render_with_own_tag-model-1.json` | N/A: model-only |
+
+## Reproduce on Linux
+
+Use a throwaway `HOME`, retain the existing `CARGO_HOME` / `RUSTUP_HOME` values
+so Rust can still find its installed toolchain and dependency cache,
+and run `git config --global --add safe.directory '*'` in that HOME first.
+
+```sh
+cargo fmt --all -- --check
+cargo test --locked -p mc-module --lib broca_compaction_0710 -- --nocapture
+cargo clippy --locked -p mc-module --all-targets -- -D warnings
+```
+
+The repository delivery gate remains `bash scripts/gate.sh full`.