deepstrike 0.2.16__tar.gz → 0.2.17__tar.gz

{deepstrike-0.2.16 → deepstrike-0.2.17}/Cargo.lock

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

{deepstrike-0.2.16 → deepstrike-0.2.17}/Cargo.toml

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

{deepstrike-0.2.16 → deepstrike-0.2.17}/PKG-INFO

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

{deepstrike-0.2.16 → deepstrike-0.2.17}/crates/deepstrike-core/src/orchestration/workflow/mod.rs

@@ -102,6 +102,12 @@ pub struct WorkflowNode {
     /// Control-flow kind. Default `Spawn` (run once).
     #[serde(default, skip_serializing_if = "is_spawn")]
     pub kind: NodeKind,
+    /// M4/G5: optional per-node cumulative token cap. The kernel carries it to the spawn descriptor;
+    /// the SDK sets the node's child-run `max_total_tokens` to it, so an expensive node self-terminates
+    /// at the cap (the "use N tokens" budget, applied per node). Additive: omitted on the wire when
+    /// `None`.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_budget: Option<u64>,
     /// Indices into [`WorkflowSpec::nodes`] this node depends on.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub depends_on: Vec<usize>,
@@ -128,10 +134,17 @@ impl WorkflowNode {
             trust: NodeTrust::Trusted,
             output_schema: None,
             kind: NodeKind::Spawn,
+            token_budget: None,
             depends_on: Vec::new(),
         }
     }
 
