deepstrike 0.2.35__tar.gz → 0.2.37__tar.gz

{deepstrike-0.2.35 → deepstrike-0.2.37}/Cargo.lock

@@ -194,7 +194,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-core"
-version = "0.2.35"
+version = "0.2.37"
 dependencies = [
  "compact_str",
  "pretty_assertions",
@@ -206,7 +206,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-node"
-version = "0.2.35"
+version = "0.2.37"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -218,7 +218,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-py"
-version = "0.2.35"
+version = "0.2.37"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -229,7 +229,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-sdk"
-version = "0.2.35"
+version = "0.2.37"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -263,7 +263,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-wasm"
-version = "0.2.35"
+version = "0.2.37"
 dependencies = [
  "compact_str",
  "deepstrike-core",

{deepstrike-0.2.35 → deepstrike-0.2.37}/Cargo.toml

@@ -3,13 +3,13 @@ resolver = "2"
 members = ["crates/deepstrike-core", "crates/deepstrike-py"]
 
 [workspace.package]
-version = "0.2.35"
+version = "0.2.37"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/kongusen/deepstrike"
 
 [workspace.dependencies]
-deepstrike-core = { path = "crates/deepstrike-core", version = "0.2.35" }
+deepstrike-core = { path = "crates/deepstrike-core", version = "0.2.37" }
 notify = "6"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

{deepstrike-0.2.35 → deepstrike-0.2.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepstrike
-Version: 0.2.35
+Version: 0.2.37
 Requires-Dist: httpx>=0.27
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: anyio>=4.0
@@ -149,7 +149,7 @@ The mechanisms above are not internal refactors — they change what you can bui
 Tool calls, spawns, compression, and signals pass through one kernel gate with an explicit lifecycle (Ready / Running / Blocked / Suspended). You implement I/O; the kernel decides *when* and *whether*. Node, Python, and Rust share the same decision path, so `wake(session_id)` and cross-language tooling see consistent behavior.
 
 **Longer, sturdier sessions (Layer-1 spool + semantic page-out)**  
-Oversized tool results (> 50 KB) stay in context as a preview plus a `.spool/` reference — the model reads the full payload on demand via ordinary file tools. When pressure triggers semantic eviction, the SDK summarizes archived content into `DreamStore` and satisfies `page_in_requested` on the way back in. Long tasks survive token pressure instead of failing mid-run.
+Oversized tool results (> 50 KB) stay in context as a preview plus a `.spool/` reference — the model reads the full payload on demand via ordinary file tools. When pressure triggers semantic eviction, the SDK summarizes archived content into `DreamStore`. Long tasks survive token pressure instead of failing mid-run.
 
 **Safety and governance by default (OS native profile)**  
 Every run loads declarative `governance_policy` (deny / ask_user / rate-limit / param rules) and in-kernel signal routing (`attention_policy`, default queue 64). Dangerous tools, external interrupts, and approval flows are policy — not ad-hoc checks in your handlers.
@@ -443,9 +443,9 @@ effort: 1
 
 ## Knowledge
 
-Implement `KnowledgeSource` — the kernel injects a `knowledge` meta-tool. Runtime retrieval results land in **history** as tool results. Use `initial_memory` for durable preload into Slot 2.
+Implement `KnowledgeSource` — the kernel injects a `knowledge` meta-tool. Runtime retrieval results land in **history** as tool results (single-use fact content that decays with compaction), not in the durable `knowledge` partition. Use `initial_memory` for durable preload into Slot 2.
 
-Before tool execution the kernel may emit `page_in_requested`; the SDK satisfies it from `DreamStore`, `KnowledgeSource`, and a local semantic page-out cache, then feeds `page_in` back to the kernel.
+For durable content at runtime use `runner.push_knowledge(content, key=..., pinned=...)` — a **keyed** entry upserts on a repeated key and `runner.remove_knowledge(key)` removes it, both applied at the next compaction/renewal boundary. `knowledge_budget_ratio` (default 0.25, 0 disables) caps the partition: over budget, the oldest unpinned, non-skill entries are evicted at boundaries while `pinned=True` entries survive. A loaded skill's body is pinned here as `skill:<name>` and unpinned by `runner.deactivate_skill(name)` or a `skill_lease_turns` expiry.
 
 ```python
 from deepstrike import KnowledgeSource

{deepstrike-0.2.35 → deepstrike-0.2.37}/README.md

@@ -136,7 +136,7 @@ The mechanisms above are not internal refactors — they change what you can bui
 Tool calls, spawns, compression, and signals pass through one kernel gate with an explicit lifecycle (Ready / Running / Blocked / Suspended). You implement I/O; the kernel decides *when* and *whether*. Node, Python, and Rust share the same decision path, so `wake(session_id)` and cross-language tooling see consistent behavior.
 
 **Longer, sturdier sessions (Layer-1 spool + semantic page-out)**  
-Oversized tool results (> 50 KB) stay in context as a preview plus a `.spool/` reference — the model reads the full payload on demand via ordinary file tools. When pressure triggers semantic eviction, the SDK summarizes archived content into `DreamStore` and satisfies `page_in_requested` on the way back in. Long tasks survive token pressure instead of failing mid-run.
+Oversized tool results (> 50 KB) stay in context as a preview plus a `.spool/` reference — the model reads the full payload on demand via ordinary file tools. When pressure triggers semantic eviction, the SDK summarizes archived content into `DreamStore`. Long tasks survive token pressure instead of failing mid-run.
 
 **Safety and governance by default (OS native profile)**  
 Every run loads declarative `governance_policy` (deny / ask_user / rate-limit / param rules) and in-kernel signal routing (`attention_policy`, default queue 64). Dangerous tools, external interrupts, and approval flows are policy — not ad-hoc checks in your handlers.
@@ -430,9 +430,9 @@ effort: 1
 
 ## Knowledge
 
-Implement `KnowledgeSource` — the kernel injects a `knowledge` meta-tool. Runtime retrieval results land in **history** as tool results. Use `initial_memory` for durable preload into Slot 2.
+Implement `KnowledgeSource` — the kernel injects a `knowledge` meta-tool. Runtime retrieval results land in **history** as tool results (single-use fact content that decays with compaction), not in the durable `knowledge` partition. Use `initial_memory` for durable preload into Slot 2.
 
-Before tool execution the kernel may emit `page_in_requested`; the SDK satisfies it from `DreamStore`, `KnowledgeSource`, and a local semantic page-out cache, then feeds `page_in` back to the kernel.
+For durable content at runtime use `runner.push_knowledge(content, key=..., pinned=...)` — a **keyed** entry upserts on a repeated key and `runner.remove_knowledge(key)` removes it, both applied at the next compaction/renewal boundary. `knowledge_budget_ratio` (default 0.25, 0 disables) caps the partition: over budget, the oldest unpinned, non-skill entries are evicted at boundaries while `pinned=True` entries survive. A loaded skill's body is pinned here as `skill:<name>` and unpinned by `runner.deactivate_skill(name)` or a `skill_lease_turns` expiry.
 
 ```python
 from deepstrike import KnowledgeSource

{deepstrike-0.2.35 → deepstrike-0.2.37}/crates/deepstrike-core/src/context/compression.rs

@@ -1,7 +1,6 @@
 use super::config::ContextConfig;
 use super::partitions::ContextPartitions;
 use super::pressure::PressureAction;
-use super::summarizer::Summarizer;
 use super::token_engine::ContextTokenEngine;
 use crate::types::message::{Content, ContentPart, Message};
 
@@ -28,7 +27,6 @@ pub trait Compressor: Send + Sync {
         target_tokens: u32,
         max_tokens: u32,
         preserve_k: usize,
-        summarizer: &dyn Summarizer,
         engine: &ContextTokenEngine,
     ) -> CompressResult;
 }
@@ -45,7 +43,6 @@ impl Compressor for SnipCompactor {
         _target_tokens: u32,
         max_tokens: u32,
         preserve_k: usize,
-        _summarizer: &dyn Summarizer,
         engine: &ContextTokenEngine,
     ) -> CompressResult {
         let per_msg_limit = ((max_tokens as f64 * self.per_msg_ratio) as u32).max(50);
@@ -63,40 +60,17 @@ impl Compressor for SnipCompactor {
         for &i in &indices {
             let msg = &mut partition.messages[i];
             let original_tokens = msg.token_count.unwrap_or_else(|| engine.count_message(msg));
-            if let Content::Text(ref t) = msg.content {
-                let head_limit = per_msg_limit / 2;
-                let tail_limit = per_msg_limit.saturating_sub(head_limit);
-                let head_text = engine.truncate(t, head_limit);
-
-                let chars: Vec<char> = t.chars().collect();
-                let mut low = head_text.chars().count();
-                let mut high = chars.len();
-                let mut suffix_start = chars.len();
-                while low <= high {
-                    let mid = (low + high) / 2;
-                    if mid >= chars.len() {
-                        break;
-                    }
-                    let candidate: String = chars[mid..].iter().collect();
-                    let tokens = engine.count(&candidate);
-                    if tokens <= tail_limit {
-                        suffix_start = mid;
-                        if mid == 0 {
-                            break;
-                        }
-                        high = mid - 1;
-                    } else {
-                        low = mid + 1;
-                    }
-                }
-                let tail_text: String = chars[suffix_start..].iter().collect();
-                let omitted = original_tokens
-                    .saturating_sub(head_limit)
-                    .saturating_sub(tail_limit);
-                msg.content = Content::Text(format!(
-                    "{}… [… {} tokens omitted …] …{}",
-                    head_text, omitted, tail_text
-                ));
+            let head_limit = per_msg_limit / 2;
+            let tail_limit = per_msg_limit.saturating_sub(head_limit);
+            // Same head/tail elision as excerpt_text; the omitted count comes from the recorded
+            // token metadata (not a recount) so the elision marker matches the saved accounting.
+            let snipped = if let Content::Text(ref t) = msg.content {
+                Some(excerpt_text_with_total(t, head_limit, tail_limit, engine, original_tokens))
+            } else {
+                None
+            };
+            if let Some(text) = snipped {
+                msg.content = Content::Text(text);
                 msg.token_count = Some(per_msg_limit);
                 saved += original_tokens.saturating_sub(per_msg_limit);
             }
@@ -157,13 +131,6 @@ fn oversized_text_message_indices(
         .collect()
 }
 
-/// 获取当前UTC时间戳
-fn utc_now() -> String {
-    // 在实际使用中，这应该从ProviderResult.now_ms获取
-    // 这里简化为占位符
-    format!("{:?}", std::time::SystemTime::now())
-}
-
 /// Helper to extract key fields and info from JSON strings.
 fn extract_json_excerpt(output: &str) -> Option<String> {
     let val: serde_json::Value = serde_json::from_str(output).ok()?;
@@ -215,7 +182,18 @@ fn excerpt_text(
     tail_tokens: u32,
     engine: &ContextTokenEngine,
 ) -> String {
-    let total_tokens = engine.count(text);
+    excerpt_text_with_total(text, head_tokens, tail_tokens, engine, engine.count(text))
+}
+
+/// [`excerpt_text`] with the total token count supplied by the caller (e.g. from recorded
+/// message metadata) instead of recounted — the count only feeds the elision marker.
+fn excerpt_text_with_total(
+    text: &str,
+    head_tokens: u32,
+    tail_tokens: u32,
+    engine: &ContextTokenEngine,
+    total_tokens: u32,
+) -> String {
     if total_tokens <= head_tokens + tail_tokens {
         return text.to_string();
     }
@@ -295,7 +273,6 @@ impl Compressor for MicroCompactor {
         _target_tokens: u32,
         _max_tokens: u32,
         preserve_k: usize,
-        _summarizer: &dyn Summarizer,
         engine: &ContextTokenEngine,
     ) -> CompressResult {
         let find_tool_name = |call_id: &str, msgs: &[Message]| -> Option<String> {
@@ -416,7 +393,6 @@ impl Compressor for CollapseCompactor {
         target_tokens: u32,
         _max_tokens: u32,
         preserve_k: usize,
-        _summarizer: &dyn Summarizer,
         engine: &ContextTokenEngine,
     ) -> CompressResult {
         let partition = &mut partitions.history;
@@ -452,7 +428,6 @@ impl Compressor for AutoCompactor {
         _target_tokens: u32,
         _max_tokens: u32,
         preserve_k: usize,
-        _summarizer: &dyn Summarizer,
         engine: &ContextTokenEngine,
     ) -> CompressResult {
         let partition = &mut partitions.history;
@@ -496,47 +471,6 @@ impl Compressor for AutoCompactor {
     }
 }
 
-// ─── Cache-aware compaction (W1-1 step 2) ───────────────────────────────────────────────────────
-// Additive cost model: introduced + tested before it drives the cascade, so the behavior-changing
-// wiring (prefix-safe-first selection + batching, with golden updates) is a separate, reviewable step.
-
-/// A fully-specified compaction step the cache-aware planner emits; the executor applies it
-/// mechanically (all *selection* already done by the planner via the pure helpers above).
-#[derive(Debug, Clone, PartialEq)]
-pub enum CompactionStep {
-    /// Excerpt the tool results at these history-message indices. Prefix-safe in practice: tool
-    /// results are interleaved mid/late, so the earliest touched index is rarely the cache prefix.
-    Excerpt { msg_idx: Vec<usize> },
-    /// Cap the oversized text messages at these indices to `per_msg_limit`.
-    Snip { msg_idx: Vec<usize>, per_msg_limit: u32 },
-    /// Drop the `count` oldest messages (the pipeline summarizes them). Prefix-breaking at index 0.
-    DropOldest { count: usize },
-}
-
-impl CompactionStep {
-    /// The earliest history-message index this step rewrites or removes — i.e. where it invalidates
-    /// the prompt-cache prefix. `None` = prefix-safe (touches nothing). A lower index is a higher
-    /// cache cost (Anthropic keys the cache off the first N messages), so the planner prefers `None`
-    /// or a later index, and escalates to a prefix-breaking drop only when the safe steps can't free
-    /// enough.
-    pub fn invalidates_prefix_at(&self) -> Option<usize> {
-        match self {
-            CompactionStep::Excerpt { msg_idx } | CompactionStep::Snip { msg_idx, .. } => {
-                msg_idx.iter().min().copied()
-            }
-            CompactionStep::DropOldest { count } => (*count > 0).then_some(0),
-        }
-    }
-}
-
-/// The prompt-cache-invalidation index of a whole plan = the earliest break across its steps (an
-/// earlier break invalidates everything after it, so the minimum dominates the cost). `None` means
-/// the plan is entirely prefix-safe and preserves the prompt cache — the cache-aware planner's goal
-/// whenever the safe steps can free enough.
-pub fn plan_cache_cost(steps: &[CompactionStep]) -> Option<usize> {
-    steps.iter().filter_map(|s| s.invalidates_prefix_at()).min()
-}
-
 /// Compression pipeline — operates on history partition but can reference full partitions.
 pub struct CompressionPipeline {
     stages: Vec<(PressureAction, Box<dyn Compressor>)>,
@@ -590,7 +524,6 @@ impl CompressionPipeline {
                     target_tokens,
                     max_tokens,
                     self.preserve_recent_turns,
-                    &summarizer,
                     engine,
                 );
                 total_saved += res.tokens_saved;
@@ -647,7 +580,7 @@ mod tests {
         let mut ctx = ContextPartitions::new(&cfg);
         ctx.history.push(Message::user("a".repeat(800)), 200);
         // preserve_k=0: exercise the truncation transform directly (no cache-prefix protection).
-        let result = compactor.compress(&mut ctx, 0, MAX, 0, &summarizer(), &engine());
+        let result = compactor.compress(&mut ctx, 0, MAX, 0, &engine());
         assert!(result.tokens_saved > 0);
         if let Content::Text(ref t) = ctx.history.messages[0].content {
             assert!(t.contains("… [… 100 tokens omitted …] …"), "got: {t}");
@@ -665,7 +598,7 @@ mod tests {
         };
         let mut ctx = ContextPartitions::new(&cfg);
         ctx.history.push(Message::user("short"), 5);
-        let result = compactor.compress(&mut ctx, 0, MAX, 2, &summarizer(), &engine());
+        let result = compactor.compress(&mut ctx, 0, MAX, 2, &engine());
         assert_eq!(result.tokens_saved, 0);
     }
 
@@ -691,7 +624,7 @@ mod tests {
         ctx.history.token_count = 300;
 
         // preserve_k=0: exercise the excerpt transform directly (no cache-prefix protection).
-        let result = compactor.compress(&mut ctx, 0, MAX, 0, &summarizer(), &engine());
+        let result = compactor.compress(&mut ctx, 0, MAX, 0, &engine());
         assert!(result.tokens_saved > 0);
         let text = ctx.history.messages[0].content.as_text().unwrap();
         assert!(
@@ -707,7 +640,7 @@ mod tests {
         for _ in 0..8 {
             ctx.history.push(Message::user("msg"), 50);
         }
-        let result = compactor.compress(&mut ctx, 250, MAX, 2, &summarizer(), &engine());
+        let result = compactor.compress(&mut ctx, 250, MAX, 2, &engine());
         assert!(result.tokens_saved > 0);
         assert!(ctx.history.messages.len() < 8);
         // Pure executor: returns the drained messages; summary + log attribution is the pipeline's
@@ -764,7 +697,7 @@ mod tests {
         ctx.history.messages.push(msg);
         ctx.history.token_count = 300;
 
-        let result = compactor.compress(&mut ctx, 0, MAX, 2, &summarizer(), &engine());
+        let result = compactor.compress(&mut ctx, 0, MAX, 2, &engine());
         // Since call_id "keep_me" is in preserved_refs, it should not be replaced!
         assert_eq!(result.tokens_saved, 0);
         let text_opt = ctx.history.messages[0].content.as_text();
@@ -781,7 +714,7 @@ mod tests {
         for i in 0..10 {
             ctx.history.push(Message::user(format!("msg {i}")), 10);
         }
-        let result = compactor.compress(&mut ctx, 0, MAX, 2, &summarizer(), &engine());
+        let result = compactor.compress(&mut ctx, 0, MAX, 2, &engine());
         assert!(result.tokens_saved > 0);
         assert_eq!(ctx.history.messages.len(), 4); // kept last 2 turns = 4 messages
         // Pure executor: returns the drained messages; the pipeline summarizes + logs under the
@@ -820,36 +753,6 @@ mod tests {
         assert_eq!(prefix_keep_for(0, 2), 0);
     }
 
-    #[test]
-    fn compaction_step_prefix_cost() {
-        // Excerpt/Snip cost = the earliest touched message index; DropOldest breaks the prefix at 0.
-        assert_eq!(CompactionStep::Excerpt { msg_idx: vec![5, 8] }.invalidates_prefix_at(), Some(5));
-        assert_eq!(
-            CompactionStep::Snip { msg_idx: vec![3, 9], per_msg_limit: 50 }.invalidates_prefix_at(),
-            Some(3)
-        );
-        assert_eq!(CompactionStep::DropOldest { count: 4 }.invalidates_prefix_at(), Some(0));
-        assert_eq!(CompactionStep::DropOldest { count: 0 }.invalidates_prefix_at(), None);
-        // An empty selection touches nothing → prefix-safe.
-        assert_eq!(CompactionStep::Excerpt { msg_idx: vec![] }.invalidates_prefix_at(), None);
-    }
-
-    #[test]
-    fn plan_cache_cost_is_the_earliest_break() {
-        // Cost of a plan = the earliest message any step touches (an earlier break dominates).
-        let late = vec![
-            CompactionStep::Excerpt { msg_idx: vec![6] },
-            CompactionStep::Snip { msg_idx: vec![7], per_msg_limit: 50 },
-        ];
-        assert_eq!(plan_cache_cost(&late), Some(6));
-        // Escalating to a DropOldest breaks the prefix at 0 — the whole plan's cost collapses to 0.
-        let mut with_drop = late.clone();
-        with_drop.push(CompactionStep::DropOldest { count: 3 });
-        assert_eq!(plan_cache_cost(&with_drop), Some(0));
-        // An empty plan preserves the cache entirely.
-        assert_eq!(plan_cache_cost(&[]), None);
-    }
-
     #[test]
     fn pipeline_reports_accurate_prefix_invalidation() {
         // (a) DoD #4: the pipeline surfaces the earliest message any stage actually touched. On the

{deepstrike-0.2.35 → deepstrike-0.2.37}/crates/deepstrike-core/src/context/config.rs

@@ -41,10 +41,6 @@ pub struct ContextConfig {
     pub preserve_recent_turns: usize,
 
     // ── Noise reduction ──────────────────────────────────────────────────────
-    /// Include the dashboard block in the rendered system context.
-    /// Defaults to false; enable only in explicit agent-os mode.
-    pub render_dashboard: bool,
-
     /// Use verbose internal control notes (e.g. "[SYSTEM] Transaction rollback: …").
     /// Defaults to false; uses concise natural-language notes instead.
     pub verbose_control_notes: bool,
@@ -83,18 +79,16 @@ pub struct ContextConfig {
 
     /// Preview byte budget kept in context when a tool result is spooled. Default: 2 KiB.
     pub spool_preview_bytes: u32,
-}
 
-fn default_micro_compact_idle_minutes() -> u32 {
-    60
-}
-
-fn default_preserved_tool_results() -> usize {
-    5
-}
+    // ── K2: knowledge budget ─────────────────────────────────────────────
 
-fn default_autocompact_buffer() -> u32 {
-    13_000
+    /// Max share of `max_tokens` the knowledge partition may occupy. Exceeding it emits a
+    /// `KnowledgeBudgetExceeded` observation (once per cache generation) and marks the OLDEST
+    /// unpinned, non-skill entries for eviction at the next compaction/renewal boundary until the
+    /// projected usage fits. Pinned entries and `skill:`-keyed pins are never budget-evicted
+    /// (skills are governed by deactivation/lease, not the budget). `0.0` disables (no cap).
+    /// Default: 0.25.
+    pub knowledge_budget_ratio: f64,
 }
 
 impl Default for ContextConfig {
@@ -111,7 +105,6 @@ impl Default for ContextConfig {
             recovery_content_ratio: 0.25,
             preserve_recent_msgs: 4,
             preserve_recent_turns: 2,
-            render_dashboard: false,
             verbose_control_notes: false,
             collapse_assistant_narration: true,
             micro_compact_idle_minutes: 60,
@@ -119,6 +112,7 @@ impl Default for ContextConfig {
             autocompact_buffer: 13_000,
             spool_threshold_bytes: 50 * 1024,
             spool_preview_bytes: 2 * 1024,
+            knowledge_budget_ratio: 0.25,
         }
     }
 }
@@ -159,7 +153,6 @@ mod tests {
     #[test]
     fn noise_reduction_defaults_to_quiet() {
         let c = ContextConfig::default();
-        assert!(!c.render_dashboard, "dashboard should be off by default");
         assert!(!c.verbose_control_notes, "verbose notes should be off by default");
     }
 

deepstrike-0.2.37/crates/deepstrike-core/src/context/fault.rs

@@ -0,0 +1,23 @@
+use serde::{Deserialize, Serialize};
+
+/// Errors/Faults that can occur during Context VM execution or replay.
+#[derive(Debug, Clone, thiserror::Error, Serialize, Deserialize)]
+pub enum ContextFault {
+    #[error("Prompt exceeds maximum token limit: budget={budget}, actual={actual}")]
+    PromptTooLong { budget: u32, actual: u32 },
+    #[error("Missing archive chunk {seq} for session {session_id}")]
+    MissingArchive { session_id: String, seq: u64 },
+    #[error("Invalid replay at turn {turn}: {reason}")]
+    InvalidReplay { turn: u32, reason: String },
+}
+
+/// FNV-1a 64-bit — the render layer's cache-stability test fingerprint dialect.
+#[cfg(test)]
+pub(crate) fn stable_hash(bytes: &[u8]) -> u64 {
+    let mut hash = 0xcbf29ce484222325u64;
+    for byte in bytes {
+        hash ^= u64::from(*byte);
+        hash = hash.wrapping_mul(0x100000001b3);
+    }
+    hash
+}