deepstrike 0.2.17__tar.gz → 0.2.18__tar.gz

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

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

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

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

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

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

deepstrike-0.2.17/crates/deepstrike-core/src/harness/eval_pipeline.rs → deepstrike-0.2.18/crates/deepstrike-core/src/harness/eval.rs

@@ -1,32 +1,20 @@
-/// Evaluation pipeline — the agent's "quality gate" cycle.
-///
-/// Mirrors `IdlePipeline` in structure: pure computation in kernel, I/O in SDK.
-///
-/// **Deprecation track (R3-4).** This standalone, single-shot pipeline predates the workflow
-/// substrate. For adversarial verification, the recommended path is now the
-/// [`crate::orchestration::workflow::verify_rules`] template (one fresh-context verifier per rule +
-/// an optional skeptic, with the bias-resistant `role_defaults` Verify ⇒ (ReadOnly, None) contract),
-/// and — for unknown-size verification — dynamic claim-level fan-out via R3-1
-/// [`crate::orchestration::workflow::WorkflowRun::submit_nodes`] (a claim-extractor node submits one
-/// verifier per claim it finds). `EvalPipeline` stays bound across the SDKs and is maintained, but
-/// not extended; a future major (0.5.x consolidation) reassesses folding it into the workflow path.
-///
-/// ```text
-/// Phase 1 — Prompt assembly (synchronous, in-kernel)
-/// ┌──────────────────────────────────────────────────────┐
-/// │ EvalEvent::Outcome { goal, criteria, result }        │
-/// │   → build evaluation prompt                          │
-/// │   → EvalAction::Evaluate { messages }                │ ← SDK calls LLM
-/// └──────────────────────────────────────────────────────┘
-///
-/// Phase 2 — Parse LLM verdict (after SDK returns)
-/// ┌──────────────────────────────────────────────────────┐
-/// │ EvalEvent::EvalResult { content }                    │
-/// │   → parse JSON → EvalResult { passed, feedback,     │
-/// │                               skill_candidate }      │
-/// │   → EvalAction::Done { result }                      │ ← SDK acts on result
-/// └──────────────────────────────────────────────────────┘
-/// ```
+//! Evaluation primitives — the agent's "quality gate" compute.
+//!
+//! Pure computation in kernel, I/O in SDK. This module provides the **stateless** building blocks
+//! for the generate → evaluate → retry quality gate:
+//!
+//! - [`build_eval_messages`] assembles the impartial-evaluator prompt from a goal + criteria + the
+//!   agent's output (the SDK then calls the eval LLM with it).
+//! - [`parse_verdict`] parses the LLM's JSON response into a structured [`EvalResult`].
+//! - [`verdict_output_schema`] is the JSON Schema for that verdict, used as the `output_schema` of
+//!   the eval node in the [`crate::orchestration::workflow::gen_eval`] workflow template.
+//!
+//! **History (0.5.0 fold, OS-axis #6).** This replaces the former `EvalPipeline` state machine +
+//! its public SDK class. The quality gate is now expressed on the workflow substrate: the iterative
+//! retry-with-feedback loop is driven by the SDK `HarnessLoop` (the kernel `NodeKind::Loop` re-arms
+//! a single node, so per-iteration eval cannot be a static DAG), and the declarative
+//! "loop-the-worker-then-verify-with-a-structured-verdict" shape is the `gen_eval` template. Both
+//! reuse these primitives, so the verdict shape stays consistent across the two paths.
 use crate::types::message::{Content, Message, Role};
 
 // ---------------------------------------------------------------------------
@@ -102,6 +90,7 @@ pub struct SkillCandidate {
     pub content: String,
 }
 