+    /// M4/G5: cap this node's child run at `tokens` cumulative tokens.
+    pub fn with_token_budget(mut self, tokens: u64) -> Self {
+        self.token_budget = Some(tokens);
+        self
+    }
+
     /// Make this a loop node: re-run the agent up to `max_iters` times before completing.
     /// Dependents wait for the whole loop to finish.
     pub fn with_loop(mut self, max_iters: usize) -> Self {

{deepstrike-0.2.16 → deepstrike-0.2.17}/crates/deepstrike-core/src/orchestration/workflow/run.rs

@@ -62,6 +62,24 @@ pub struct WorkflowSpawnInfo {
     /// (entrant / spawn / loop / classify) node. Additive ABI: omitted on the wire when `None`.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub judge_match: Option<JudgeMatch>,
+    /// Present only for a [`NodeKind::Loop`] iteration spawn (A#2 v2): the loop's `max_iters`. It
+    /// both *marks* the spawn as a loop iteration — so the SDK knows to solicit and report a
+    /// `loop_continue` stop signal from the agent — and gives the cap for the agent's prompt. `None`
+    /// for every non-loop node. Mirrors how `reducer` / `judge_match` distinguish reduce / judge
+    /// spawns. Additive ABI: omitted on the wire when `None`.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub loop_max_iters: Option<usize>,
+    /// Present only for a [`NodeKind::Classify`] spawn (A#2): the branch labels the classifier must
+    /// choose among. Non-empty *marks* the spawn as a classifier — the SDK instructs the agent to
+    /// pick exactly one label and reports it in the result's `classify_branch`. Empty for every
+    /// non-classify node. Additive ABI: omitted on the wire when empty.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub classify_labels: Vec<String>,
+    /// M4/G5: the node's per-node cumulative token cap, if set. The SDK sets the child run's
+    /// `max_total_tokens` to this so the node self-terminates at the cap. Additive ABI: omitted when
+    /// `None`.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_budget: Option<u64>,
 }
 
 fn default_trust() -> String {
@@ -102,6 +120,18 @@ pub struct WorkflowBudget {
     /// how many of a submission's nodes can spawn *immediately* rather than deferring for a slot.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub concurrency_remaining: Option<usize>,
+    /// M4/G5: cumulative tokens spent across the run so far (the scheduler's `total_tokens`).
+    /// `#[serde(default)]` keeps older JSON (without this field) deserializing to 0 — additive ABI.
+    #[serde(default)]
+    pub tokens_used: u64,
+    /// M4/G5: `SchedulerBudget::max_total_tokens` — the run's cumulative token cap.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tokens_max: Option<u64>,
+    /// M4/G5: `tokens_max - tokens_used` (saturating) — how many tokens remain before the run-level
+    /// token budget terminates the workflow. Lets a coordinator scale its next submission to token
+    /// headroom (the analogue of "use 10k tokens").
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tokens_remaining: Option<u64>,
 }
 
 fn role_label(role: AgentRole) -> &'static str {
@@ -307,6 +337,17 @@ impl WorkflowRun {
             ),
             _ => (None, Vec::new()),
         };
+        // A#2 v2 / classify: surface the control-flow kind so the SDK can solicit + report the
+        // matching result signal (`loop_continue` / `classify_branch`), mirroring how `reducer` /
+        // `judge_match` distinguish reduce / judge spawns.
+        let loop_max_iters = match &n.kind {
+            NodeKind::Loop { max_iters } => Some(*max_iters),
+            _ => None,
+        };
+        let classify_labels = match &n.kind {
+            NodeKind::Classify { branches } => branches.iter().map(|b| b.label.clone()).collect(),
+            _ => Vec::new(),
+        };
         WorkflowSpawnInfo {
             agent_id: self.current_agent_id(node),
             goal: n.task.goal.clone(),
@@ -319,6 +360,9 @@ impl WorkflowRun {
             reducer,
             input_agent_ids,
             judge_match: self.judge_matches.get(&node).cloned(),
+            loop_max_iters,
+            classify_labels,
+            token_budget: n.token_budget,
         }
     }
 
@@ -640,6 +684,7 @@ impl WorkflowRun {
 
     pub fn submit_nodes(&mut self, nodes: Vec<WorkflowNode>) -> Vec<usize> {
         let base = self.nodes.len();
+        let batch_len = nodes.len();
         let mut ids = Vec::with_capacity(nodes.len());
         for (offset, mut node) in nodes.into_iter().enumerate() {
             let deps: Vec<usize> = node
@@ -649,6 +694,21 @@ impl WorkflowRun {
                 .map(|&d| base + d)
                 .collect();
             node.depends_on = deps.clone();
+            // A#2/G2: a submitted `Classify` node's branch indices are *batch-relative* — they point
+            // at other nodes in this same submission, whose absolute graph index the submitter cannot
+            // know. Remap each branch node index `d` (0-based within the batch) to its absolute index
+            // `base + d`, dropping out-of-range references. Mirrors the `depends_on` batch-relative
+            // convention; without it a runtime-submitted classifier would prune the wrong nodes.
+            if let NodeKind::Classify { branches } = &mut node.kind {
+                for branch in branches.iter_mut() {
+                    branch.nodes = branch
+                        .nodes
+                        .iter()
+                        .filter(|&&d| d < batch_len)
+                        .map(|&d| base + d)
+                        .collect();
+                }
+            }
             let idx = self.graph.add(node.task.clone(), deps);
             debug_assert_eq!(idx, self.nodes.len(), "graph/nodes index drift");
             self.nodes.push(node);
@@ -702,6 +762,21 @@ impl WorkflowRun {
         (completed, failed)
     }
 
+    /// #2-B abort: outcome when the workflow is preempted — every node that has not already
+    /// `Completed` counts as `failed` (running / ready / pending all abort). Used to emit a terminal
+    /// `WorkflowCompleted` when an `InterruptNow` tears the whole `WorkflowRun` down.
+    pub fn abort_outcome(&self) -> (Vec<String>, Vec<String>) {
+        let mut completed = Vec::new();
+        let mut failed = Vec::new();
+        for i in 0..self.graph.len() {
+            match self.graph.get(i).map(|n| n.status) {
+                Some(TaskStatus::Completed) => completed.push(node_agent_id(i)),
+                _ => failed.push(node_agent_id(i)),
+            }
+        }
+        (completed, failed)
+    }
+
     /// Total node count.
     pub fn len(&self) -> usize {
         self.graph.len()
@@ -1018,6 +1093,110 @@ mod tests {
         assert!(run.is_complete(), "submitted loop ran its 2 iterations then finished");
     }
 
+    #[test]
+    fn submitted_tournament_runs_bracket_then_promotes_submitted_dependent() {
+        // M2: an agent can submit a Tournament *controller* (plus a dependent) at runtime. The
+        // controller expands into entrant children + a judge via the same bracket machinery, and the
+        // dependent's batch-relative `depends_on` links it to the submitted controller.
+        use crate::orchestration::workflow::{WorkflowNode, WorkflowSpec};
+        use crate::types::agent::AgentRole;
+
+        let spec = WorkflowSpec::new(vec![WorkflowNode::new(
+            RuntimeTask::new("root"),
+            AgentRole::Implement,
+        )]);
+        let mut run = WorkflowRun::new(&spec, "sess").unwrap();
+        let id0 = run.current_agent_id(0);
+        run.mark_spawned(0, &id0);
+        run.record_completion(&id0, done());
+
+        // Submit [tournament@batch0, dependent@batch1 depends_on [0]] (batch-relative).
+        let ids = run.submit_nodes(vec![
+            WorkflowNode::new(RuntimeTask::new("pick best"), AgentRole::Plan)
+                .with_tournament(vec![RuntimeTask::new("x"), RuntimeTask::new("y")]),
+            WorkflowNode::new(RuntimeTask::new("use winner"), AgentRole::Implement)
+                .with_depends_on(vec![0]),
+        ]);
+        assert_eq!(ids, vec![1, 2], "appended controller=1, dependent=2");
+
+        // Controller (node 1) expands into 2 entrant children (3,4); spawns no agent of its own.
+        let entrants = spawn_round(&mut run);
+        let entrant_nodes: Vec<usize> = entrants.iter().map(|(n, _)| *n).collect();
+        assert_eq!(entrant_nodes, vec![3, 4], "two entrant children appended after the dependent");
+        for (_, id) in &entrants {
+            run.record_completion(id, done());
+        }
+
+        // One judge over the two entrants; dependent (node 2) gated until the bracket resolves.
+        let r1 = spawn_round(&mut run);
+        assert_eq!(r1.len(), 1, "one judge for two entrants");
+        let jm = run.spawn_info(r1[0].0).judge_match.expect("judge carries a match");
+        assert_eq!(jm, JudgeMatch { left: node_agent_id(3), right: node_agent_id(4) });
+
+        // Entrant 3 wins → controller completes with the champion → dependent unblocks.
+        run.record_completion(&r1[0].1, judge_done(&node_agent_id(3)));
+        assert_eq!(run.ready_batch(), vec![2], "submitted dependent unblocks after the bracket");
+        let last = spawn_round(&mut run);
+        assert_eq!(last, vec![(2, node_agent_id(2))]);
+        run.record_completion(&last[0].1, done());
+        assert!(run.is_complete());
+    }
+
+    #[test]
+    fn submitted_classify_remaps_branch_indices_and_prunes() {
+        // M2: a submitted Classify node's branch `nodes` are batch-relative; `submit_nodes` remaps
+        // them to absolute indices so the chosen branch runs and the rest are pruned. Without the
+        // remap a runtime-submitted classifier would prune the wrong nodes.
+        use crate::orchestration::workflow::{ClassifyBranch, NodeKind, WorkflowNode, WorkflowSpec};
+        use crate::types::agent::AgentRole;
+
+        let spec = WorkflowSpec::new(vec![WorkflowNode::new(
+            RuntimeTask::new("root"),
+            AgentRole::Implement,
+        )]);
+        let mut run = WorkflowRun::new(&spec, "sess").unwrap();
+        let id0 = run.current_agent_id(0);
+        run.mark_spawned(0, &id0);
+        run.record_completion(&id0, done());
+
+        // Submit [classify@batch0 (a→[1] b→[2]), branchA@batch1 dep[0], branchB@batch2 dep[0]].
+        let ids = run.submit_nodes(vec![
+            WorkflowNode::new(RuntimeTask::new("route"), AgentRole::Plan).with_classify(vec![
+                ClassifyBranch { label: "a".into(), nodes: vec![1] },
+                ClassifyBranch { label: "b".into(), nodes: vec![2] },
+            ]),
+            WorkflowNode::new(RuntimeTask::new("branch-a"), AgentRole::Implement)
+                .with_depends_on(vec![0]),
+            WorkflowNode::new(RuntimeTask::new("branch-b"), AgentRole::Implement)
+                .with_depends_on(vec![0]),
+        ]);
+        assert_eq!(ids, vec![1, 2, 3], "classify=1, branchA=2, branchB=3");
+
+        // Branch indices were remapped batch-relative → absolute: a→[2], b→[3].
+        if let NodeKind::Classify { branches } = &run.nodes[1].kind {
+            assert_eq!(branches[0].nodes, vec![2], "branch a remapped to absolute node 2");
+            assert_eq!(branches[1].nodes, vec![3], "branch b remapped to absolute node 3");
+        } else {
+            panic!("node 1 should be a classify node");
+        }
+
+        // Classifier picks "a" → branch-a (node 2) runs, branch-b (node 3) is pruned/failed.
+        let r = spawn_round(&mut run);
+        assert_eq!(r, vec![(1, node_agent_id(1))], "classifier runs first");
+        run.record_completion(&r[0].1, LoopResult { classify_branch: Some("a".into()), ..done() });
+
+        assert_eq!(run.ready_batch(), vec![2], "only branch a is enabled");
+        let (_c, failed) = run.outcome();
+        assert!(failed.contains(&node_agent_id(3)), "branch b pruned/failed");
+
+        let last = spawn_round(&mut run);
+        assert_eq!(last, vec![(2, node_agent_id(2))]);
+        run.record_completion(&last[0].1, done());
+        assert!(run.is_complete());
+        let (completed, _f) = run.outcome();
+        assert!(completed.contains(&node_agent_id(1)) && completed.contains(&node_agent_id(2)));
+    }
+
     #[test]
     fn loop_node_iterates_with_distinct_ids_then_promotes_dependent() {
         use crate::orchestration::workflow::{WorkflowNode, WorkflowSpec};
@@ -1185,6 +1364,52 @@ mod tests {
         assert_eq!(t.model_hint, None);
     }
 
+    #[test]
+    fn spawn_info_carries_loop_and_classify_hints() {
+        use crate::orchestration::workflow::{ClassifyBranch, WorkflowNode, WorkflowSpec};
+        use crate::types::agent::AgentRole;
+
+        let spec = WorkflowSpec::new(vec![
+            // 0: loop node → descriptor carries the cap so the SDK knows to solicit `loop_continue`.
+            WorkflowNode::new(RuntimeTask::new("refine"), AgentRole::Implement).with_loop(3),
+            // 1: classify node → descriptor carries the branch labels so the SDK can instruct + report.
+            WorkflowNode::new(RuntimeTask::new("route"), AgentRole::Plan).with_classify(vec![
+                ClassifyBranch { label: "bug".into(), nodes: vec![] },
+                ClassifyBranch { label: "feature".into(), nodes: vec![] },
+            ]),
+            // 2: plain spawn → neither hint present.
+            WorkflowNode::new(RuntimeTask::new("act"), AgentRole::Implement),
+        ]);
+        let run = WorkflowRun::new(&spec, "sess").unwrap();
+
+        let l = run.spawn_info(0);
+        assert_eq!(l.loop_max_iters, Some(3));
+        assert!(l.classify_labels.is_empty());
+        assert_eq!(l.token_budget, None, "no token budget unless set");
+
+        let c = run.spawn_info(1);
+        assert_eq!(c.classify_labels, vec!["bug".to_string(), "feature".to_string()]);
+        assert_eq!(c.loop_max_iters, None);
+
+        let s = run.spawn_info(2);
+        assert_eq!(s.loop_max_iters, None);
+        assert!(s.classify_labels.is_empty());
+    }
+
+    #[test]
+    fn spawn_info_carries_token_budget() {
+        use crate::orchestration::workflow::{WorkflowNode, WorkflowSpec};
+        use crate::types::agent::AgentRole;
+
+        let spec = WorkflowSpec::new(vec![
+            WorkflowNode::new(RuntimeTask::new("expensive"), AgentRole::Implement).with_token_budget(10_000),
+            WorkflowNode::new(RuntimeTask::new("plain"), AgentRole::Implement),
+        ]);
+        let run = WorkflowRun::new(&spec, "sess").unwrap();
+        assert_eq!(run.spawn_info(0).token_budget, Some(10_000));
+        assert_eq!(run.spawn_info(1).token_budget, None);
+    }
+
     // ── Tournament node (A#2) ───────────────────────────────────────────────────────────────────
 
     use crate::orchestration::workflow::{NodeKind, WorkflowNode, WorkflowSpec};

{deepstrike-0.2.16 → deepstrike-0.2.17}/crates/deepstrike-core/src/runtime/event_log.rs

@@ -88,7 +88,7 @@ pub fn category_for_kind(kind: &str) -> KernelEventCategory {
         | "context_renewed"
         | "large_result_spooled" => KernelEventCategory::Mm,
         "agent_process_changed" | "agent_spawned" | "workflow_batch_spawned"
-        | "workflow_completed" => KernelEventCategory::Proc,
+        | "workflow_completed" | "agent_preempted" => KernelEventCategory::Proc,
         "signal_disposed" => KernelEventCategory::Ipc,
         "memory_written" | "memory_queried" | "memory_validation_failed" => KernelEventCategory::Mm,
         _ => KernelEventCategory::Sched,
@@ -110,6 +110,7 @@ pub const KERNEL_OBSERVATION_KINDS: &[&str] = &[
     "agent_process_changed",
     "workflow_batch_spawned",
     "workflow_completed",
+    "agent_preempted",
     "tool_gated",
     "signal_disposed",
     "budget_exceeded",

{deepstrike-0.2.16 → deepstrike-0.2.17}/crates/deepstrike-core/src/runtime/kernel.rs

@@ -270,6 +270,21 @@ pub enum KernelInputEvent {
         #[serde(default, skip_serializing_if = "Option::is_none")]
         submitter_agent_id: Option<String>,
     },
+    /// M5/G1: an agent authors a whole `WorkflowSpec` (the article's "model writes its own harness").
+    /// The agent-reachable analogue of the host-only `LoadWorkflow`: **bootstraps** the DAG when no
+    /// workflow is active, else **flattens** the spec's nodes onto the running DAG (bootstrap-or-flatten,
+    /// one kernel / one quota — never a workflow stack). Gated by `Syscall::LoadWorkflow`. Additive ABI:
+    /// a brand-new variant, byte-identical on the wire for SDKs that never send it.
+    SubmitWorkflow {
+        spec: crate::orchestration::workflow::WorkflowSpec,
+        /// Used only on bootstrap (no workflow active) to seed child session ids; ignored on flatten.
+        #[serde(default)]
+        parent_session_id: String,
+        /// G1: the authoring node's agent id (flatten case) — a quarantined author's nodes are coerced
+        /// quarantined. Additive: omitted (top-level bootstrap) → `None` → the run's own trust applies.
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        submitter_agent_id: Option<String>,
+    },
     /// Feed long-term memory entries into the knowledge partition (page-in).
     /// SDK performs retrieval I/O; kernel only applies the result.
     PageIn {
@@ -480,6 +495,17 @@ pub enum KernelObservation {
         #[serde(default, skip_serializing_if = "Vec::is_empty")]
         failed: Vec<String>,
     },
+    /// #2-B: a high-urgency `InterruptNow` signal preempted in-flight work. The kernel has already
+    /// marked these agents `Done(UserAbort)` and reclaimed the root to reason about the interrupt; the
+    /// SDK must ABORT the listed in-flight child runs and discard their results (do NOT feed their
+    /// `SubAgentCompleted`). Additive variant (`agent_preempted`) — byte-identical for SDKs that never
+    /// receive it.
+    AgentPreempted {
+        turn: u32,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        agent_ids: Vec<String>,
+        reason: String,
+    },
     /// A tool call needs user approval (governance `AskUser`). Not blocked by the
     /// kernel — the SDK must obtain approval before executing the named call.
     ToolGated {
@@ -866,6 +892,21 @@ impl KernelRuntime {
                 }
                 return KernelStep::single(action, self.sm.take_observations());
             }
+            KernelInputEvent::SubmitWorkflow {
+                spec,
+                parent_session_id,
+                submitter_agent_id,
+            } => {
+                let action = self.sm.submit_workflow(
+                    spec,
+                    &parent_session_id,
+                    submitter_agent_id.as_deref(),
+                );
+                if matches!(action, LoopAction::AwaitingResume) {
+                    return KernelStep::empty(self.sm.take_observations());
+                }
+                return KernelStep::single(action, self.sm.take_observations());
+            }
             KernelInputEvent::SetMemoryPolicy {
                 memory_path,
                 stale_warning_days,
@@ -1922,6 +1963,61 @@ mod tests {
         )));
     }
 
+    #[test]
+    fn submit_workflow_input_bootstraps_a_dag_over_the_abi() {
+        // M5/G1: a top-level agent authors a whole spec over the ABI (full serde round-trip of
+        // SubmitWorkflow + WorkflowSpec) with no workflow active → the kernel bootstraps and drives it.
+        use crate::orchestration::workflow::{WorkflowNode, WorkflowSpec};
+        use crate::types::agent::AgentRole;
+        use crate::types::result::{LoopResult, SubAgentResult, TerminationReason};
+
+        let mut runtime = KernelRuntime::new(LoopPolicy::default());
+        runtime.step(KernelInput::new(KernelInputEvent::StartRun {
+            task: RuntimeTask::new("parent task"),
+            run_spec: None,
+        }));
+        runtime.state_machine_mut().take_observations();
+
+        // No LoadWorkflow first — the agent itself authors the spec.
+        let spec = WorkflowSpec::new(vec![WorkflowNode::new(
+            RuntimeTask::new("authored root"),
+            AgentRole::Implement,
+        )]);
+        let event = KernelInputEvent::SubmitWorkflow {
+            spec,
+            parent_session_id: "sess".to_string(),
+            submitter_agent_id: None,
+        };
+        let json = serde_json::to_string(&event).expect("serialize");
+        let parsed: KernelInputEvent = serde_json::from_str(&json).expect("deserialize");
+        let step = runtime.step(KernelInput::new(parsed));
+        // The authored node bootstraps as wf-node0 in a workflow batch.
+        assert!(step.observations.iter().any(|o| matches!(
+            o,
+            KernelObservation::WorkflowBatchSpawned { nodes, .. }
+                if nodes.len() == 1 && nodes[0].agent_id == "wf-node0" && nodes[0].goal == "authored root"
+        )));
+
+        let step = runtime.step(KernelInput::new(KernelInputEvent::SubAgentCompleted {
+            result: SubAgentResult {
+                agent_id: compact_str::CompactString::new("wf-node0"),
+                result: LoopResult {
+                    termination: TerminationReason::Completed,
+                    final_message: None,
+                    turns_used: 1,
+                    total_tokens_used: 1,
+                    loop_continue: None,
+                    classify_branch: None,
+                    tournament_winner: None,
+                },
+            },
+        }));
+        assert!(step.observations.iter().any(|o| matches!(
+            o,
+            KernelObservation::WorkflowCompleted { completed, .. } if completed.len() == 1
+        )));
+    }
+
     #[test]
     fn load_workflow_resumes_from_completed_nodes() {
         use crate::orchestration::workflow::fanout_synthesize;

deepstrike-0.2.17/crates/deepstrike-core/src/scheduler/state_machine/capability.rs

@@ -0,0 +1,151 @@
+//! Capability management impl for [`super::LoopStateMachine`].
+
+use super::{KernelObservation, LoopStateMachine};
+
+impl LoopStateMachine {
+    /// Drop capability leases whose expiry turn has passed. Runs at the head of
+    /// every event so expired temporary capabilities are unmounted promptly.
+    pub(super) fn sweep_expired_leases(&mut self) {
+        let current_turn = self.turn;
+        let mut to_remove = Vec::new();
+        for cap in self.ctx.capabilities.capabilities() {
+            if let Some(ref lease) = cap.lease {
+                if current_turn >= lease.expires_at_turn {
+                    to_remove.push((cap.kind, cap.id.to_string()));
+                }
+            }
+        }
+        for (kind, id) in to_remove {
+            self.unmount_capability(kind, &id);
+        }
+    }
+
+    /// Emit a `CapabilityChanged` observation for the current turn.
+    /// Single construction site for all mount/unmount/replace/pin changes.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn push_capability_change(
+        &mut self,
+        added: Vec<String>,
+        removed: Vec<String>,
+        change_kind: &str,
+        capability_id: Option<String>,
+        version: Option<String>,
+        mounted_by: Option<String>,
+        mount_reason: Option<String>,
+    ) {
+        self.observations.push(KernelObservation::CapabilityChanged {
+            turn: self.turn,
+            added,
+            removed,
+            change_kind: Some(change_kind.to_string()),
+            capability_id,
+            version,
+            mounted_by,
+            mount_reason,
+        });
+    }
+
+    pub fn execute_capability_command(&mut self, cmd: crate::types::capability::CapabilityCommand) {
+        use crate::types::capability::CapabilityCommand;
+        match cmd {
+            CapabilityCommand::Mount {
+                capability,
+                mounted_by,
+                mount_reason,
+            } => {
+                self.mount_capability(capability, mounted_by, mount_reason);
+            }
+            CapabilityCommand::Unmount { kind, id } => {
+                self.unmount_capability(kind, &id);
+            }
+            CapabilityCommand::Replace {
+                old_kind,
+                old_id,
+                new_capability,
+            } => {
+                let new_id = new_capability.id.to_string();
+                let version = new_capability.version.clone();
+                let old_kind_str = old_kind.label();
+                let new_kind_str = new_capability.kind.label();
+
+                self.ctx.capabilities.remove(old_kind, &old_id);
+                self.ctx.capabilities.upsert(new_capability);
+
+                self.push_capability_change(
+                    vec![format!("{}:{}", new_kind_str, new_id)],
+                    vec![format!("{}:{}", old_kind_str, old_id)],
+                    "replace",
+                    Some(new_id),
+                    version,
+                    None,
+                    None,
+                );
+            }
+            CapabilityCommand::Pin { kind, id } => {
+                let version = self
+                    .ctx
+                    .capabilities
+                    .get_mut(kind, &id)
+                    .and_then(|c| c.version.clone());
+                if let Some(cap) = self.ctx.capabilities.get_mut(kind, &id) {
+                    cap.is_pinned = true;
+                    self.push_capability_change(
+                        vec![],
+                        vec![],
+                        "pin",
+                        Some(id),
+                        version,
+                        None,
+                        None,
+                    );
+                }
+            }
+        }
+    }
+
+    pub fn mount_capability(
+        &mut self,
+        mut descriptor: crate::types::capability::CapabilityDescriptor,
+        mounted_by: Option<String>,
+        mount_reason: Option<String>,
+    ) {
+        if mounted_by.is_some() {
+            descriptor.mounted_by = mounted_by.clone();
+        }
+        if mount_reason.is_some() {
+            descriptor.mount_reason = mount_reason.clone();
+        }
+        let id = descriptor.id.to_string();
+        let kind_str = descriptor.kind.label();
+        let version = descriptor.version.clone();
+        self.ctx.capabilities.upsert(descriptor);
+        self.push_capability_change(
+            vec![format!("{}:{}", kind_str, id)],
+            vec![],
+            "mount",
+            Some(id),
+            version,
+            mounted_by,
+            mount_reason,
+        );
+    }
+
+    pub fn unmount_capability(&mut self, kind: crate::types::capability::CapabilityKind, id: &str) {
+        let version = self
+            .ctx
+            .capabilities
+            .get_mut(kind, id)
+            .and_then(|c| c.version.clone());
+        self.ctx.capabilities.remove(kind, id);
+        let kind_str = kind.label();
+        self.push_capability_change(
+            vec![],
+            vec![format!("{}:{}", kind_str, id)],
+            "unmount",
+            Some(id.to_string()),
+            version,
+            None,
+            None,
+        );
+    }
+}