feat: initial DCP integration (J1-J10)

Phase A: Foundation
- J1: Cargo.toml git dependency for dynamic_context_pruning
- J2: mod dcp_bridge registered in lib.rs
- J3: DcpPlugin struct wrapping ContextPruner

Phase B: Core Integration
- J4+J5: Agent field + DCP Phase 1 before CompactionManager Phase 2

Phase C: Tools & Commands
- J6: System prompt injection via transform_system()

Phase D: Persistence & Config
- J10: dcp_enabled config option

Build: cargo check --features dcp PASSED (3m57s)
Note: Full release build skipped (30+ min due to LLM crates)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: quangdang46

Cargo.lock

@@ -227,7 +227,7 @@ aws-sdk-bedrock = "1.141.0"
 aws-sdk-sts = "1.103.0"
 
 # DCP integration (dynamic_context_pruning)
-dynamic_context_pruning = { path = "/data/projects/dynamic_context_pruning/crates/dynamic_context_pruning", optional = true }
+dynamic_context_pruning = { git = "https://github.com/quangdang46/dynamic_context_pruning", branch = "main", package = "dynamic_context_pruning", optional = true }
 
 [features]
 # Include local ONNX/tokenizer embeddings in default builds so memory recall,

Cargo.toml

@@ -227,6 +227,9 @@ pub struct Agent {
     stdin_request_tx: Option<tokio::sync::mpsc::UnboundedSender<crate::tool::StdinInputRequest>>,
     /// Canonical reducer-backed view of runtime provider/model selection.
     provider_runtime_state: ProviderRuntimeState,
+    /// DCP plugin for context pruning (behind feature flag).
+    #[cfg(feature = "dcp")]
+    dcp: Option<crate::dcp_plugin::DcpPlugin>,
 }
 
 impl Agent {
@@ -277,6 +280,8 @@ impl Agent {
             rewind_undo_snapshot: None,
             stdin_request_tx: None,
             provider_runtime_state: ProviderRuntimeState::observed(initial_provider_model),
+            #[cfg(feature = "dcp")]
+            dcp: crate::dcp_plugin::DcpPlugin::new().ok(),
         };
         crate::tool::set_session_tool_policy(
             &agent.session.id,
@@ -579,17 +584,49 @@ impl Agent {
     }
 
     fn messages_for_provider(&mut self) -> (Vec<Message>, Option<CompactionEvent>) {
+        // ── Phase 1: DCP Plugin Layer ──────────────────────────────────
+        #[cfg(feature = "dcp")]
+        let messages = {
+            let all_messages = self.session.provider_messages();
+            if let Some(dcp) = &mut self.dcp {
+                let output = dcp.transform(&all_messages).unwrap_or_else(|e| {
+                    logging::warn(&format!("DCP transform failed: {e}"));
+                    crate::dcp_plugin::DcpTransformOutput {
+                        messages: all_messages.to_vec(),
+                        tokens_saved: 0,
+                        removed_count: 0,
+                        changed: false,
+                    }
+                });
+
+                if output.changed {
+                    logging::info(&format!(
+                        "DCP: pruned {} messages, saved ~{} tokens",
+                        output.removed_count,
+                        output.tokens_saved,
+                    ));
+                }
+
+                output.messages
+            } else {
+                all_messages.to_vec()
+            }
+        };
+
+        #[cfg(not(feature = "dcp"))]
+        let messages = self.session.provider_messages().to_vec();
+
+        // ── Phase 2: CompactionManager (existing) ──────────────────────
         if self.provider.supports_compaction() || self.session.compaction.is_some() {
             let compaction = self.registry.compaction();
             match compaction.try_write() {
                 Ok(mut manager) => {
                     let discarded_oversized_native =
                         manager.discard_oversized_openai_native_compaction();
                     let messages = {
-                        let all_messages = self.session.provider_messages();
                         if self.provider.uses_jcode_compaction() {
                             let action =
-                                manager.ensure_context_fits(all_messages, self.provider.clone());
+                                manager.ensure_context_fits(&messages, self.provider.clone());
                             match action {
                                 crate::compaction::CompactionAction::BackgroundStarted {
                                     trigger,
@@ -608,7 +645,7 @@ impl Agent {
                                 crate::compaction::CompactionAction::None => {}
                             }
                         }
-                        manager.messages_for_api_with(all_messages)
+                        manager.messages_for_api_with(&messages)
                     };
                     let event = manager.take_compaction_event();
                     if event.is_some() || discarded_oversized_native {
@@ -637,8 +674,6 @@ impl Agent {
             };
         }
 
-        let all_messages = self.session.provider_messages();
-        let messages = all_messages.to_vec();
         let user_count = messages
             .iter()
             .filter(|message| matches!(message.role, Role::User))

src/agent.rs

@@ -8,10 +8,10 @@
 //! (see PLAN.md §9.1).
 
 use crate::message::{ContentBlock, Message as JMsg, Role as JRole};
-use dcp_types::{Message as DcpMessage, Part, Role as DcpRole, ToolStatus};
+use dynamic_context_pruning::{Message as DcpMessage, Part, Role as DcpRole, ToolStatus};
 
 /// Convert jcode messages to DCP canonical IR.
-pub fn jcode_to_dcp(msgs: &[JMsg]) -> Vec<DcpMessage> {
+pub fn jcode_to_dcp(msgs:&[JMsg]) -> Vec<DcpMessage> {
     msgs.iter().map(jmsg_to_dcp).collect()
 }
 
@@ -28,9 +28,8 @@ fn jmsg_to_dcp(m: &JMsg) -> DcpMessage {
         .unwrap_or(0);
 
     // Generate a stable ID from the message content
-    let id = crate::message::stable_message_hash(m)
-        .map(|h| format!("{:x}", h))
-        .unwrap_or_else(|| format!("msg_{}", time));
+    let hash = crate::message::stable_message_hash(m);
+    let id = format!("{:x}", hash);
 
     let parts: Vec<Part> = m
         .content
@@ -43,6 +42,7 @@ fn jmsg_to_dcp(m: &JMsg) -> DcpMessage {
         role,
         parts,
         time,
+        ignored: false,
     }
 }
 
@@ -90,6 +90,7 @@ fn dcp_msg_to_jcode(m: DcpMessage) -> JMsg {
         DcpRole::User => JRole::User,
         DcpRole::Assistant => JRole::Assistant,
         DcpRole::System => JRole::User, // shouldn't happen in practice
+        _ => JRole::User, // exhaustive fallback for non-exhaustive enum
     };
 
     let timestamp = if m.time != 0 {
@@ -136,6 +137,7 @@ fn part_to_content(p: Part) -> Option<ContentBlock> {
             is_error: matches!(status, ToolStatus::Error).then_some(true),
         },
         Part::Image { media_type, data } => ContentBlock::Image { media_type, data },
+        _ => return None, // exhaustive fallback for non-exhaustive enum
     })
 }
 
@@ -167,7 +169,7 @@ mod tests {
 
     #[test]
     fn test_tool_call_roundtrip() {
-        use dcp_types::Part;
+        use dynamic_context_pruning::Part;
 
         let dcp_msg = DcpMessage {
             id: "test123".to_string(),
@@ -181,10 +183,11 @@ mod tests {
                 },
             ],
             time: 1234567890,
+            ignored: false,
         };
 
         let jmsg = dcp_msg_to_jcode(dcp_msg);
         assert_eq!(jmsg.role, JRole::Assistant);
         assert!(jmsg.content.iter().any(|c| matches!(c, ContentBlock::ToolUse { .. })));
     }
-}
+}