Removed unintended embedded repo and added to gitignore

.gitignore

@@ -4,3 +4,4 @@ blueprint.txt
 artifacts/*
 *.html
 .venv/
+.tmp_compare/

.tmp_compare/Meta-s-LedgerShield

@@ -0,0 +1 @@
+Subproject commit fd5c9b60ddfbd2eba9d09001938b63169ac98f7b

README.md

@@ -209,12 +209,13 @@ The FastAPI app serves:
 - `/`: overview page
 - `/dashboard`: generated benchmark dashboard
 - `/api/environment`: environment metadata
-- `/healthz`: health check
+- `/health`: health check (validator-friendly alias)
+- `/healthz`: health check (legacy alias)
 - `/openenv.yaml`: OpenEnv HTTP spec stub
 - `/openenv/tasks`: task enumeration
-- `/openenv/reset`: episode reset endpoint
-- `/openenv/step`: episode step endpoint
-- `/openenv/state/{session_id}`: current session state endpoint
+- `/reset` and `/openenv/reset`: episode reset endpoints
+- `/step` and `/openenv/step`: episode step endpoints
+- `/state` and `/openenv/state/{session_id}`: session state endpoints (`/state` returns the latest session)
 
 ## Automated Validation
 

datasets/fixed_levels/leaderboard_fixed_levels.json

@@ -881,5 +881,48 @@
     },
     "run_id": "run_0021",
     "run_name": "fixed_levels_qwen_swarm"
+  },
+  {
+    "config": {
+      "llm_model": "gpt-5.4-mini",
+      "llm_provider": "openai",
+      "max_agents": 3,
+      "max_breadth": 2,
+      "max_depth": 2,
+      "max_steps": 24,
+      "max_width": 2,
+      "seed": 2026,
+      "seeded_questions": 30,
+      "swarm_enabled": true
+    },
+    "created_at": "2026-04-07T15:59:20+00:00",
+    "episodes": 1,
+    "metrics": {
+      "avg_compactness_reward": 0.0,
+      "avg_connectivity_gain_reward": 0.0,
+      "avg_connectivity_reward": 0.0,
+      "avg_diversity_reward": 0.0,
+      "avg_entity_informativeness_reward": 0.0,
+      "avg_format_reward": 0.15,
+      "avg_graph_f1": 0.0,
+      "avg_knowledge_carrier_reward": 0.0,
+      "avg_knowledge_indexing_reward": 0.0,
+      "avg_relation_informativeness_reward": 0.0,
+      "avg_reward": 0.5519400198339021,
+      "avg_soft_shaping_reward": 0.0,
+      "avg_spawn_count": 0.0,
+      "avg_spawn_critical_steps": 0.0,
+      "avg_steps_to_solution": 1.0,
+      "deanonymization_accuracy": 0.0,
+      "leaderboard_score": 0.2785970009916951,
+      "retrieval_signal": 0.5,
+      "spawn_completion_rate": 0.0,
+      "spawn_signal": 0.4,
+      "structural_signal": 0.5,
+      "task_success_rate": 0.0,
+      "tool_efficiency": 1.0
+    },
+    "run_id": "run_0022",
+    "run_name": "fixed_levels_qwen_swarm"
   }
 ]

inference.py

@@ -97,7 +97,7 @@ def log_step(step: int, action: str, reward: float, done: bool, error: str | Non
 def log_end(success: bool, steps: int, score: float, rewards: list[float]) -> None:
     rewards_text = ",".join(f"{value:.2f}" for value in rewards)
     print(
-        f"[END] success={str(bool(success)).lower()} steps={steps} score={score:.3f} rewards={rewards_text}",
+        f"[END] success={str(bool(success)).lower()} steps={steps} score={score:.2f} rewards={rewards_text}",
         flush=True,
     )
 

openenv.yaml

@@ -7,7 +7,7 @@ transport:
 endpoints:
   health:
     method: GET
-    path: /healthz
+    path: /health
   metadata:
     method: GET
     path: /api/environment
@@ -16,13 +16,13 @@ endpoints:
     path: /openenv/tasks
   reset:
     method: POST
-    path: /openenv/reset
+    path: /reset
   step:
     method: POST
-    path: /openenv/step
+    path: /step
   state:
     method: GET
-    path: /openenv/state/{session_id}
+    path: /state
 models:
   action_space:
     - CALL_TOOL

server.py

@@ -43,6 +43,7 @@ OPENENV_SPEC_PATH = Path("openenv.yaml")
 _SESSION_LOCK = Lock()
 _SESSIONS: dict[str, OSINTEnvironment] = {}
 _RESET_COUNTER = 0
+_LATEST_SESSION_ID: str | None = None
 
 
 def _load_json(path: Path) -> dict[str, Any] | None:
@@ -147,8 +148,26 @@ def _get_session_env(session_id: str) -> OSINTEnvironment:
 
 
 def _store_session(session_id: str, env: OSINTEnvironment) -> None:
+    global _LATEST_SESSION_ID
     with _SESSION_LOCK:
         _SESSIONS[session_id] = env
+        _LATEST_SESSION_ID = session_id
+
+
+def _latest_session_id() -> str:
+    with _SESSION_LOCK:
+        if _LATEST_SESSION_ID and _LATEST_SESSION_ID in _SESSIONS:
+            return _LATEST_SESSION_ID
+        if _SESSIONS:
+            return next(reversed(_SESSIONS))
+    raise HTTPException(status_code=404, detail="No active session. Call /reset first.")
+
+
+def _resolve_session_id(session_id: str | None) -> str:
+    token = str(session_id or "").strip()
+    if token:
+        return token
+    return _latest_session_id()
 
 
 def _task_lookup(env: OSINTEnvironment) -> dict[str, Any]:
@@ -400,6 +419,11 @@ def healthz() -> JSONResponse:
     return JSONResponse({"status": "ok"})
 
 
+@app.get("/health")
+def health() -> JSONResponse:
+    return healthz()
+
+
 @app.get("/openenv.yaml")
 def openenv_spec() -> FileResponse:
     return FileResponse(OPENENV_SPEC_PATH, media_type="text/yaml")
@@ -456,8 +480,12 @@ async def openenv_reset(request: Request) -> OpenEnvResponseEnvelope:
 
 
 @app.post("/openenv/step", response_model=OpenEnvResponseEnvelope)
+@app.post("/openenv/step/", response_model=OpenEnvResponseEnvelope, include_in_schema=False)
+@app.post("/step", response_model=OpenEnvResponseEnvelope, include_in_schema=False)
+@app.post("/step/", response_model=OpenEnvResponseEnvelope, include_in_schema=False)
 def openenv_step(request: OpenEnvActionRequest) -> OpenEnvResponseEnvelope:
-    env = _get_session_env(request.session_id)
+    session_id = _resolve_session_id(request.session_id)
+    env = _get_session_env(session_id)
     action_type_raw = request.resolved_action_type().strip()
     if not action_type_raw:
         raise HTTPException(status_code=400, detail="Missing action_type")
@@ -467,7 +495,7 @@ def openenv_step(request: OpenEnvActionRequest) -> OpenEnvResponseEnvelope:
         raise HTTPException(status_code=400, detail=f"Unsupported action_type {action_type_raw}") from exc
     observation, reward, done, info = env.step(Action(action_type=action_type, payload=request.resolved_payload()))
     return OpenEnvResponseEnvelope(
-        session_id=request.session_id,
+        session_id=session_id,
         observation=_serialize_observation(observation),
         reward=float(reward),
         done=bool(done),
@@ -475,8 +503,7 @@ def openenv_step(request: OpenEnvActionRequest) -> OpenEnvResponseEnvelope:
     )
 
 
-@app.get("/openenv/state/{session_id}", response_model=OpenEnvResponseEnvelope)
-def openenv_state(session_id: str) -> OpenEnvResponseEnvelope:
+def _state_response(session_id: str) -> OpenEnvResponseEnvelope:
     env = _get_session_env(session_id)
     if env.state is None:
         raise HTTPException(status_code=400, detail="Session has not been reset yet")
@@ -489,6 +516,18 @@ def openenv_state(session_id: str) -> OpenEnvResponseEnvelope:
     )
 
 
+@app.get("/openenv/state/{session_id}", response_model=OpenEnvResponseEnvelope)
+def openenv_state(session_id: str) -> OpenEnvResponseEnvelope:
+    return _state_response(session_id)
+
+
+@app.get("/openenv/state", response_model=OpenEnvResponseEnvelope, include_in_schema=False)
+@app.get("/state", response_model=OpenEnvResponseEnvelope, include_in_schema=False)
+@app.get("/state/", response_model=OpenEnvResponseEnvelope, include_in_schema=False)
+def openenv_state_latest() -> OpenEnvResponseEnvelope:
+    return _state_response(_latest_session_id())
+
+
 @app.post("/openenv/report_inference", response_model=OpenEnvInferenceReportResponse)
 def openenv_report_inference(request: OpenEnvInferenceReportRequest) -> OpenEnvInferenceReportResponse:
     env = _build_environment()

src/osint_env/api/models.py

@@ -26,7 +26,10 @@ class OpenEnvResetRequest(BaseModel):
 
 
 class OpenEnvActionRequest(BaseModel):
-    session_id: str
+    session_id: str | None = Field(
+        default=None,
+        description="Session identifier. Optional for /step compatibility alias, which uses the latest session.",
+    )
     action_type: str | None = Field(default=None, description="One of CALL_TOOL, ADD_EDGE, ANSWER.")
     payload: dict[str, Any] = Field(default_factory=dict)
     action: dict[str, Any] | None = None

tests/test_server.py

@@ -16,6 +16,12 @@ def test_server_health():
     assert response.json()["status"] == "ok"
 
 
+def test_server_health_alias():
+    response = client.get("/health")
+    assert response.status_code == 200
+    assert response.json()["status"] == "ok"
+
+
 def test_server_environment_metadata():
     response = client.get("/api/environment")
     assert response.status_code == 200
@@ -115,6 +121,36 @@ def test_openenv_step_accepts_nested_action_payload():
     assert step.json()["done"] is True
 
 
+def test_step_alias_uses_latest_session_when_session_id_missing():
+    reset = client.post("/reset", json={"task_index": 0})
+    assert reset.status_code == 200
+    session_id = reset.json()["session_id"]
+
+    step = client.post(
+        "/step",
+        json={
+            "action_type": "ANSWER",
+            "payload": {"answer": "unknown"},
+        },
+    )
+    assert step.status_code == 200
+    body = step.json()
+    assert body["session_id"] == session_id
+    assert body["done"] is True
+
+
+def test_state_alias_returns_latest_session():
+    reset = client.post("/reset", json={"task_index": 0})
+    assert reset.status_code == 200
+    session_id = reset.json()["session_id"]
+
+    state = client.get("/state")
+    assert state.status_code == 200
+    body = state.json()
+    assert body["session_id"] == session_id
+    assert "task" in body["observation"]
+
+
 def test_report_inference_updates_latest_evaluation_and_dashboard(tmp_path, monkeypatch):
     latest_evaluation = tmp_path / "latest_evaluation.json"
     space_dashboard = tmp_path / "space_dashboard.html"