deepstrike 0.2.30__tar.gz → 0.2.32__tar.gz

{deepstrike-0.2.30 → deepstrike-0.2.32}/Cargo.lock

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

{deepstrike-0.2.30 → deepstrike-0.2.32}/Cargo.toml

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

{deepstrike-0.2.30 → deepstrike-0.2.32}/PKG-INFO

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

{deepstrike-0.2.30 → deepstrike-0.2.32}/crates/deepstrike-core/src/governance/quota.rs

@@ -17,8 +17,15 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct ResourceQuota {
     /// Max sub-agents in the `Running` state at once. Further `Spawn`s are denied while at cap.
+    /// *Instantaneous* — vehicle-scoped (cannot span stateless replicas; spec §2.5).
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub max_concurrent_subagents: Option<u32>,
+    /// L1 (RunGroup): max sub-agents spawned *cumulatively* over the whole governance domain. Unlike
+    /// `max_concurrent_subagents` this counts every spawn ever (running + completed), seeded across
+    /// members via `group_spawns_base`, so it spans N stateless top-level runs. A hard `Deny` at cap
+    /// (a completed sibling never frees a cumulative slot).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max_total_subagents: Option<u32>,
     /// Max sub-agent nesting depth (direct children of the root loop are depth 1).
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub max_spawn_depth: Option<u32>,
@@ -37,6 +44,7 @@ impl ResourceQuota {
     /// Whether any limit is actually set (used to short-circuit the gate when fully open).
     pub fn is_open(&self) -> bool {
         self.max_concurrent_subagents.is_none()
+            && self.max_total_subagents.is_none()
             && self.max_spawn_depth.is_none()
             && self.memory_writes_per_window.is_none()
             && self.max_workflow_nodes.is_none()

{deepstrike-0.2.30 → deepstrike-0.2.32}/crates/deepstrike-core/src/runtime/kernel.rs

@@ -150,6 +150,16 @@ pub struct RunConfig {
     pub scheduler_max_wall_ms: Option<u64>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub resource_quota: Option<crate::governance::quota::ResourceQuota>,
+    /// L1 (RunGroup): cumulative tokens already spent by *other* members of this run's governance
+    /// domain, seeded at boot so the run-level token cap (`max_total_tokens`) is enforced across the
+    /// whole group, not per-vehicle. `None`/0 ⇒ no group (N=1) ⇒ pre-L1 per-kernel behavior.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub group_tokens_base: Option<u64>,
+    /// L1 (RunGroup): sub-agents already spawned by *other* members of this run's governance domain,
+    /// seeded at boot so `ResourceQuota::max_total_subagents` is enforced across the whole group.
+    /// `None`/0 ⇒ no group (N=1) ⇒ pre-L1 per-vehicle behavior.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub group_spawns_base: Option<u32>,
 }
 
 /// Build a [`GovernancePipeline`](crate::governance::pipeline::GovernancePipeline) from the ABI policy
@@ -766,6 +776,12 @@ impl KernelRuntime {
         self.sm.is_terminal()
     }
 
+    /// L1 (RunGroup): this vehicle's cumulative sub-agent spawns this run, read back by the SDK at run
+    /// end to charge the group ledger (so the next member's cumulative spawn cap is seeded correctly).
+    pub fn local_subagents_spawned(&self) -> u32 {
+        self.sm.local_subagents_spawned()
+    }
+
     pub fn step(&mut self, input: KernelInput) -> KernelStep {
         let action = match input.event {
             KernelInputEvent::SetTools { tools } => {
@@ -884,6 +900,8 @@ impl KernelRuntime {
                     attention_max_queue_size,
                     scheduler_max_wall_ms,
                     resource_quota,
+                    group_tokens_base,
+                    group_spawns_base,
                 } = config;
                 if let Some(tools) = tools {
                     self.sm.tools = tools;
@@ -924,6 +942,12 @@ impl KernelRuntime {
                 if let Some(quota) = resource_quota {
                     self.sm.set_resource_quota(quota);
                 }
+                if let Some(base) = group_tokens_base {
+                    self.sm.seed_group_budget(base);
+                }
+                if let Some(base) = group_spawns_base {
+                    self.sm.seed_group_spawns(base);
+                }
                 return KernelStep::empty(self.sm.take_observations());
             }
             KernelInputEvent::SetAttentionPolicy { max_queue_size } => {
@@ -1396,6 +1420,111 @@ mod tests {
         assert!(!runtime.state_machine().is_suspended());
     }
 
+    #[test]
+    fn group_budget_base_enforces_shared_token_cap() {
+        use crate::types::message::{Content, Message, ToolCall, ToolResult};
+
+        // Drive one tool-calling turn under a 100-token run cap, with `group_base` already spent by
+        // other members of the governance domain. The token-budget axis is checked after the tool
+        // results, against `group_base + local`.
+        fn run_one_turn(group_base: Option<u64>) -> KernelStep {
+            let mut runtime = KernelRuntime::new(LoopPolicy {
+                max_total_tokens: 100,
+                ..LoopPolicy::default()
+            });
+            runtime.step(KernelInput::new(KernelInputEvent::ConfigureRun {
+                config: RunConfig { group_tokens_base: group_base, ..RunConfig::default() },
+            }));
+            runtime.step(KernelInput::new(KernelInputEvent::StartRun {
+                task: RuntimeTask::new("task"),
+                run_spec: None,
+            }));
+            let mut msg = Message::assistant("");
+            msg.token_count = Some(10); // this vehicle's local spend this turn
+            msg.tool_calls.push(ToolCall {
+                id: "c1".into(),
+                name: "echo".into(),
+                arguments: serde_json::json!({}),
+            });
+            runtime.step(KernelInput::new(KernelInputEvent::ProviderResult {
+                message: msg,
+                observed_input_tokens: None,
+                observed_output_tokens: None,
+                now_ms: None,
+            }));
+            runtime.step(KernelInput::new(KernelInputEvent::ToolResults {
+                results: vec![ToolResult {
+                    call_id: "c1".into(),
+                    output: Content::Text("ok".into()),
+                    is_error: false,
+                    is_fatal: false,
+                    error_kind: None,
+                    token_count: None,
+                }],
+            }))
+        }
+
+        let exceeded = |step: &KernelStep| {
+            step.observations.iter().any(|o| {
+                matches!(o, KernelObservation::BudgetExceeded { budget, .. } if budget == "token_budget")
+            })
+        };
+
+        // Group already spent 95; this vehicle's 10 pushes the domain to 105 > 100 → shared cap fires.
+        assert!(
+            exceeded(&run_one_turn(Some(95))),
+            "group token budget must span the whole domain"
+        );
+        // N=1 / no group (base 0): local 10 is far under the cap → pre-L1 behavior unchanged.
+        assert!(
+            !exceeded(&run_one_turn(None)),
+            "no group seed ⇒ per-vehicle budget, well under cap"
+        );
+    }
+
+    #[test]
+    fn group_spawns_base_enforces_cumulative_spawn_cap() {
+        use crate::governance::quota::ResourceQuota;
+        use crate::types::agent::{AgentIdentity, AgentRole, AgentRunSpec};
+
+        // Cumulative cap of 2 sub-agents across the domain. Other members already spawned 2 (seeded),
+        // so this vehicle's very first spawn is denied — the cap spans the whole group.
+        let mut runtime = KernelRuntime::new(LoopPolicy::default());
+        runtime.step(KernelInput::new(KernelInputEvent::ConfigureRun {
+            config: RunConfig {
+                resource_quota: Some(ResourceQuota {
+                    max_total_subagents: Some(2),
+                    ..ResourceQuota::default()
+                }),
+                group_spawns_base: Some(2),
+                ..RunConfig::default()
+            },
+        }));
+        runtime.step(KernelInput::new(KernelInputEvent::StartRun {
+            task: RuntimeTask::new("task"),
+            run_spec: None,
+        }));
+        runtime.state_machine_mut().take_observations();
+
+        let spec = AgentRunSpec::new(
+            AgentIdentity::sub_agent("worker", "worker-session"),
+            AgentRole::Implement,
+            "do work",
+        );
+        let step = runtime.step(KernelInput::new(KernelInputEvent::SpawnSubAgent {
+            spec,
+            parent_session_id: "parent-session".to_string(),
+        }));
+
+        // Denied: domain already at the cumulative cap → rolled back, no process registered.
+        assert!(matches!(
+            step.actions.as_slice(),
+            [KernelAction::CallProvider { .. }]
+        ));
+        assert!(runtime.state_machine().agent_process("worker").is_none());
+        assert_eq!(runtime.local_subagents_spawned(), 0);
+    }
+
     #[test]
     fn default_runtime_leaves_spawn_unquota_ed() {
         use crate::types::agent::{AgentIdentity, AgentRole, AgentRunSpec};

{deepstrike-0.2.30 → deepstrike-0.2.32}/crates/deepstrike-core/src/scheduler/state_machine/gate.rs

@@ -85,6 +85,9 @@ impl LoopStateMachine {
         // M4/G5 token headroom: the run-level cumulative token cap is always set on the scheduler
         // budget, so a coordinator always sees how many tokens remain (the "use 10k tokens" signal).
         let tokens_max = self.policy.max_total_tokens;
+        // L1: report the governance domain's cumulative token spend (this vehicle + other members'
+        // seeded base) so a coordinator scales submissions to the group's remaining headroom.
+        let tokens_used = self.total_tokens.saturating_add(self.group_tokens_base);
         Some(crate::orchestration::workflow::WorkflowBudget {
             nodes_used,
             nodes_max,
@@ -93,9 +96,9 @@ impl LoopStateMachine {
             max_concurrent_subagents,
             concurrency_remaining: max_concurrent_subagents
                 .map(|m| m.saturating_sub(running_subagents)),
-            tokens_used: self.total_tokens,
+            tokens_used,
             tokens_max: Some(tokens_max),
-            tokens_remaining: Some(tokens_max.saturating_sub(self.total_tokens)),
+            tokens_remaining: Some(tokens_max.saturating_sub(tokens_used)),
         })
     }
 
@@ -122,6 +125,17 @@ impl LoopStateMachine {
                 };
             }
         }
+        if let Some(max) = quota.max_total_subagents {
+            // L1: cumulative across the whole governance domain (other members' seeded base + this
+            // vehicle's spawns ever). A hard Deny — a completed sibling never frees a cumulative slot.
+            let total = self.group_spawns_base + self.local_subagents_spawned();
+            if total >= max {
+                return Disposition::Deny {
+                    stage: "quota",
+                    reason: format!("max_total_subagents={max} reached ({total} spawned in domain)"),
+                };
+            }
+        }
         if let Some(max) = quota.max_spawn_depth {
             // Sub-agents currently parent to the root task (depth 1). Nested spawning would
             // generalize this to the spawning task's lineage depth.
@@ -161,6 +175,16 @@ impl LoopStateMachine {
                 return Disposition::Defer { slot: running };
             }
         }
+        if let Some(max) = quota.max_total_subagents {
+            // Cumulative cap is permanent (no sibling completion frees a slot) → hard Deny, not Defer.
+            let total = self.group_spawns_base + self.local_subagents_spawned();
+            if total >= max {
+                return Disposition::Deny {
+                    stage: "quota",
+                    reason: format!("max_total_subagents={max} reached ({total} spawned in domain)"),
+                };
+            }
+        }
         if let Some(max) = quota.max_spawn_depth {
             let depth = 1u32;
             if depth > max {

{deepstrike-0.2.30 → deepstrike-0.2.32}/crates/deepstrike-core/src/scheduler/state_machine/mod.rs

@@ -157,6 +157,14 @@ pub struct LoopStateMachine {
     pub observations: Vec<KernelObservation>,
     pub(super) policy: LoopPolicy,
     pub(super) total_tokens: u64,
+    /// L1 (RunGroup): cumulative tokens spent by *other* members of this run's governance domain,
+    /// seeded at boot via `seed_group_budget`. The run-level token cap is enforced against
+    /// `group_tokens_base + total_tokens` so the budget spans the whole group, not one vehicle.
+    /// 0 (default) ⇒ no group (N=1) ⇒ pre-L1 per-kernel behavior (byte-identical).
+    pub(super) group_tokens_base: u64,
+    /// L1 (RunGroup): sub-agents spawned by *other* members of this run's governance domain, seeded
+    /// at boot. `max_total_subagents` is enforced against `group_spawns_base + local spawns`. 0 ⇒ N=1.
+    pub(super) group_spawns_base: u32,
     /// When set, the next LLM call strips tools to force a text response,
     /// then terminates with this reason once the response arrives.
     pub(super) pending_termination: Option<TerminationReason>,
@@ -234,6 +242,8 @@ impl LoopStateMachine {
             observations: Vec::new(),
             policy,
             total_tokens: 0,
+            group_tokens_base: 0,
+            group_spawns_base: 0,
             pending_termination: None,
             session_history_baseline: 0,
             checkpoint: TurnCheckpoint::default(),
@@ -293,7 +303,9 @@ impl LoopStateMachine {
     fn root_tcb(&self) -> Tcb {
         let mut tcb = Tcb::root("root", self.policy.clone());
         tcb.budget.turns = self.turn;
-        tcb.budget.total_tokens = self.total_tokens;
+        // L1: the token-budget axis is evaluated against the whole governance domain's cumulative
+        // spend (this vehicle's `total_tokens` plus other members' `group_tokens_base`).
+        tcb.budget.total_tokens = self.total_tokens.saturating_add(self.group_tokens_base);
         tcb.budget.started_at_ms = self.started_at_ms;
         tcb.state = self.lifecycle();
         tcb
@@ -318,6 +330,26 @@ impl LoopStateMachine {
         self.resource_quota = Some(quota);
     }
 
+    /// L1 (RunGroup): seed the cumulative tokens already spent by other members of this run's
+    /// governance domain. The run-level token cap is then enforced against the group total. Seeding
+    /// 0 (the default) preserves pre-L1 per-vehicle behavior.
+    pub fn seed_group_budget(&mut self, tokens_spent: u64) {
+        self.group_tokens_base = tokens_spent;
+    }
+
+    /// L1 (RunGroup): seed the sub-agents already spawned by other members of this run's governance
+    /// domain. `max_total_subagents` is then enforced against the group total. 0 ⇒ pre-L1 behavior.
+    pub fn seed_group_spawns(&mut self, subagents_spawned: u32) {
+        self.group_spawns_base = subagents_spawned;
+    }
+
+    /// L1: this vehicle's cumulative sub-agent spawns this run — every child task ever registered in
+    /// the `TaskTable` (running + completed), distinct from the *instantaneous* running count. Used
+    /// for the cumulative spawn quota and read back by the SDK to charge the group ledger at run end.
+    pub fn local_subagents_spawned(&self) -> u32 {
+        self.tasks.all().iter().filter(|t| t.proc.is_some()).count() as u32
+    }
+
     /// Install the long-term memory policy (`set_memory_policy`). Once set it gates `write_memory`
     /// validation and bounds `query_memory` retrieval breadth. Not setting it (the default)
     /// preserves pre-policy behavior.
@@ -723,6 +755,9 @@ impl LoopStateMachine {
             observations: Vec::new(),
             policy,
             total_tokens: snap.total_tokens,
+            // Re-seeded from the replayed `ConfigureRun` (strategy is data, not serialized state).
+            group_tokens_base: 0,
+            group_spawns_base: 0,
             pending_termination: None,
             session_history_baseline: 0,
             checkpoint: TurnCheckpoint::default(),

{deepstrike-0.2.30 → deepstrike-0.2.32}/crates/deepstrike-core/src/signals/queue.rs

@@ -65,6 +65,34 @@ impl SignalQueue {
         self.heap.pop().map(|ps| ps.signal)
     }
 
+    /// Pop the highest-priority signal visible to `recipient`: broadcasts
+    /// (`signal.recipient == None`) plus those addressed to `recipient`.
+    /// Non-matching entries are retained (re-pushed) so heap ordering is preserved.
+    /// `recipient == None` ⇒ no filtering (drains anything; back-compat with `pop`).
+    pub(super) fn pop_for(&mut self, recipient: Option<&str>) -> Option<RuntimeSignal> {
+        let Some(recipient) = recipient else {
+            return self.pop();
+        };
+        let mut skipped: Vec<PrioritizedSignal> = Vec::new();
+        let mut found = None;
+        while let Some(ps) = self.heap.pop() {
+            let visible = ps
+                .signal
+                .recipient
+                .as_deref()
+                .is_none_or(|r| r == recipient);
+            if visible {
+                found = Some(ps.signal);
+                break;
+            }
+            skipped.push(ps);
+        }
+        for ps in skipped {
+            self.heap.push(ps);
+        }
+        found
+    }
+
     pub(super) fn len(&self) -> usize {
         self.heap.len()
     }

{deepstrike-0.2.30 → deepstrike-0.2.32}/crates/deepstrike-core/src/signals/router.rs

@@ -54,6 +54,12 @@ impl SignalRouter {
         self.queue.pop()
     }
 
+    /// Pull the next queued signal visible to `recipient` (broadcasts plus signals
+    /// addressed to it); other recipients' signals stay queued. `None` ⇒ no filter.
+    pub fn next_for(&mut self, recipient: Option<&str>) -> Option<RuntimeSignal> {
+        self.queue.pop_for(recipient)
+    }
+
     /// Number of queued signals.
     pub fn depth(&self) -> usize {
         self.queue.len()
@@ -139,6 +145,49 @@ mod tests {
         assert_eq!(router.ingest(s2, false), SignalDisposition::Dropped);
     }
 
+    #[test]
+    fn next_for_drains_recipient_plus_broadcast_only() {
+        let mut router = SignalRouter::new(100);
+        let to_a = RuntimeSignal::new(SignalSource::Gateway, SignalType::Event, Urgency::Normal, "a")
+            .with_recipient("sess-a")
+            .with_timestamp(1);
+        let to_b = RuntimeSignal::new(SignalSource::Gateway, SignalType::Event, Urgency::Normal, "b")
+            .with_recipient("sess-b")
+            .with_timestamp(2);
+        let broadcast =
+            RuntimeSignal::new(SignalSource::Cron, SignalType::Job, Urgency::Normal, "all")
+                .with_timestamp(3);
+        router.ingest(to_a, false);
+        router.ingest(to_b, false);
+        router.ingest(broadcast, false);
+
+        // Puller "sess-a" sees only its own + the broadcast, never sess-b's.
+        let first = router.next_for(Some("sess-a")).unwrap();
+        let second = router.next_for(Some("sess-a")).unwrap();
+        let mut got: Vec<_> = [first.summary.as_str(), second.summary.as_str()]
+            .iter()
+            .map(|s| s.to_string())
+            .collect();
+        got.sort();
+        assert_eq!(got, vec!["a".to_string(), "all".to_string()]);
+        assert!(router.next_for(Some("sess-a")).is_none());
+
+        // sess-b's signal is still queued for its own puller.
+        assert_eq!(router.next_for(Some("sess-b")).unwrap().summary.as_str(), "b");
+    }
+
+    #[test]
+    fn next_for_none_drains_anything() {
+        let mut router = SignalRouter::new(100);
+        router.ingest(
+            RuntimeSignal::new(SignalSource::Gateway, SignalType::Event, Urgency::Normal, "x")
+                .with_recipient("sess-a"),
+            false,
+        );
+        // No recipient filter ⇒ back-compat: drains the addressed signal too.
+        assert_eq!(router.next_for(None).unwrap().summary.as_str(), "x");
+    }
+
     #[test]
     fn clear_dedup_allows_reingest() {
         let mut router = SignalRouter::new(100);

{deepstrike-0.2.30 → deepstrike-0.2.32}/crates/deepstrike-core/src/types/signal.rs

@@ -12,6 +12,14 @@ pub struct RuntimeSignal {
     pub payload: serde_json::Value,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub dedupe_key: Option<CompactString>,
+    /// Target a specific agent/session loop. `None` ⇒ broadcast (drained by any puller).
+    /// The canonical key is the recipient's `sessionId` (see R1 / L0).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recipient: Option<CompactString>,
+    /// Optional topic for pub/sub-style fan-out. Carried through for subscribers;
+    /// multi-subscriber routing is deferred (field-only this phase).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub topic: Option<CompactString>,
     pub timestamp_ms: u64,
 }
 
@@ -56,6 +64,8 @@ impl RuntimeSignal {
             summary: summary.into(),
             payload: serde_json::Value::Null,
             dedupe_key: None,
+            recipient: None,
+            topic: None,
             timestamp_ms: 0,
         }
     }
@@ -65,6 +75,16 @@ impl RuntimeSignal {
         self
     }
 
+    pub fn with_recipient(mut self, recipient: impl Into<CompactString>) -> Self {
+        self.recipient = Some(recipient.into());
+        self
+    }
+
+    pub fn with_topic(mut self, topic: impl Into<CompactString>) -> Self {
+        self.topic = Some(topic.into());
+        self
+    }
+
     pub fn with_payload(mut self, payload: serde_json::Value) -> Self {
         self.payload = payload;
         self

{deepstrike-0.2.30 → deepstrike-0.2.32}/crates/deepstrike-py/src/lib.rs

@@ -91,13 +91,17 @@ struct RuntimeSignal {
     #[pyo3(get, set)]
     dedupe_key: Option<String>,
     #[pyo3(get, set)]
+    recipient: Option<String>,
+    #[pyo3(get, set)]
+    topic: Option<String>,
+    #[pyo3(get, set)]
     timestamp_ms: f64,
 }
 
 #[pymethods]
 impl RuntimeSignal {
     #[new]
-    #[pyo3(signature = (source, urgency, summary, signal_type="event", payload="null", dedupe_key=None, timestamp_ms=0.0))]
+    #[pyo3(signature = (source, urgency, summary, signal_type="event", payload="null", dedupe_key=None, timestamp_ms=0.0, recipient=None, topic=None))]
     fn new(
         source: String,
         urgency: String,
@@ -106,6 +110,8 @@ impl RuntimeSignal {
         payload: &str,
         dedupe_key: Option<String>,
         timestamp_ms: f64,
+        recipient: Option<String>,
+        topic: Option<String>,
     ) -> Self {
         Self {
             id: uuid::Uuid::new_v4().to_string(),
@@ -115,6 +121,8 @@ impl RuntimeSignal {
             signal_type: signal_type.into(),
             payload: payload.into(),
             dedupe_key,
+            recipient,
+            topic,
             timestamp_ms,
         }
     }
@@ -154,6 +162,12 @@ impl RuntimeSignal {
         if let Some(ref key) = self.dedupe_key {
             sig = sig.with_dedupe(key.as_str());
         }
+        if let Some(ref recipient) = self.recipient {
+            sig = sig.with_recipient(recipient.as_str());
+        }
+        if let Some(ref topic) = self.topic {
+            sig = sig.with_topic(topic.as_str());
+        }
         sig
     }
 
@@ -183,6 +197,8 @@ impl RuntimeSignal {
             summary: s.summary.to_string(),
             payload: serde_json::to_string(&s.payload).unwrap_or_else(|_| "null".into()),
             dedupe_key: s.dedupe_key.as_ref().map(|k| k.to_string()),
+            recipient: s.recipient.as_ref().map(|r| r.to_string()),
+            topic: s.topic.as_ref().map(|t| t.to_string()),
             timestamp_ms: s.timestamp_ms as f64,
         }
     }
@@ -865,6 +881,11 @@ impl KernelRuntime {
         self.inner.state_machine().turn
     }
 
+    /// L1 (RunGroup): cumulative sub-agent spawns this run, for charging the group ledger at run end.
+    fn local_subagents_spawned(&self) -> u32 {
+        self.inner.local_subagents_spawned()
+    }
+
     fn recovery_content_bytes(&self) -> u32 {
         let sm = self.inner.state_machine();
         let tokens = sm.ctx.config.recovery_content_tokens(sm.ctx.max_tokens);
@@ -922,6 +943,16 @@ impl SignalRouter {
         self.inner.next().as_ref().map(RuntimeSignal::from_rust)
     }
 
+    /// Pull the next queued signal visible to `recipient` (broadcasts plus signals
+    /// addressed to it); other recipients' signals stay queued. None ⇒ no filter.
+    #[pyo3(signature = (recipient=None))]
+    fn next_for(&mut self, recipient: Option<String>) -> Option<RuntimeSignal> {
+        self.inner
+            .next_for(recipient.as_deref())
+            .as_ref()
+            .map(RuntimeSignal::from_rust)
+    }
+
     fn depth(&self) -> usize {
         self.inner.depth()
     }

{deepstrike-0.2.30 → deepstrike-0.2.32}/deepstrike/__init__.py

@@ -38,6 +38,29 @@ from deepstrike.runtime import (
     InMemorySessionLog,
     FileSessionLog,
     SessionLog,
+    RunGroup,
+    GroupBudgetStore,
+    GroupLedger,
+    GroupMember,
+    InMemoryGroupBudgetStore,
+    SessionLogGroupBudgetStore,
+    BlackboardEvent,
+    EventStream,
+    EventViewer,
+    InMemoryEventStream,
+    is_visible_to,
+    PeerView,
+    react_by_mention,
+    director_driven,
+    round_robin,
+    first_non_empty,
+    union,
+    ReactiveSession,
+    ReactivePeerSpec,
+    Reaction,
+    ReactorContext,
+    ReactorTurn,
+    read_recent_tool,
     ProviderReplay,
     FilteredExecutionPlane,
     SubAgentOrchestrator,
@@ -137,6 +160,29 @@ __all__ = [
     "InMemorySessionLog",
     "FileSessionLog",
     "SessionLog",
+    "RunGroup",
+    "GroupBudgetStore",
+    "GroupLedger",
+    "GroupMember",
+    "InMemoryGroupBudgetStore",
+    "SessionLogGroupBudgetStore",
+    "BlackboardEvent",
+    "EventStream",
+    "EventViewer",
+    "InMemoryEventStream",
+    "is_visible_to",
+    "PeerView",
+    "react_by_mention",
+    "director_driven",
+    "round_robin",
+    "first_non_empty",
+    "union",
+    "ReactiveSession",
+    "ReactivePeerSpec",
+    "Reaction",
+    "ReactorContext",
+    "ReactorTurn",
+    "read_recent_tool",
     "ProviderReplay",
     "ProviderReplay",
     "ProviderReplay",