deepstrike 0.2.73__tar.gz → 0.2.74__tar.gz

{deepstrike-0.2.73 → deepstrike-0.2.74}/Cargo.lock

@@ -254,7 +254,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-core"
-version = "0.2.73"
+version = "0.2.74"
 dependencies = [
  "compact_str",
  "deepstrike-tokenizer",
@@ -268,7 +268,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-node"
-version = "0.2.73"
+version = "0.2.74"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -280,7 +280,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-py"
-version = "0.2.73"
+version = "0.2.74"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -291,7 +291,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-sdk"
-version = "0.2.73"
+version = "0.2.74"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -327,7 +327,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-tokenizer"
-version = "0.2.73"
+version = "0.2.74"
 dependencies = [
  "pretty_assertions",
  "tiktoken-rs",
@@ -335,7 +335,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-wasm"
-version = "0.2.73"
+version = "0.2.74"
 dependencies = [
  "compact_str",
  "deepstrike-core",

{deepstrike-0.2.73 → deepstrike-0.2.74}/Cargo.toml

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

{deepstrike-0.2.73 → deepstrike-0.2.74}/PKG-INFO

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

{deepstrike-0.2.73 → deepstrike-0.2.74}/crates/deepstrike-core/src/orchestration/workflow/run.rs

@@ -320,6 +320,11 @@ impl WorkflowRun {
         self.graph.ready_tasks()
     }
 
+    /// Whether every workflow node has reached a terminal state.
+    pub fn is_complete(&self) -> bool {
+        self.graph.all_done()
+    }
+
     pub fn set_scheduler_policy(
         &mut self,
         policy: crate::scheduler::policy::SchedulerPolicyConfig,
@@ -1002,12 +1007,6 @@ impl WorkflowRun {
         })
     }
 
-    /// Test instrument: every node reached one of the four terminal statuses.
-    #[cfg(test)]
-    pub(crate) fn is_complete(&self) -> bool {
-        self.graph.all_done()
-    }
-
     /// Close a workflow and return exactly one typed terminal outcome per graph node.
     pub fn finish(&mut self) -> Vec<WorkflowNodeOutcome> {
         for node in 0..self.graph.len() {

{deepstrike-0.2.73 → deepstrike-0.2.74}/crates/deepstrike-core/src/runtime/kernel/observation.rs

@@ -236,6 +236,31 @@ pub enum KernelObservation {
         #[serde(default, skip_serializing_if = "Option::is_none")]
         submitter: Option<String>,
     },
+    /// The host's dynamic plan was accepted and bound to this kernel workflow transition. The
+    /// canonical DAG remains authoritative for scheduling; this fact preserves replay identity,
+    /// dependencies and the host's replay disposition in the journal.
+    DynamicWorkflowPlanCommitted {
+        turn: u32,
+        run_id: String,
+        sequence: u32,
+        node_ids: Vec<String>,
+        dependencies: Vec<Vec<String>>,
+        prompt_fingerprints: Vec<String>,
+        replay: Vec<String>,
+    },
+    /// A dynamic invocation replay decision observed by the kernel.
+    DynamicWorkflowReplayRecorded {
+        turn: u32,
+        run_id: String,
+        sequence: u32,
+        node_id: String,
+        prompt_fingerprint: String,
+        status: String,
+        replay: String,
+        result_digest: String,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        termination: Option<String>,
+    },
     /// A runtime node batch was rejected before any graph mutation.
     NodesRejected {
         turn: u32,

{deepstrike-0.2.73 → deepstrike-0.2.74}/crates/deepstrike-core/src/runtime/kernel/wire/command.rs

@@ -2,7 +2,7 @@
 
 use serde::{Deserialize, Serialize};
 
-use super::root::{CapabilityGrant, CapabilityRef, KnowledgeEntry};
+use super::root::{CapabilityGrant, CapabilityRef, KnowledgeEntry, WorkflowNode};
 use super::scalar::{CallId, WireU64};
 
 /// Live commands a host may issue against a running operation.
@@ -22,6 +22,15 @@ pub enum HostCommand {
     Cancel(CancelCommand),
     ForceCompact(ForceCompactCommand),
     UpdateTask(UpdateTaskCommand),
+    /// Dynamic workflow controller growth. The host remains the author of the request, while the
+    /// kernel still owns DAG validation, quota gating, trust coercion, scheduling, and durable
+    /// spawn facts. This is intentionally separate from the model-facing append syscall: it has
+    /// host authority and no caller-supplied agent identity.
+    AppendWorkflowNodes(AppendWorkflowNodesCommand),
+    /// A host replay decision recorded in the canonical journal alongside workflow facts.
+    RecordDynamicWorkflowReplay(DynamicWorkflowReplayCommand),
+    /// Close a host-driven dynamic workflow after its script and all submitted batches settle.
+    CompleteDynamicWorkflow(CompleteDynamicWorkflowCommand),
     ApplyCapabilityPatch(ApplyCapabilityPatchCommand),
     ApplyKnowledgeMutation(ApplyKnowledgeMutationCommand),
     /// DEC-9: the host seeding entries into the knowledge partition. Named apart from the P1
@@ -67,6 +76,52 @@ pub struct UpdateTaskCommand {
     pub update: TaskUpdate,
 }
 
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct AppendWorkflowNodesCommand {
+    pub nodes: Vec<WorkflowNode>,
+    /// Host-generated plan metadata. The kernel records it, but scheduling remains driven by the
+    /// canonical DAG built from `nodes`.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<DynamicWorkflowPlan>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct DynamicWorkflowPlan {
+    pub run_id: String,
+    pub sequence: u32,
+    pub nodes: Vec<DynamicWorkflowPlanNode>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct DynamicWorkflowPlanNode {
+    pub node_id: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub depends_on: Vec<String>,
+    pub prompt_fingerprint: String,
+    pub replay: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct DynamicWorkflowReplayCommand {
+    pub run_id: String,
+    pub sequence: u32,
+    pub node_id: String,
+    pub prompt_fingerprint: String,
+    pub status: String,
+    pub replay: String,
+    pub result_digest: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub termination: Option<String>,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct CompleteDynamicWorkflowCommand {}
+
 /// A partial edit of the task state. Every field is optional; absent ⇒ unchanged.
 #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]

{deepstrike-0.2.73 → deepstrike-0.2.74}/crates/deepstrike-core/src/runtime/kernel/wire/driver/continuation.rs

@@ -412,6 +412,24 @@ impl CanonicalOperationDriver {
         if let Some(output_schema) = &info.output_schema {
             metadata.insert("output_schema".to_string(), output_schema.clone());
         }
+        if let Some(token_budget) = info.token_budget {
+            metadata.insert(
+                "token_budget".to_string(),
+                serde_json::Value::Number(token_budget.into()),
+            );
+        }
+        if let Some(max_turns) = info.max_turns {
+            metadata.insert(
+                "max_turns".to_string(),
+                serde_json::Value::Number(max_turns.into()),
+            );
+        }
+        if let Some(max_wall_ms) = info.max_wall_ms {
+            metadata.insert(
+                "max_wall_ms".to_string(),
+                serde_json::Value::Number(max_wall_ms.into()),
+            );
+        }
         if !info.input_agent_ids.is_empty() {
             metadata.insert(
                 "input_agent_ids".to_string(),

{deepstrike-0.2.73 → deepstrike-0.2.74}/crates/deepstrike-core/src/runtime/kernel/wire/driver/events.rs

@@ -404,6 +404,15 @@ impl CanonicalOperationDriver {
                 self.continue_after(context, LoopAction::AwaitingResume, root_kind)
             }
             HostCommand::UpdateTask(update) => self.plan_host_task_update(update),
+            HostCommand::AppendWorkflowNodes(append) => {
+                self.plan_dynamic_workflow_append(context, append)
+            }
+            HostCommand::RecordDynamicWorkflowReplay(fact) => {
+                self.plan_dynamic_workflow_replay(context, fact)
+            }
+            HostCommand::CompleteDynamicWorkflow(_) => {
+                self.plan_dynamic_workflow_complete(context)
+            }
             HostCommand::ApplyCapabilityPatch(patch) => self.plan_capability_patch(patch),
             HostCommand::ApplyKnowledgeMutation(mutation) => self.plan_knowledge_mutation(mutation),
             HostCommand::SeedKnowledge(seed) => self.plan_seed_knowledge(seed),
@@ -413,6 +422,186 @@ impl CanonicalOperationDriver {
         }
     }
 
+    /// Grow a root dynamic workflow from the host controller while keeping the same kernel-owned
+    /// DAG, quota ledger, trust coercion, and spawn queue as model-authored workflow growth. The
+    /// host command is only admitted for an active root workflow; it cannot bootstrap or stack a
+    /// second operation.
+    pub(super) fn plan_dynamic_workflow_append(
+        &mut self,
+        context: &PlanContext<'_>,
+        append: &AppendWorkflowNodesCommand,
+    ) -> Result<PlannedStep, KernelFault> {
+        if append.nodes.is_empty() {
+            return Err(KernelFault::new(
+                KernelFaultCode::InvalidConfig,
+                "a dynamic workflow append must contain at least one node",
+            ));
+        }
+        if self.root_kind != Some(RootKind::Workflow)
+            || !self.engine().is_some_and(LoopStateMachine::workflow_active)
+        {
+            return Err(KernelFault::new(
+                KernelFaultCode::InvalidAuthority,
+                "dynamic workflow nodes may only be appended to an active root workflow",
+            ));
+        }
+        for node in &append.nodes {
+            self.require_known_contract(context.config, node.run_spec.as_ref())?;
+        }
+        if let Some(plan) = &append.plan {
+            if plan.run_id.is_empty() || plan.nodes.len() != append.nodes.len() {
+                return Err(KernelFault::new(
+                    KernelFaultCode::InvalidConfig,
+                    "dynamic workflow plan must name a run and one entry per appended node",
+                ));
+            }
+            if plan.nodes.iter().any(|node| node.replay != "executed") {
+                return Err(KernelFault::new(
+                    KernelFaultCode::InvalidConfig,
+                    "dynamic workflow append plans may only describe executed nodes",
+                ));
+            }
+            for planned in &plan.nodes {
+                if planned.node_id.is_empty() || planned.prompt_fingerprint.is_empty() {
+                    return Err(KernelFault::new(
+                        KernelFaultCode::InvalidConfig,
+                        "dynamic workflow plan nodes require an identity and prompt fingerprint",
+                    ));
+                }
+                if planned
+                    .depends_on
+                    .iter()
+                    .any(|dependency| dependency == &planned.node_id)
+                {
+                    return Err(KernelFault::new(
+                        KernelFaultCode::InvalidConfig,
+                        format!("dynamic workflow plan node {:?} cannot depend on itself", planned.node_id),
+                    ));
+                }
+            }
+        }
+        let wire_spec = WireSpec {
+            name: String::new(),
+            nodes: append.nodes.clone(),
+        };
+        let core_spec = build_core_spec(&wire_spec)?;
+        let node_ids = wire_node_ids(&wire_spec);
+        // A host append is the explicit append operation, even though the underlying DAG is the
+        // same one used by model-authored workflow growth. Keeping the `SubmitNodes` gate and
+        // `submit_workflow_nodes` label here preserves the kernel→host action contract: a quota
+        // denial must come back as a dynamic append rejection, not as a fresh workflow start.
+        let action = self
+            .engine_mut()?
+            .submit_workflow_nodes(core_spec.nodes, None);
+        let appended = self.engine().is_some_and(|engine| {
+            engine.observations.iter().any(|observation| {
+                matches!(
+                    observation,
+                    KernelObservation::WorkflowNodesSubmitted { .. }
+                )
+            })
+        });
+        if appended {
+            self.node_ids.extend(node_ids);
+            self.workflow_nodes.extend(append.nodes.clone());
+            if let Some(plan) = &append.plan {
+                let engine = self.engine_mut()?;
+                engine
+                    .observations
+                    .push(KernelObservation::DynamicWorkflowPlanCommitted {
+                        turn: engine.turn,
+                        run_id: plan.run_id.clone(),
+                        sequence: plan.sequence,
+                        node_ids: plan.nodes.iter().map(|node| node.node_id.clone()).collect(),
+                        dependencies: plan
+                            .nodes
+                            .iter()
+                            .map(|node| node.depends_on.clone())
+                            .collect(),
+                        prompt_fingerprints: plan
+                            .nodes
+                            .iter()
+                            .map(|node| node.prompt_fingerprint.clone())
+                            .collect(),
+                        replay: plan.nodes.iter().map(|node| node.replay.clone()).collect(),
+                    });
+            }
+        }
+        self.continue_after(context, action, RootKind::Workflow)
+    }
+
+    pub(super) fn plan_dynamic_workflow_replay(
+        &mut self,
+        _context: &PlanContext<'_>,
+        fact: &DynamicWorkflowReplayCommand,
+    ) -> Result<PlannedStep, KernelFault> {
+        if fact.run_id.is_empty()
+            || fact.node_id.is_empty()
+            || fact.prompt_fingerprint.is_empty()
+            || fact.result_digest.is_empty()
+        {
+            return Err(KernelFault::new(
+                KernelFaultCode::InvalidConfig,
+                "dynamic workflow replay facts require run_id, node_id, prompt_fingerprint and result_digest",
+            ));
+        }
+        if !matches!(fact.replay.as_str(), "executed" | "reused") {
+            return Err(KernelFault::new(
+                KernelFaultCode::InvalidConfig,
+                "dynamic workflow replay must be executed or reused",
+            ));
+        }
+        if !matches!(
+            fact.status.as_str(),
+            "completed" | "completed_partial" | "failed" | "skipped_upstream_failed" | "cancelled"
+        ) {
+            return Err(KernelFault::new(
+                KernelFaultCode::InvalidConfig,
+                "dynamic workflow replay fact has an unsupported status",
+            ));
+        }
+        if self.root_kind != Some(RootKind::Workflow)
+            || !self.engine().is_some_and(LoopStateMachine::workflow_active)
+        {
+            return Err(KernelFault::new(
+                KernelFaultCode::InvalidAuthority,
+                "dynamic workflow replay facts require a live workflow operation",
+            ));
+        }
+        let engine = self.engine_mut()?;
+        engine
+            .observations
+            .push(KernelObservation::DynamicWorkflowReplayRecorded {
+                turn: engine.turn,
+                run_id: fact.run_id.clone(),
+                sequence: fact.sequence,
+                node_id: fact.node_id.clone(),
+                prompt_fingerprint: fact.prompt_fingerprint.clone(),
+                status: fact.status.clone(),
+                replay: fact.replay.clone(),
+                result_digest: fact.result_digest.clone(),
+                termination: fact.termination.clone(),
+            });
+        Ok(self.quiet_step())
+    }
+
+    pub(super) fn plan_dynamic_workflow_complete(
+        &mut self,
+        context: &PlanContext<'_>,
+    ) -> Result<PlannedStep, KernelFault> {
+        if self.root_kind != Some(RootKind::Workflow)
+            || !self.engine().is_some_and(LoopStateMachine::workflow_active)
+            || !self.engine().is_some_and(LoopStateMachine::is_dynamic_workflow_open)
+        {
+            return Err(KernelFault::new(
+                KernelFaultCode::InvalidAuthority,
+                "dynamic workflow close requires an active host-driven dynamic root",
+            ));
+        }
+        let action = self.engine_mut()?.close_dynamic_workflow();
+        self.continue_after(context, action, RootKind::Workflow)
+    }
+
     /// §11.1 · the cancellation ladder, and the only path an operation is cancelled through.
     ///
     /// The order is downstream-first and it happens **inside one transition**, because §7.12 admits

{deepstrike-0.2.73 → deepstrike-0.2.74}/crates/deepstrike-core/src/runtime/kernel/wire/driver/planning.rs

@@ -395,6 +395,30 @@ impl CanonicalOperationDriver {
                     disposition,
                 })
             }
+            RootEntry::DynamicWorkflow(_) => {
+                // A dynamic root intentionally publishes no first spawn effect. The host script
+                // supplies its first batch through `AppendWorkflowNodes`; the explicit open bit
+                // prevents the empty DAG from self-terminating in the state machine.
+                let workflow_id = mint_workflow_id(&context.input.operation_id, context.step_seq);
+                let engine = self.engine_mut()?;
+                seed_initial_context(engine, initial);
+                engine.set_root_workflow(true);
+                engine.set_dynamic_workflow_open(true);
+                let action = engine.load_workflow_as(
+                    crate::orchestration::workflow::WorkflowSpec::default(),
+                    ROOT_TASK_ID,
+                );
+                debug_assert!(matches!(action, LoopAction::AwaitingResume));
+                self.node_ids.clear();
+                self.workflow_nodes.clear();
+                self.workflow_id = Some(workflow_id.clone());
+                Ok(PlannedStep {
+                    root_kind: Some(RootKind::Workflow),
+                    focus: Some(ExecutionFocus::workflow_controller(workflow_id, None)),
+                    observations: Vec::new(),
+                    disposition: self.quiet_step().disposition,
+                })
+            }
         }
     }
 }