Update pipeline/run_two_phase.py

pipeline/run_two_phase.py

@@ -1,6 +1,6 @@
 """
 Reference pipeline orchestrator.
-This module shows how to wire the two-phase flow. Replace `call_model` with your LLM runner.
+Wire into your LLM runner. Supports packs built from free-form scenarios.
 """
 
 from pathlib import Path
@@ -12,12 +12,8 @@ from ..graders.rule_grader import grade
 from .io_utils import load_json
 
 # -------------------------
-# Replace this with your LLM runner.
+# REPLACE with your actual LLM runner
 def call_model(system_prompt: str, user_prompt: str, temperature: float = 0.2, top_p: float = 0.9) -> str:
-    """
-    Stub for LLM call. Should return the model's raw text output.
-    In production: plug into your provider (OpenAI, Azure, Anthropic, etc.)
-    """
     raise NotImplementedError("call_model must be implemented in your environment.")
 # -------------------------
 
@@ -39,55 +35,62 @@ def run_clarityops(pack_dir: str) -> Tuple[Dict[str, Any], Any]:
     inputs = load_json(pack / "inputs.json")
     constraints = load_json(pack / "constraints.json")
     schema_cfg = load_json(pack / "schema.json")
-    rubric = load_json(pack / "rubric.json")
-    expected = load_json(pack / "expected.json")
 
-    # Build the human-readable blocks
+    # Optional — only required if you want grading
+    rubric_path = pack / "rubric.json"
+    expected_path = pack / "expected.json"
+    rubric = load_json(rubric_path) if rubric_path.exists() else {"set_equals": [], "must_contain": [], "numeric_equals": []}
+    expected = load_json(expected_path) if expected_path.exists() else {"note": "No expected gold provided."}
+
+    # Build Phase 1 user prompt
     context_block = inputs.get("context", "No context provided.")
     data_block = json.dumps(inputs.get("data_inputs", {}), ensure_ascii=False, indent=2)
     constraints_block = json.dumps(constraints, ensure_ascii=False, indent=2)
 
     # ---- Phase 1: Clarification Questions
     user_prompt_phase1 = build_user_prompt(user_template, context_block, data_block, constraints_block)
-    # Tell the model explicitly: generate Phase 1 only
     user_prompt_phase1 += "\n\n[INSTRUCTION TO MODEL] Produce **Phase 1** only. Do not produce Phase 2 yet."
-
     clarif_raw = call_model(system_prompt, user_prompt_phase1)
-    # Expect clarif_raw to contain either "No clarifications required" or a numbered list of questions.
 
-    # Option A: automated answers for CI (if provided)
+    # ---- Collect answers
     clarif_answers_path = pack / "clarifications.json"
     if clarif_answers_path.exists():
         clarif_answers = load_json(clarif_answers_path)
+        # If the file is still the placeholder, raise to force operator to fill it
+        if clarif_answers.get("_note"):
+            raise RuntimeError(f"Clarification answers required. Edit and remove _note in: {clarif_answers_path}")
     else:
-        # Option B: interactive collection (replace as needed)
-        raise RuntimeError("Clarification answers required. Provide packs/<scenario>/clarifications.json or implement an interactive flow.")
+        raise RuntimeError(f"Clarification answers file missing: {clarif_answers_path}")
 
     # Merge clarifications into inputs for Phase 2
     merged_inputs = inputs.copy()
     merged_inputs["clarifications"] = clarif_answers
 
     # ---- Phase 2: Structured Analysis
-    user_prompt_phase2 = build_user_prompt(user_template, context_block, json.dumps(merged_inputs, ensure_ascii=False, indent=2), constraints_block)
+    user_prompt_phase2 = build_user_prompt(
+        user_template,
+        context_block,
+        json.dumps(merged_inputs, ensure_ascii=False, indent=2),
+        constraints_block
+    )
     user_prompt_phase2 += "\n\n[INSTRUCTION TO MODEL] Produce **Phase 2** only (final structured analysis), using clarified inputs."
-
     final_raw = call_model(system_prompt, user_prompt_phase2)
 
-    # Expect final_raw to be JSON or parseable. If your model returns markdown, strip code fences first.
+    # Parse final output JSON
     try:
-        # naive parse: assume JSON
         output = json.loads(final_raw)
     except Exception as e:
         raise ValueError(f"Failed to parse model output as JSON. Raw:\n{final_raw}") from e
 
-    # Validators
+    # Validators (hard guardrails)
     schema_validator.assert_valid(output, str(root / "schemas" / "analysis_output.schema.json"))
     unit_validator.assert_valid(output, str(root / "core" / "policy_global.json"))
     math_validator.assert_valid(output)
     policy_validator.assert_valid(output, str(pack / "constraints.json"))
 
-    # Grading (optional): compare to expected
-    grader_result = grade(output, str(pack / "rubric.json"))
+    # Optional grading
+    grader_result = grade(output, str(rubric_path)) if rubric_path.exists() else {"score": 0, "max_score": 0, "notes": ["No rubric."]}
     output["_grader"] = grader_result
+    output["_clarifications_summary"] = clarif_raw
 
     return output, clarif_raw