mason: enable OpenCode tagging surface

Author: ualtinok

crates/mc-module/src/lib.rs

@@ -168,16 +168,28 @@ pub const fn profile_render_epoch(profile: SerializerProfile) -> u32 {
     }
 }
 
-/// Normalize the request-local Claude Code surface signal once. Every behavior tied to
-/// the reduction tool consumes this value rather than maintaining an independent gate.
+/// Normalize the request-local Claude Code surface signal once. This remains limited to
+/// Claude Code mechanics such as the Thalamus acknowledgement contract and guidance variant.
 pub const fn cc_u1_active(profile: Option<SerializerProfile>, tool_present: bool) -> bool {
     matches!(profile, Some(SerializerProfile::ClaudeCodeAnthropic)) && tool_present
 }
 
+/// Return whether the provider-visible tagging and reduction overlay may be enabled.
+/// OpenCode uses the same overlay when its session exposes ctx_reduce.
+pub const fn tagging_surface_active(
+    profile: Option<SerializerProfile>,
+    tool_present: bool,
+) -> bool {
+    matches!(
+        profile,
+        Some(SerializerProfile::ClaudeCodeAnthropic | SerializerProfile::OpencodeAiSdk)
+    ) && tool_present
+}
+
 /// The tagger component of the effective render identity. A false request contributes
 /// no component, preserving the render identity used before the capability existed.
