merge latest refactoring and improve test coverage

Author: RCFans

src/omen/analysis/actor/__init__.py

@@ -3,16 +3,11 @@
 from __future__ import annotations
 
 from .query import build_events_snapshot, build_status_snapshot, snapshot_by_year
-
-
-def generate_persona_insight(*args, **kwargs):
-    from .insight import generate_persona_insight as _generate_persona_insight
-
-    return _generate_persona_insight(*args, **kwargs)
+from .insight import generate_persona_insight
 
 __all__ = [
     "build_events_snapshot",
     "build_status_snapshot",
     "generate_persona_insight",
     "snapshot_by_year",
-]
+]

src/omen/analysis/actor/formation.py

@@ -151,7 +151,7 @@ def extract_strategic_actor_identity(payload: dict[str, Any]) -> tuple[str, str]
     )
 
 
-def extract_strategic_actor_style_payload(payload: dict[str, Any]) -> dict[str, Any]:
+def strategic_style(payload: dict[str, Any]) -> dict[str, Any]:
     strategic_actor = find_strategic_actor(payload)
     profile = strategic_actor.get("profile") or {}
     style = profile.get("strategic_style") or {}

src/omen/cli/main.py

@@ -43,8 +43,8 @@
 )
 from omen.simulation.engine import run_simulation
 from omen.simulation.deterministic import (
-    try_run_deterministic_compare_from_scenario_input,
-    try_run_deterministic_simulate_from_scenario_input,
+    run_compare,
+    run_simulate_with_actor,
 )
 from omen.simulation.precision_gate import evaluate_precision_gates
 from omen.simulation.precision_metrics import evaluate_repeatability
@@ -397,7 +397,7 @@ def _print_deferred_scope_message(exc: Exception) -> None:
 
     if args.command == "simulate":
         try:
