deepstrike 0.2.80__tar.gz → 0.2.81__tar.gz

{deepstrike-0.2.80 → deepstrike-0.2.81}/Cargo.lock

@@ -293,7 +293,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-core"
-version = "0.2.80"
+version = "0.2.81"
 dependencies = [
  "compact_str",
  "deepstrike-tokenizer",
@@ -307,7 +307,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-lab"
-version = "0.2.80"
+version = "0.2.81"
 dependencies = [
  "serde",
  "serde_json",
@@ -315,7 +315,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-node"
-version = "0.2.80"
+version = "0.2.81"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -327,7 +327,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-py"
-version = "0.2.80"
+version = "0.2.81"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -338,7 +338,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-sdk"
-version = "0.2.80"
+version = "0.2.81"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -376,7 +376,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-tokenizer"
-version = "0.2.80"
+version = "0.2.81"
 dependencies = [
  "pretty_assertions",
  "tiktoken-rs",
@@ -384,7 +384,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-wasm"
-version = "0.2.80"
+version = "0.2.81"
 dependencies = [
  "compact_str",
  "deepstrike-core",

{deepstrike-0.2.80 → deepstrike-0.2.81}/Cargo.toml

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

{deepstrike-0.2.80 → deepstrike-0.2.81}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepstrike
-Version: 0.2.80
+Version: 0.2.81
 Requires-Dist: httpx>=0.27
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: anyio>=4.0

deepstrike-0.2.81/crates/deepstrike-core/src/context/graph.rs

@@ -0,0 +1,147 @@
+//! Plan task 7.1 · the item graph: typed, directed edges between the items of one operation.
+//!
+//! The item table says what each item is; the graph says how items relate: which call a tool result
+//! answers, which history item referenced which knowledge item and by what evidence, what a read
+//! brought back, what a provider summary covers. Edges are recorded from committed input only (D1),
+//! so a replay rebuilds the same graph, and they travel in the checkpoint.
+//!
+//! The graph is bounded. An edge whose two ends are both still resident is always kept; of the
+//! edges that touch an item which has left, only the latest [`RETIRED_EDGE_CAP`] are kept and the
+//! rest are counted in [`ItemGraph::omitted`]. In 0.2.81 the graph only reports: no decision reads it.
+
+use std::collections::BTreeSet;
+
+use crate::context::item::{ExternalEdge, HISTORY_ITEM_DETAIL_CAP, ItemEdge, ItemId};
+
+/// Edges touching a retired item that the graph keeps, newest last.
+pub const RETIRED_EDGE_CAP: usize = HISTORY_ITEM_DETAIL_CAP;
+
+/// Edges the graph holds before it prunes against residency.
+pub const EDGE_PRUNE_AT: usize = 1024;
+
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct ItemGraph {
+    edges: Vec<ItemEdge>,
+    omitted: u32,
+    /// Plan task 7.4 · edges to items of other runs, the latest [`RETIRED_EDGE_CAP`] kept.
+    external: Vec<ExternalEdge>,
+}
+
+impl ItemGraph {
+    /// Record `edge` unless it is degenerate (an untracked end, a self-loop) or already recorded.
+    /// Returns whether it was added.
+    pub fn add(&mut self, edge: ItemEdge) -> bool {
+        if edge.from == 0 || edge.to == 0 || edge.from == edge.to {
+            return false;
+        }
+        if self
+            .edges
+            .iter()
+            .any(|e| e.from == edge.from && e.to == edge.to && e.relation == edge.relation)
+        {
+            return false;
+        }
+        self.edges.push(edge);
+        true
+    }
+
+    /// Whether the graph has grown past [`EDGE_PRUNE_AT`] and should be pruned.
+    pub fn over_limit(&self) -> bool {
+        self.edges.len() > EDGE_PRUNE_AT
+    }
+
+    /// Keep every edge whose ends are both in `resident`, and the latest [`RETIRED_EDGE_CAP`] of
+    /// the others; count what is dropped. If resident edges alone still exceed
+    /// [`EDGE_PRUNE_AT`], the oldest go too.
+    pub fn prune(&mut self, resident: &BTreeSet<ItemId>) {
+        let live = |edge: &ItemEdge| resident.contains(&edge.from) && resident.contains(&edge.to);
+        let retired = self.edges.iter().filter(|edge| !live(edge)).count();
+        let mut drop_retired = retired.saturating_sub(RETIRED_EDGE_CAP);
+        let before = self.edges.len();
+        self.edges.retain(|edge| {
+            if live(edge) || drop_retired == 0 {
+                return true;
+            }
+            drop_retired -= 1;
+            false
+        });
+        let overflow = self.edges.len().saturating_sub(EDGE_PRUNE_AT);
+        self.edges.drain(..overflow);
+        self.omitted = self.omitted.saturating_add((before - self.edges.len()) as u32);
+    }
+
+    /// Record an edge to another run's item; the oldest goes past [`RETIRED_EDGE_CAP`].
+    pub fn add_external(&mut self, edge: ExternalEdge) -> bool {
+        if edge.from == 0 || self.external.contains(&edge) {
+            return false;
+        }
+        self.external.push(edge);
+        if self.external.len() > RETIRED_EDGE_CAP {
+            self.external.remove(0);
+            self.omitted = self.omitted.saturating_add(1);
+        }
+        true
+    }
+
+    pub fn external(&self) -> &[ExternalEdge] {
+        &self.external
+    }
+
+    pub fn edges(&self) -> &[ItemEdge] {
+        &self.edges
+    }
+
+    /// Edges dropped by pruning over the run.
+    pub fn omitted(&self) -> u32 {
+        self.omitted
+    }
+
+    /// The recorded edges into `to`.
+    pub fn in_edges(&self, to: ItemId) -> impl Iterator<Item = &ItemEdge> {
+        self.edges.iter().filter(move |edge| edge.to == to)
+    }
+
+    /// Rebuild from a checkpoint.
+    pub fn restore(&mut self, edges: Vec<ItemEdge>, external: Vec<ExternalEdge>, omitted: u32) {
+        self.edges = edges;
+        self.external = external;
+        self.omitted = omitted;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::context::item::Relation;
+
+    fn edge(from: ItemId, to: ItemId) -> ItemEdge {
+        ItemEdge { from, to, relation: Relation::ReferencesLexical, turn: 0 }
+    }
+
+    #[test]
+    fn degenerate_and_repeated_edges_are_not_recorded() {
+        let mut graph = ItemGraph::default();
+        assert!(!graph.add(edge(0, 3)));
+        assert!(!graph.add(edge(3, 3)));
+        assert!(graph.add(edge(4, 3)));
+        assert!(!graph.add(edge(4, 3)));
+        assert!(graph.add(ItemEdge { relation: Relation::ReferencesStrong, ..edge(4, 3) }));
+        assert_eq!(graph.in_edges(3).count(), 2);
+    }
+
+    #[test]
+    fn pruning_keeps_resident_edges_and_the_latest_retired_ones() {
+        let mut graph = ItemGraph::default();
+        let total = RETIRED_EDGE_CAP as u64 + 5;
+        for from in 1..=total {
+            graph.add(edge(from + 1000, 1));
+        }
+        graph.add(edge(2, 3));
+        let resident = BTreeSet::from([2, 3]);
+        graph.prune(&resident);
+        assert_eq!(graph.omitted(), 5);
+        assert_eq!(graph.edges().len(), RETIRED_EDGE_CAP + 1);
+        assert_eq!(graph.edges()[0].from, 1006, "the oldest retired edges go first");
+        assert!(graph.edges().contains(&edge(2, 3)));
+    }
+}

{deepstrike-0.2.80 → deepstrike-0.2.81}/crates/deepstrike-core/src/context/item.rs

@@ -19,6 +19,80 @@ pub const RECALL_LEASE_TURNS: u32 = 8;
 /// (a message restored from a checkpoint without item ids).
 pub type ItemId = u64;
 
+/// Plan task 7.1 · what an edge of the item graph says about its two ends. Fixed and small: the
+/// graph records relations the kernel already acts on, not arbitrary links.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Relation {
+    /// A tool result answers the call its assistant item made.
+    Answers,
+    /// A history item names a knowledge item (its key or record id).
+    ReferencesStrong,
+    /// A history item shares a knowledge item's distinctive terms.
+    ReferencesLexical,
+    /// The item that asked (`read_result`, `memory`) read the target back.
+    ReadsBack,
+    /// A provider summary stands in for the item it covered.
+    Summarizes,
+    /// A memory hit in history gives a recalled index line's record in full.
+    Expands,
+    /// Plan task 7.4 · a child run's copy of knowledge it inherited → the parent run's item.
+    InheritedFrom,
+    /// Plan task 7.4 · the item that read a dependency output back → the run that produced it.
+    DependsOn,
+}
+
+impl Relation {
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Answers => "answers",
+            Self::ReferencesStrong => "references_strong",
+            Self::ReferencesLexical => "references_lexical",
+            Self::ReadsBack => "reads_back",
+            Self::Summarizes => "summarizes",
+            Self::Expands => "expands",
+            Self::InheritedFrom => "inherited_from",
+            Self::DependsOn => "depends_on",
+        }
+    }
+}
+
+/// One directed edge `from → to`, recorded on the turn the kernel observed it. Built only from
+/// committed input (D1), so a replay rebuilds the same graph.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct ItemEdge {
+    pub from: ItemId,
+    pub to: ItemId,
+    pub relation: Relation,
+    #[serde(default)]
+    pub turn: u32,
+}
+
+/// Plan task 7.4 · an item of another run: a parent operation's item, or a dependency's output.
+#[derive(Debug, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct ExternalItem {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub operation: Option<String>,
+    /// The workflow agent whose output it is.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub agent: Option<String>,
+    #[serde(default, skip_serializing_if = "is_zero_u64")]
+    pub item: ItemId,
+}
+
+/// Plan task 7.4 · an edge from an item of this run to an item of another run.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct ExternalEdge {
+    pub from: ItemId,
+    pub to: ExternalItem,
+    pub relation: Relation,
+    #[serde(default)]
+    pub turn: u32,
+}
+
 /// The identity a history message carries as an item.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
@@ -330,6 +404,9 @@ impl HistoryItemRecord {
 /// One knowledge-tier item.
 #[derive(Debug, Clone)]
 pub struct ContextItem {
+    /// From the operation's item allocator, shared with history; an upsert keeps it. `0` until the
+    /// manager admits the item (a partition used on its own never allocates).
+    pub id: ItemId,
     /// `None` appends an unkeyed item. Keyed items upsert.
     pub key: Option<CompactString>,
     pub origin: ItemOrigin,
@@ -395,6 +472,7 @@ impl ContextItem {
     ) -> Self {
         let lease = Lease::for_item(origin, pinned);
         Self {
+            id: 0,
             key,
             origin,
             lease,
@@ -441,6 +519,7 @@ impl ContextItem {
 
     pub fn record(&self, end: Option<ItemEnd>) -> ItemRecord {
         ItemRecord {
+            id: self.id,
             key: self.key.as_ref().map(ToString::to_string),
             origin: self.origin,
             tokens: self.tokens,
@@ -454,6 +533,8 @@ impl ContextItem {
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct ItemRecord {
+    #[serde(default, skip_serializing_if = "is_zero_u64")]
+    pub id: ItemId,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub key: Option<String>,
     pub origin: ItemOrigin,