-pub const fn tagger_feature_epoch(cc_u1_active: bool) -> u32 {
-    if cc_u1_active {
+pub const fn tagger_feature_epoch(tagging_surface_active: bool) -> u32 {
+    if tagging_surface_active {
         TAGGER_FEATURE_EPOCH
     } else {
         0
@@ -4095,7 +4107,7 @@ impl McHandler {
         } else {
             "present"
         };
-        let surface = if loaded.meta.cc_u1_active {
+        let surface = if loaded.meta.tagging_surface_active || loaded.meta.cc_u1_active {
             "active"
         } else {
             "inactive"
@@ -12727,6 +12739,55 @@ mod tests {
         assert_eq!(store.load_pending_agent_drops("ses").unwrap(), pending);
     }
 
+    #[tokio::test(flavor = "current_thread")]
+    async fn opencode_raw_drop_range_resolves_minted_tags_and_drains_on_next_bust() {
+        let producer = Arc::new(ProducerState::default());
+        let (handler, store, _dir, _project) = handler_with_store(producer, default_test_config());
+        let messages = (1..=25u64)
+            .map(|ordinal| {
+                let mid = format!("m{ordinal}");
+                let text = format!("output {ordinal}");
+                ck(&mid, ordinal, &text)
+            })
+            .collect::<Vec<_>>();
+        let mut transform_request = request(messages);
+        transform_request["serializer_profile"] = json!("opencode-aisdk");
+        transform_request["tool_present"] = json!(true);
+        transform_request["serve_native"] = json!(true);
+
+        let transition = call_transform_request(&handler, transform_request.clone()).await;
+        assert_eq!(transition["surface_state"], "transition");
+        let tagged = call_transform_request(&handler, transform_request.clone()).await;
+        assert_eq!(tagged["surface_state"], "active");
+        let tagged_bytes = serde_json::to_string(&tagged["ck_messages"]).unwrap();
+        assert!(tagged_bytes.contains("§1§ output 1"));
+        assert!(tagged_bytes.contains("§2§ output 2"));
+        assert!(tagged_bytes.contains("§3§ output 3"));
+        assert_eq!(store.load_tags_for_session("ses").unwrap().len(), 25);
+
+        let queued = match handler.handle_agent_drops_value(
+            7,
+            json!({
+                "method": "agent_drops.append",
+                "session_id": "ses",
+                "drop": "1-3",
+                "command_id": "opencode-drop-range",
+            }),
+        ) {
+            HandlerOutcome::Response(bytes) => serde_json::from_slice::<Value>(&bytes).unwrap(),
+            other => panic!("unexpected handler outcome: {other:?}"),
+        };
+        assert_eq!(queued, json!({ "ok": true, "queued": 3 }));
+
+        transform_request["render_config"] = json!("cfg1");
+        let drained = call_transform_request(&handler, transform_request).await;
+        let drained_bytes = serde_json::to_string(&drained["ck_messages"]).unwrap();
+        assert!(drained_bytes.contains("[dropped §1§]"));
+        assert!(drained_bytes.contains("[dropped §2§]"));
+        assert!(drained_bytes.contains("[dropped §3§]"));
+        assert!(store.load_pending_agent_drops("ses").unwrap().is_empty());
+    }
+
     #[tokio::test(flavor = "current_thread")]
     async fn ctx_reduce_command_id_survives_transform_drain() {
         let producer = Arc::new(ProducerState::default());

crates/mc-module/src/transform.rs

@@ -842,14 +842,19 @@ fn apply_once(
     let mutation_exempt_mid =
         latest_assistant_mutation_exempt_mid(&req.messages, serializer_profile, req.mid_turn);
     let cc_u1_active = crate::cc_u1_active(serializer_profile, req.tool_present);
+    let tagging_surface_requested =
+        crate::tagging_surface_active(serializer_profile, req.tool_present);
     let transform_snapshot = store.load_transform_snapshot(&req.session_id)?;
     let loaded = transform_snapshot.loaded;
     let overlay_frontier = transform_snapshot.overlay_frontier;
-    let surface_transition = serializer_profile == Some(SerializerProfile::ClaudeCodeAnthropic)
-        && loaded.meta.cc_u1_active != cc_u1_active;
+    // Legacy sessions stored the CC latch before the generic surface latch existed.
+    // Treat that old true value as the generic latch so an upgrade does not repeat a fold.
+    let persisted_tagging_surface_active =
+        loaded.meta.tagging_surface_active || loaded.meta.cc_u1_active;
+    let surface_transition = persisted_tagging_surface_active != tagging_surface_requested;
     let surface_state = if surface_transition {
         SurfaceState::Transition
-    } else if cc_u1_active {
+    } else if tagging_surface_requested {
         SurfaceState::Active
     } else {
         SurfaceState::Inactive
@@ -874,7 +879,7 @@ fn apply_once(
         .filter(|epoch| *epoch != 0)
         .map(|epoch| format!("mpe{epoch}"))
         .unwrap_or_default();
-    let tagger_feature_epoch = match crate::tagger_feature_epoch(cc_u1_active) {
+    let tagger_feature_epoch = match crate::tagger_feature_epoch(tagging_surface_requested) {
         0 => String::new(),
         epoch => format!("tfe{epoch}"),
     };
@@ -890,7 +895,7 @@ fn apply_once(
             tagger_feature_epoch: tagger_feature_epoch.clone(),
         },
     );
-    let tagging_active = cc_u1_active && loaded.meta.cc_u1_active;
+    let tagging_active = tagging_surface_requested && persisted_tagging_surface_active;
     // Previously stored overlay rows may still replay when boundary-lineage validation
     // later forces pass-through. Decisions from this request stay in memory until the
     // final cache-state compare-and-swap accepts the pass.
@@ -1152,10 +1157,10 @@ fn apply_once(
         || reconcile_hard_due
         || emergency_arm_engaged;
     // Profile defaults remain conservative, while the request-local tool signal enables
-    // full-array tail reclaim for the Claude Code profile. A false request therefore
+    // full-array tail reclaim for an active tagging surface. A false request therefore
     // retains the exact pre-capability behavior without changing the global profile table.
-    let tail_reclaim_enabled =
-        serializer_profile.is_none_or(|profile| healing::tail_reclaim(profile) || cc_u1_active);
+    let tail_reclaim_enabled = serializer_profile
+        .is_none_or(|profile| healing::tail_reclaim(profile) || tagging_surface_requested);
     let producer_gate = tail_reclaim_enabled
         && producer_gate(
             scheduler_outcome.pass,
@@ -1170,7 +1175,7 @@ fn apply_once(
         PassClass::Defer
     };
     let tail_for_selection = tail_sel_items(&live, loaded.meta.coverage_ordinal);
-    let mut protected_block_ids = if cc_u1_active {
+    let mut protected_block_ids = if tagging_surface_requested {
         newest_active_tag_block_ids(
             &loaded.core,
             &loaded.meta,
@@ -1298,6 +1303,7 @@ fn apply_once(
     }
     apply_ingress_meta(&mut meta, req, &projection, provisional_tail_mid);
     meta.cc_u1_active = cc_u1_active;
+    meta.tagging_surface_active = tagging_surface_requested;
     if cc_u1_active {
         meta.last_serializer_profile = req.serializer_profile.clone();
     }
@@ -9136,6 +9142,97 @@ mod tests {
         assert!(s.load_tags_for_session("inert").unwrap().is_empty());
     }
 
+    #[test]
+    fn opencode_tagging_surface_tags_tool_results_and_replays_byte_stably() {
+        let dir = tempfile::tempdir().unwrap();
+        let s = store(dir.path());
+        let messages = vec![
+            wire_tool_call("call-1", 1, "call_result-1"),
+            wire_tool_result(
+                "result-1",
+                2,
+                json!({ "kind": { "type": "text", "text": "tool output" } }),
+            ),
+        ];
+        let request = active_opencode_req("opencode-tags", "cfg0", messages);
+
+        let transition = run(&s, &request, &spine());
+        assert_eq!(transition.surface_state, SurfaceState::Transition);
+        assert!(!serde_json::to_string(transition.messages())
+            .unwrap()
+            .contains("§1§"));
+
+        let active = run(&s, &request, &spine());
+        assert_eq!(active.surface_state, SurfaceState::Active);
+        let active_bytes = serde_json::to_vec(active.messages()).unwrap();
+        assert!(serde_json::to_string(active.messages())
+            .unwrap()
+            .contains("§1§ tool output"));
+        assert_eq!(s.load_tags_for_session("opencode-tags").unwrap().len(), 1);
+
+        let replay = run(&s, &request, &spine());
+        assert_eq!(serde_json::to_vec(replay.messages()).unwrap(), active_bytes);
+    }
+
+    #[test]
+    fn opencode_tool_absent_keeps_overlay_bytes_disabled() {
+        let dir = tempfile::tempdir().unwrap();
+        let s = store(dir.path());
+        let request = opencode_req(
+            "opencode-inactive",
+            "cfg0",
+            vec![item("m1", 1, "plain output")],
+        );
+
+        let first = run(&s, &request, &spine());
+        let replay = run(&s, &request, &spine());
+        assert_eq!(first.surface_state, SurfaceState::Inactive);
+        assert_eq!(
+            serde_json::to_vec(first.messages()).unwrap(),
+            serde_json::to_vec(replay.messages()).unwrap()
+        );
+        assert!(!serde_json::to_string(first.messages())
+            .unwrap()
+            .contains("§1§"));
+        assert!(s
+            .load_tags_for_session("opencode-inactive")
+            .unwrap()
+            .is_empty());
+    }
+
+    #[test]
+    fn opencode_surface_flip_folds_once_before_rendering_tags() {
+        let dir = tempfile::tempdir().unwrap();
+        let s = store(dir.path());
+        let mut request =
+            opencode_req("opencode-flip", "cfg0", vec![item("m1", 1, "stable bytes")]);
+
+        let before = run(&s, &request, &spine());
+        let before_config = s.load("opencode-flip").unwrap().meta.last_render_config;
+        assert_eq!(before.action, "HARD");
+        assert!(!before_config.contains("tfe:"));
+
+        request.tool_present = true;
+        let transition = run(&s, &request, &spine());
+        let transitioned_config = s.load("opencode-flip").unwrap().meta.last_render_config;
+        assert_eq!(transition.action, "HARD");
+        assert_ne!(transitioned_config, before_config);
+        assert!(transitioned_config.contains("tfe:4:tfe3"));
+        assert!(!serde_json::to_string(transition.messages())
+            .unwrap()
+            .contains("§1§"));
+
+        let active = run(&s, &request, &spine());
+        assert_ne!(active.action, "HARD");
+        assert_eq!(
+            s.load("opencode-flip").unwrap().meta.last_render_config,
+            transitioned_config
+        );
+        assert!(serde_json::to_string(active.messages())
+            .unwrap()
+            .contains("§1§ stable bytes"));
+    }
+
     #[test]
     fn tagger_flip_hards_before_committed_identity_can_render_tags() {
         let dir = tempfile::tempdir().unwrap();
@@ -11617,6 +11714,20 @@ mod tests {
         request
     }
 
+    fn opencode_req(session: &str, cfg: &str, messages: Vec<CkIngressMessage>) -> TransformRequest {
+        profile_req(SerializerProfile::OpencodeAiSdk, session, cfg, messages)
+    }
+
+    fn active_opencode_req(
+        session: &str,
+        cfg: &str,
+        messages: Vec<CkIngressMessage>,
+    ) -> TransformRequest {
+        let mut request = opencode_req(session, cfg, messages);
+        request.tool_present = true;
+        request
+    }
+
     fn effective_render_config_with_epochs(
         store: &McStore,
         cfg: &str,

crates/mc-store/src/lib.rs

@@ -1381,10 +1381,15 @@ pub struct ModuleMeta {
     /// after OpenCode rebuilds the native message array from its database.
     #[serde(default)]
     pub reasoning_cleared_through_ordinal: u64,
-    /// The request-local reduction surface state committed with the rendered identity.
+    /// The request-local Claude Code mechanics state committed with the rendered identity.
     /// Missing legacy metadata is false, which preserves the dormant render path.
     #[serde(default)]
     pub cc_u1_active: bool,
+    /// The request-local tagging surface latch committed with the rendered identity.
+    /// Both the current request and this durable latch must be active before overlay bytes
+    /// render, so a transition pass can coordinate one cache-breaking HARD first.
+    #[serde(default)]
+    pub tagging_surface_active: bool,
     /// Reclaimable-token amount at the last Channel-1 append or suppression reset.
     #[serde(default)]
     pub channel1_last_nudge_undropped: i64,