-            deterministic_payload = try_run_deterministic_simulate_from_scenario_input(
+            deterministic_payload = run_simulate_with_actor(
                 scenario_path=args.scenario,
                 actor_profile_ref=args.actor_profile_ref,
                 calculation_policy_version=args.calc_policy_version,
@@ -440,7 +440,7 @@ def _print_deferred_scope_message(exc: Exception) -> None:
         print(f"Saved explanation to {output_path}")
     elif args.command == "compare":
         try:
-            deterministic_payload = try_run_deterministic_compare_from_scenario_input(
+            deterministic_payload = run_compare(
                 scenario_path=args.scenario,
                 actor_profile_ref=args.actor_profile_ref,
                 calculation_policy_version=args.calc_policy_version,

src/omen/cli/situation.py

@@ -20,7 +20,7 @@
     save_situation_artifact,
     save_situation_markdown,
 )
-from omen.scenario.planner import plan_scenarios_from_situation
+from omen.scenario.planner import from_situation
 from omen.scenario.planner import ScenarioDecompositionValidationError
 from omen.ingest.synthesizer.services.situation import (
     LLMJsonValidationAbort,
@@ -424,7 +424,7 @@ def handle_scenario_command(args: Any) -> int:
             else _resolve_splitter_default_output_path(situation_path, pack_id)
         )
 
-        ontology = plan_scenarios_from_situation(
+        ontology = from_situation(
             situation_artifact=situation_artifact,
             pack_id=pack_id,
             pack_version=str(args.pack_version),

src/omen/ingest/synthesizer/builders/situation.py

@@ -2,11 +2,7 @@
 
 from __future__ import annotations
 
-from datetime import datetime
 from pathlib import Path
-from typing import Any
-
-from omen.ingest.reporter.markdown import render_situation_brief
 from omen.scenario.ingest_validator import DeferredScopeFeatureError
 
 
@@ -47,49 +43,6 @@ def validate_situation_source_or_raise(situation_file: str | Path) -> None:
     _validate_source_scope_or_raise(text)
 
 
-def build_scenario_ontology_from_situation_artifact(
-    *,
-    situation_artifact: dict[str, Any],
-    llm_decomposition: dict[str, Any],
-    pack_id: str,
-    pack_version: str,
-) -> dict[str, Any]:
-    from omen.scenario.planner import normalize_llm_scenarios_with_policy
-
-    scenarios = normalize_llm_scenarios_with_policy(
-        list(llm_decomposition.get("scenarios") or []),
-        source_hint=f"Derived from situation artifact: {situation_artifact.get('id', 'unknown')}",
-    )
-    source_meta = dict(llm_decomposition.get("source_meta") or {})
-    source_meta.setdefault(
-        "source_path",
-        str((situation_artifact.get("source_meta") or {}).get("source_path") or ""),
-    )
-    source_meta.setdefault("generated_at", datetime.now().isoformat())
-    source_meta["generated_from"] = "situation_artifact"
-
-    return {
-        "pack_id": pack_id,
-        "pack_version": pack_version,
-        "derived_from_situation_id": str(situation_artifact.get("id") or "unknown"),
-        "ontology_version": str(llm_decomposition.get("ontology_version") or "scenario_ontology_v1"),
-        "planning_query_ref": str(llm_decomposition.get("planning_query_ref") or "traces/planning_query.json"),
-        "prior_snapshot_ref": str(llm_decomposition.get("prior_snapshot_ref") or "traces/prior_snapshot.json"),
-        "scenarios": scenarios,
-        "source_meta": source_meta,
-    }
-
-
-def situation_artifact_to_markdown(situation: dict[str, Any], config_path: str = "config/llm.toml") -> str:
-    return render_situation_brief(situation, config_path=config_path)
-
-
-def scenario_ontology_to_deterministic_pack(ontology: dict) -> dict:
-    from omen.ingest.synthesizer.services.scenario import scenario_ontology_to_deterministic
-
-    return scenario_ontology_to_deterministic(ontology)
-
-
 def scenario_ontology_to_markdown(ontology: dict) -> str:
     lines: list[str] = []
     lines.append(f"# Scenario Ontology: {ontology.get('derived_from_situation_id', 'unknown')}")

src/omen/ingest/synthesizer/services/scenario.py

@@ -123,7 +123,7 @@ def _is_filled_field(field_name: str, value: Any) -> bool:
     return bool(str(value or "").strip())
 
 
-def _assess_scenario_decomposition_quality(payload: dict[str, Any]) -> dict[str, Any]:
+def _assess_quality(payload: dict[str, Any]) -> dict[str, Any]:
     scenarios = payload.get("scenarios")
     coerced = _coerce_slot_payloads(scenarios)
     by_slot: dict[str, Any] = coerced["by_slot"]
@@ -181,7 +181,7 @@ def _assess_scenario_decomposition_quality(payload: dict[str, Any]) -> dict[str,
     }
 
 
-def _normalize_decomposition_payload(payload: dict[str, Any]) -> dict[str, Any]:
+def _normalize(payload: dict[str, Any]) -> dict[str, Any]:
     scenarios = payload.get("scenarios")
     normalized_scenarios: list[Any]
 
@@ -235,7 +235,7 @@ def _normalize_decomposition_payload(payload: dict[str, Any]) -> dict[str, Any]:
     return payload
 
 
-def decompose_scenario_from_situation(
+def planning(
     *,
     situation_artifact: dict[str, Any],
     pack_id: str,
@@ -259,8 +259,8 @@ def decompose_scenario_from_situation(
         config_path=config_path,
         stage="situation_decompose_prompt",
     )
-    payload = _normalize_decomposition_payload(payload)
-    quality = _assess_scenario_decomposition_quality(payload)
+    payload = _normalize(payload)
+    quality = _assess_quality(payload)
 
     retries = 0
     if quality["schema_completeness_ratio"] < 0.5:
@@ -275,8 +275,8 @@ def decompose_scenario_from_situation(
             config_path=config_path,
             stage="situation_decompose_prompt",
         )
-        payload = _normalize_decomposition_payload(payload)
-        quality = _assess_scenario_decomposition_quality(payload)
+        payload = _normalize(payload)
+        quality = _assess_quality(payload)
         retries = 1
 
     payload.setdefault("pack_id", pack_id)
@@ -299,14 +299,14 @@ def decompose_scenario_from_situation(
     return payload
 
 
-def load_scenario_ontology_slice_payload(path: str | Path) -> dict[str, Any]:
+def load(path: str | Path) -> dict[str, Any]:
     scenario_path = Path(path)
     payload = json.loads(scenario_path.read_text(encoding="utf-8"))
     validated = validate_scenario_ontology_slice_or_raise(payload)
     return validated.model_dump()
 
 
-def scenario_ontology_to_deterministic(ontology: dict[str, Any]) -> dict[str, Any]:
+def pack(ontology: dict[str, Any]) -> dict[str, Any]:
     scenarios: list[dict[str, Any]] = []
     for scenario in ontology.get("scenarios", []):
         if not isinstance(scenario, dict):
@@ -336,9 +336,9 @@ def scenario_ontology_to_deterministic(ontology: dict[str, Any]) -> dict[str, An
     }
 
 
-def prepare_deterministic_inputs_from_scenario(path: str | Path) -> tuple[dict[str, Any], dict[str, dict[str, Any]]]:
-    ontology = load_scenario_ontology_slice_payload(path)
-    deterministic_pack = scenario_ontology_to_deterministic(ontology)
+def prepare(path: str | Path) -> tuple[dict[str, Any], dict[str, dict[str, Any]]]:
+    ontology = load(path)
+    deterministic_pack = pack(ontology)
     validated_pack = validate_deterministic_scenario_pack_or_raise(deterministic_pack)
     planned_scenarios = {
         str(item.get("scenario_key") or ""): dict(item)

src/omen/ingest/validators/scenario.py

@@ -92,6 +92,26 @@ def is_scenario_ontology_input_path(path: str | Path) -> bool:
     return is_scenario_ontology_input_payload(payload)
 
 
+def is_situation_planned_scenario_payload(payload: Any) -> bool:
+    if not is_scenario_ontology_input_payload(payload):
+        return False
+    if not isinstance(payload, dict):
+        return False
+
+    situation_id = str(payload.get("derived_from_situation_id") or "").strip()
+    planning_query_ref = str(payload.get("planning_query_ref") or "").strip()
+    prior_snapshot_ref = str(payload.get("prior_snapshot_ref") or "").strip()
+    return bool(situation_id and planning_query_ref and prior_snapshot_ref)
+
+
+def is_situation_planned_scenario_path(path: str | Path) -> bool:
+    try:
+        payload = json.loads(Path(path).read_text(encoding="utf-8"))
+    except Exception:
+        return False
+    return is_situation_planned_scenario_payload(payload)
+
+
 class ResultArtifactContract(BaseModel):
     scenario_id: str = Field(min_length=1)
     outcome_class: str = Field(min_length=1)

src/omen/scenario/loader.py

@@ -8,8 +8,8 @@
 
 from omen.ingest.synthesizer.builders.situation import (
     scenario_ontology_to_markdown,
-    situation_artifact_to_markdown,
 )
+from omen.ingest.reporter.markdown import render_situation_brief
 from omen.ingest.validators.scenario import (
     ScenarioConfig,
     validate_case_package_or_raise,
@@ -122,7 +122,7 @@ def save_situation_markdown(path: str | Path, payload: dict[str, Any], config_pa
     output_path = Path(path)
     validated = validate_situation_artifact_or_raise(payload)
     output_path.parent.mkdir(parents=True, exist_ok=True)
-    markdown = situation_artifact_to_markdown(validated.model_dump(), config_path=config_path)
+    markdown = render_situation_brief(validated.model_dump(), config_path=config_path)
     output_path.write_text(markdown, encoding="utf-8")
     return output_path