+/// The structured verdict produced by parsing the eval LLM's JSON response.
 #[derive(Debug, Clone)]
 pub struct EvalResult {
     pub passed: bool,
@@ -114,112 +103,19 @@ pub struct EvalResult {
     pub skill_candidate: Option<SkillCandidate>,
 }
 
-// ---------------------------------------------------------------------------
-// State machine types
-// ---------------------------------------------------------------------------
-
-#[derive(Debug)]
-pub enum EvalPhase {
-    Idle,
-    EvalPending { goal: String, attempt: u32 },
-    Done,
-}
-
-pub enum EvalEvent {
-    Outcome {
-        goal: String,
-        criteria: Vec<Criterion>,
-        result: String,
-        attempt: u32,
-    },
-    EvalResult {
-        content: String,
-    },
-}
-
-pub enum EvalAction {
-    /// Call the LLM with `messages`, then feed `EvalEvent::EvalResult`.
-    Evaluate { messages: Vec<Message> },
-    /// Evaluation complete — SDK reads `result` and decides next step.
-    Done { result: EvalResult },
-}
-
-// ---------------------------------------------------------------------------
-// Policy
-// ---------------------------------------------------------------------------
-
-#[derive(Debug, Clone)]
-pub struct EvalPolicy {
-    /// Whether to ask the LLM to propose a skill when the run passes. Default: true.
-    pub extract_skill_on_pass: bool,
-}
-
-impl Default for EvalPolicy {
-    fn default() -> Self {
-        Self {
-            extract_skill_on_pass: true,
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Pipeline
-// ---------------------------------------------------------------------------
-
-pub struct EvalPipeline {
-    pub phase: EvalPhase,
-    policy: EvalPolicy,
-}
-
-impl EvalPipeline {
-    pub fn new(policy: EvalPolicy) -> Self {
-        Self {
-            phase: EvalPhase::Idle,
-            policy,
-        }
-    }
-
-    pub fn is_idle(&self) -> bool {
-        matches!(self.phase, EvalPhase::Idle)
-    }
-
-    pub fn feed(&mut self, event: EvalEvent) -> EvalAction {
-        match event {
-            EvalEvent::Outcome {
-                goal,
-                criteria,
-                result,
-                attempt,
-            } => {
-                let messages = build_eval_prompt(&goal, &criteria, &result, attempt, &self.policy);
-                self.phase = EvalPhase::EvalPending { goal, attempt };
-                EvalAction::Evaluate { messages }
-            }
-
-            EvalEvent::EvalResult { content } => {
-                self.phase = EvalPhase::Done;
-                EvalAction::Done {
-                    result: parse_eval_response(&content),
-                }
-            }
-        }
-    }
-
-    pub fn reset(&mut self) {
-        self.phase = EvalPhase::Idle;
-    }
-}
-
 // ---------------------------------------------------------------------------
 // Prompt builder
 // ---------------------------------------------------------------------------
 
-fn build_eval_prompt(
+/// Build the impartial-evaluator messages for one attempt: a system instruction describing the
+/// scoring contract + a user message carrying the goal, criteria, and the agent's output. The SDK
+/// calls the eval LLM with these, then feeds the response to [`parse_verdict`].
+pub fn build_eval_messages(
     goal: &str,
     criteria: &[Criterion],
     result: &str,
     attempt: u32,
-    policy: &EvalPolicy,
+    extract_skill_on_pass: bool,
 ) -> Vec<Message> {
     let criteria_text = if criteria.is_empty() {
         "No explicit criteria — use general quality judgement.".to_string()
@@ -246,7 +142,7 @@ fn build_eval_prompt(
 
     let details_schema = r#"[{"criterion":"...","passed":bool,"score":0.0-1.0,"feedback":"..."}]"#;
 
-    let skill_instruction = if policy.extract_skill_on_pass {
+    let skill_instruction = if extract_skill_on_pass {
         "\nIf passed=true and the approach is reusable, add a \"skill\" field:\
 \n{\"name\":\"snake_case\",\"description\":\"one sentence\",\"when_to_use\":\"optional hint\",\"content\":\"markdown body (no frontmatter)\"}"
     } else {
@@ -279,11 +175,59 @@ fn build_eval_prompt(
     vec![system, user]
 }
 
+// ---------------------------------------------------------------------------
+// Verdict output schema (for the gen_eval workflow template's eval node)
+// ---------------------------------------------------------------------------
+
+/// JSON Schema for the verdict an eval node must produce. Used as the `output_schema` of the eval
+/// node in the [`crate::orchestration::workflow::gen_eval`] template so the SDK can instruct +
+/// validate the verdict. Matches what [`parse_verdict`] reads.
+pub fn verdict_output_schema(extract_skill_on_pass: bool) -> serde_json::Value {
+    let mut properties = serde_json::json!({
+        "passed": { "type": "boolean", "description": "true iff all [required] criteria pass" },
+        "overall_score": { "type": "number", "minimum": 0.0, "maximum": 1.0 },
+        "feedback": { "type": "string", "description": "concise summary; on fail, what to fix next attempt" },
+        "details": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["criterion", "passed", "score", "feedback"],
+                "properties": {
+                    "criterion": { "type": "string" },
+                    "passed": { "type": "boolean" },
+                    "score": { "type": "number", "minimum": 0.0, "maximum": 1.0 },
+                    "feedback": { "type": "string" }
+                }
+            }
+        }
+    });
+    if extract_skill_on_pass {
+        properties["skill"] = serde_json::json!({
+            "type": "object",
+            "description": "optional reusable skill distilled from a passing run",
+            "required": ["name", "description", "content"],
+            "properties": {
+                "name": { "type": "string", "description": "snake_case" },
+                "description": { "type": "string" },
+                "when_to_use": { "type": "string" },
+                "content": { "type": "string", "description": "markdown body, no frontmatter" }
+            }
+        });
+    }
+    serde_json::json!({
+        "type": "object",
+        "required": ["passed", "overall_score", "feedback"],
+        "properties": properties
+    })
+}
+
 // ---------------------------------------------------------------------------
 // Response parser
 // ---------------------------------------------------------------------------
 
-fn parse_eval_response(content: &str) -> EvalResult {
+/// Parse an eval LLM's JSON response into a structured [`EvalResult`]. Tolerant of markdown fences
+/// and missing fields (defaults: `passed=false`, score derived from `passed`).
+pub fn parse_verdict(content: &str) -> EvalResult {
     let json_str = extract_json(content);
     let v: serde_json::Value = serde_json::from_str(json_str).unwrap_or(serde_json::Value::Null);
 
@@ -378,77 +322,68 @@ fn extract_json(s: &str) -> &str {
 mod tests {
     use super::*;
 
-    fn pipeline() -> EvalPipeline {
-        EvalPipeline::new(EvalPolicy::default())
+    #[test]
+    fn build_eval_messages_carries_goal_and_criteria() {
+        let msgs = build_eval_messages(
+            "Write a function",
+            &[Criterion::required("Must handle errors")],
+            "fn foo() {}",
+            1,
+            true,
+        );
+        assert_eq!(msgs.len(), 2);
+        assert!(matches!(msgs[0].role, Role::System));
+        let Content::Text(user) = &msgs[1].content else {
+            panic!("expected text")
+        };
+        assert!(user.contains("Write a function"));
+        assert!(user.contains("[required]Must handle errors"));
+        assert!(user.contains("attempt 1"));
+        // skill instruction present when extract_skill_on_pass=true
+        let Content::Text(system) = &msgs[0].content else {
+            panic!("expected text")
+        };
+        assert!(system.contains("\"skill\""));
     }
 
     #[test]
-    fn starts_idle() {
-        assert!(pipeline().is_idle());
+    fn build_eval_messages_omits_skill_instruction_when_disabled() {
+        let msgs = build_eval_messages("g", &[], "r", 1, false);
+        let Content::Text(system) = &msgs[0].content else {
+            panic!("expected text")
+        };
+        assert!(!system.contains("\"name\":\"snake_case\""));
     }
 
     #[test]
-    fn outcome_emits_evaluate() {
-        let mut p = pipeline();
-        let action = p.feed(EvalEvent::Outcome {
-            goal: "Write a function".into(),
-            criteria: vec![Criterion::required("Must handle errors")],
-            result: "fn foo() {}".into(),
-            attempt: 1,
-        });
-        assert!(matches!(action, EvalAction::Evaluate { .. }));
-        assert!(matches!(p.phase, EvalPhase::EvalPending { .. }));
+    fn parse_verdict_failed_no_skill() {
+        let result = parse_verdict(
+            r#"{"passed":false,"overall_score":0.2,"feedback":"Missing error handling","details":[{"criterion":"Must handle errors","passed":false,"score":0.2,"feedback":"No error handling found"}]}"#,
+        );
+        assert!(!result.passed);
+        assert_eq!(result.feedback, "Missing error handling");
+        assert_eq!(result.details.len(), 1);
+        assert!(!result.details[0].passed);
+        assert!(result.skill_candidate.is_none());
     }
 
     #[test]
-    fn eval_result_failed_no_skill() {
-        let mut p = pipeline();
-        p.feed(EvalEvent::Outcome {
-            goal: "g".into(),
-            criteria: vec![],
-            result: "r".into(),
-            attempt: 1,
-        });
-        let action = p.feed(EvalEvent::EvalResult {
-            content: r#"{"passed":false,"overall_score":0.2,"feedback":"Missing error handling","details":[{"criterion":"Must handle errors","passed":false,"score":0.2,"feedback":"No error handling found"}]}"#.into(),
-        });
-        match action {
-            EvalAction::Done { result } => {
-                assert!(!result.passed);
-                assert_eq!(result.feedback, "Missing error handling");
-                assert_eq!(result.details.len(), 1);
-                assert!(!result.details[0].passed);
-                assert!(result.skill_candidate.is_none());
-            }
-            _ => panic!("expected Done"),
-        }
+    fn parse_verdict_passed_with_skill_and_details() {
+        let json = r#"{"passed":true,"overall_score":0.95,"feedback":"All criteria met","details":[{"criterion":"Must handle errors","passed":true,"score":1.0,"feedback":"Good error handling"}],"skill":{"name":"robust_api_call","description":"How to call APIs with retries","content":"Robust API Call - Always retry on 5xx."}}"#;
+        let result = parse_verdict(json);
+        assert!(result.passed);
+        assert!(result.overall_score > 0.9);
+        assert_eq!(result.details.len(), 1);
+        assert!(result.details[0].passed);
+        let skill = result.skill_candidate.unwrap();
+        assert_eq!(skill.name, "robust_api_call");
+        assert!(skill.content.contains("retry"));
     }
 
     #[test]
-    fn eval_result_passed_with_skill_and_details() {
-        let mut p = pipeline();
-        p.feed(EvalEvent::Outcome {
-            goal: "g".into(),
-            criteria: vec![],
-            result: "r".into(),
-            attempt: 1,
-        });
-        let json = r#"{"passed":true,"overall_score":0.95,"feedback":"All criteria met","details":[{"criterion":"Must handle errors","passed":true,"score":1.0,"feedback":"Good error handling"}],"skill":{"name":"robust_api_call","description":"How to call APIs with retries","content":"Robust API Call - Always retry on 5xx."}}"#;
-        let action = p.feed(EvalEvent::EvalResult {
-            content: json.into(),
-        });
-        match action {
-            EvalAction::Done { result } => {
-                assert!(result.passed);
-                assert!(result.overall_score > 0.9);
-                assert_eq!(result.details.len(), 1);
-                assert!(result.details[0].passed);
-                let skill = result.skill_candidate.unwrap();
-                assert_eq!(skill.name, "robust_api_call");
-                assert!(skill.content.contains("retry"));
-            }
-            _ => panic!("expected Done"),
-        }
+    fn parse_verdict_strips_markdown_fences() {
+        let result = parse_verdict("```json\n{\"passed\":true,\"feedback\":\"good\"}\n```");
+        assert!(result.passed);
     }
 
     #[test]
@@ -466,36 +401,15 @@ mod tests {
     }
 
     #[test]
-    fn reset_allows_reuse() {
-        let mut p = pipeline();
-        p.feed(EvalEvent::Outcome {
-            goal: "g".into(),
-            criteria: vec![],
-            result: "r".into(),
-            attempt: 1,
-        });
-        p.feed(EvalEvent::EvalResult {
-            content: r#"{"passed":true,"feedback":"ok"}"#.into(),
-        });
-        p.reset();
-        assert!(p.is_idle());
-    }
-
-    #[test]
-    fn strips_markdown_fences() {
-        let mut p = pipeline();
-        p.feed(EvalEvent::Outcome {
-            goal: "g".into(),
-            criteria: vec![],
-            result: "r".into(),
-            attempt: 1,
-        });
-        let action = p.feed(EvalEvent::EvalResult {
-            content: "```json\n{\"passed\":true,\"feedback\":\"good\"}\n```".into(),
-        });
-        match action {
-            EvalAction::Done { result } => assert!(result.passed),
-            _ => panic!(),
-        }
+    fn verdict_output_schema_shape() {
+        let schema = verdict_output_schema(true);
+        assert_eq!(schema["type"], "object");
+        assert!(schema["properties"]["passed"].is_object());
+        assert!(schema["properties"]["overall_score"].is_object());
+        assert!(schema["properties"]["details"].is_object());
+        assert!(schema["properties"]["skill"].is_object());
+        // skill property dropped when extraction is disabled
+        let no_skill = verdict_output_schema(false);
+        assert!(no_skill["properties"]["skill"].is_null());
     }
 }

deepstrike-0.2.18/crates/deepstrike-core/src/harness/mod.rs

@@ -0,0 +1,6 @@
+pub mod eval;
+
+pub use eval::{
+    build_eval_messages, parse_verdict, verdict_output_schema, Criterion, CriterionResult,
+    EvalResult, SkillCandidate,
+};

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

@@ -10,8 +10,9 @@
 //! loop-until-done, classify-and-act, and tournament — are now first-class [`NodeKind`] variants
 //! ([`NodeKind::Loop`] / [`NodeKind::Classify`] / [`NodeKind::Tournament`]) driven by the unified
 //! workflow executor; the former standalone `loop_until_done` / `tournament` SDK primitives were
-//! removed in their favor (A#1). Adversarial verification stays in
-//! [`crate::harness::eval_pipeline::EvalPipeline`].
+//! removed in their favor (A#1). The generate→evaluate→retry quality gate is the [`gen_eval`]
+//! template (a `Loop` worker + a `Verify` eval node carrying [`crate::harness::verdict_output_schema`]);
+//! its eval/verdict compute lives in [`crate::harness`].
 //!
 //! Pure: no I/O, no clock, no spawning. Validation reuses [`TaskGraph::topological_sort`].
 
@@ -338,7 +339,7 @@ pub fn fanout_synthesize(workers: Vec<RuntimeTask>, synthesize: RuntimeTask) ->
 ///
 /// Structurally a fan-out barrier, but semantically distinct: generators are `Implement`
 /// agents producing candidates; the filter is a `Verify` agent that ranks/dedupes against
-/// a rubric (pair with [`crate::harness::eval_pipeline::EvalPipeline`] for the rubric).
+/// a rubric (pair with the [`gen_eval`] verdict schema for the rubric).
 pub fn generate_and_filter(generators: Vec<RuntimeTask>, filter: RuntimeTask) -> WorkflowSpec {
     let mut nodes: Vec<WorkflowNode> = generators
         .into_iter()
@@ -365,9 +366,9 @@ pub fn generate_and_filter(generators: Vec<RuntimeTask>, filter: RuntimeTask) ->
 /// against self-preferential bias). The optional `skeptic` depends on all verifiers and reviews
 /// their flags (real violation vs. false positive). Runs on the W0 workflow executor.
 ///
-/// Pair each verifier with [`crate::harness::eval_pipeline::EvalPipeline`] at run time for the
-/// rubric scoring. For rules known only at run time (claim extraction), a dynamic-fan-out variant
-/// is a later round; this covers the case where the rule/claim set is known up front.
+/// For unknown-size rule sets (claim extraction), a dynamic-fan-out variant is a later round; this
+/// covers the case where the rule/claim set is known up front. For the generate→evaluate→retry
+/// quality gate (scoring one author's output against criteria), see [`gen_eval`].
 pub fn verify_rules(rules: Vec<RuntimeTask>, skeptic: Option<RuntimeTask>) -> WorkflowSpec {
     let mut nodes: Vec<WorkflowNode> = rules
         .into_iter()
@@ -383,6 +384,44 @@ pub fn verify_rules(rules: Vec<RuntimeTask>, skeptic: Option<RuntimeTask>) -> Wo
     WorkflowSpec::new(nodes)
 }
 
+// ---------------------------------------------------------------------------
+// Quality gate — generate → evaluate (#6, the EvalPipeline successor)
+// ---------------------------------------------------------------------------
+
+/// The generate→evaluate quality gate as a workflow: a `Loop` **worker** node (the task, re-run up
+/// to `max_iters`, stopping early on a `loop_continue=false` self-signal) followed by a `Verify`
+/// **eval** node that scores the worker's output against the goal/criteria and emits a structured
+/// verdict ([`crate::harness::verdict_output_schema`] as its `output_schema`).
+///
+/// This is the declarative substrate form of the former `EvalPipeline` (0.5.0 fold, OS-axis #6).
+/// The eval node is a `Verify` agent — [`role_defaults`] gives it `ReadOnly` + [`ContextInheritance::None`]
+/// so it does not inherit the worker's reasoning (bias resistance); it evaluates the worker's
+/// *output*, carried in via its task goal. The verdict's `passed` is the gate.
+///
+/// For the **iterative retry-with-feedback** variant (re-run the worker with the eval's feedback
+/// folded into the next attempt), the SDK `HarnessLoop` drives this with the same
+/// [`crate::harness::build_eval_messages`] / [`crate::harness::parse_verdict`] primitives — the
+/// kernel `Loop` re-arms a single node, so per-iteration eval is necessarily SDK-driven.
+pub fn gen_eval(
+    worker: RuntimeTask,
+    eval: RuntimeTask,
+    max_iters: usize,
+    extract_skill_on_pass: bool,
+) -> WorkflowSpec {
+    let worker_node = WorkflowNode::new(
+        worker.with_lane(TaskLane::new(TaskLane::ORCHESTRATE)),
+        AgentRole::Implement,
+    )
+    .with_loop(max_iters.max(1));
+    let eval_node = WorkflowNode::new(
+        eval.with_lane(TaskLane::new(TaskLane::VERIFY)),
+        AgentRole::Verify,
+    )
+    .with_depends_on(vec![0])
+    .with_output_schema(crate::harness::verdict_output_schema(extract_skill_on_pass));
+    WorkflowSpec::new(vec![worker_node, eval_node])
+}
+
 // ---------------------------------------------------------------------------
 // Pattern 3 — Classify-and-act
 // ---------------------------------------------------------------------------
@@ -489,6 +528,43 @@ mod tests {
         spec.validate().unwrap();
     }
 
+    #[test]
+    fn gen_eval_shape() {
+        // Worker loops; eval is a bias-resistant Verify node gated on the worker, carrying the
+        // verdict output_schema.
+        let spec = gen_eval(task("implement feature"), task("score against criteria"), 3, true);
+        assert_eq!(spec.nodes.len(), 2);
+
+        let worker = &spec.nodes[0];
+        assert_eq!(worker.role, AgentRole::Implement);
+        assert_eq!(worker.kind, NodeKind::Loop { max_iters: 3 });
+        assert!(worker.depends_on.is_empty());
+
+        let eval = &spec.nodes[1];
+        assert_eq!(eval.role, AgentRole::Verify);
+        assert_eq!(eval.context_inheritance, ContextInheritance::None);
+        assert_eq!(eval.isolation, AgentIsolation::ReadOnly);
+        assert_eq!(eval.depends_on, vec![0]);
+        let schema = eval.output_schema.as_ref().expect("eval node carries verdict schema");
+        assert!(schema["properties"]["passed"].is_object());
+        assert!(schema["properties"]["skill"].is_object()); // extract_skill_on_pass=true
+
+        spec.validate().unwrap();
+        // Worker is the only initially-ready node; eval is gated.
+        assert_eq!(spec.to_task_graph().unwrap().ready_tasks(), vec![0]);
+    }
+
+    #[test]
+    fn gen_eval_max_iters_floor_and_no_skill() {
+        // max_iters=0 would be an invalid loop; the template floors it to 1.
+        let spec = gen_eval(task("w"), task("e"), 0, false);
+        assert_eq!(spec.nodes[0].kind, NodeKind::Loop { max_iters: 1 });
+        // extract_skill_on_pass=false ⇒ no skill property in the verdict schema.
+        let schema = spec.nodes[1].output_schema.as_ref().unwrap();
+        assert!(schema["properties"]["skill"].is_null());
+        spec.validate().unwrap();
+    }
+
     #[test]
     fn verify_rules_empty_with_skeptic_is_just_skeptic() {
         // No rules → skeptic has nothing to depend on; still a valid single-node spec.

{deepstrike-0.2.17 → deepstrike-0.2.18}/crates/deepstrike-core/src/types/contract.rs

@@ -129,8 +129,8 @@ impl VerificationContract {
         out
     }
 
-    /// Derives a flat `Vec<String>` of criterion texts for use with the existing
-    /// `EvalPipeline` / `HarnessLoop` criteria API.
+    /// Derives a flat `Vec<String>` of criterion texts for use with the
+    /// `HarnessLoop` / [`crate::harness::build_eval_messages`] criteria API.
     pub fn to_criteria_strings(&self) -> Vec<String> {
         self.acceptance.iter().map(|c| c.text.clone()).collect()
     }