Fix seeded context retrieval and latest Space dashboard

server.py

@@ -37,6 +37,13 @@ def _load_json(path: Path) -> dict[str, Any] | None:
     return payload if isinstance(payload, dict) else None
 
 
+def _path_mtime(path: Path) -> float:
+    try:
+        return path.stat().st_mtime
+    except OSError:
+        return 0.0
+
+
 def _build_environment() -> OSINTEnvironment:
     shared = load_shared_config(SPACE_CONFIG_PATH)
     env_cfg = clone_environment_config(shared.environment)
@@ -97,31 +104,37 @@ def _space_snapshot() -> dict[str, Any]:
     snapshot = dict(_base_environment_snapshot())
 
     baseline_payload = _load_json(LATEST_BASELINE_OUTPUT)
+    evaluation_payload = _load_json(LATEST_EVALUATION_OUTPUT)
+
+    candidates: list[tuple[float, str, dict[str, Any]]] = []
     if baseline_payload is not None and isinstance(baseline_payload.get("summary"), dict):
-        dashboard_path = Path(
-            str(
-                ((baseline_payload.get("run") or {}).get("dashboard_path"))
-                or "artifacts/baselines/openai_fixed_levels_dashboard.html"
+        candidates.append((_path_mtime(LATEST_BASELINE_OUTPUT), "baseline_output", baseline_payload))
+    if evaluation_payload is not None and isinstance(evaluation_payload.get("summary"), dict):
+        candidates.append((_path_mtime(LATEST_EVALUATION_OUTPUT), "latest_evaluation", evaluation_payload))
+
+    if candidates:
+        _, source, payload = max(candidates, key=lambda item: item[0])
+        snapshot["summary"] = dict(payload["summary"])
+        snapshot["source"] = source
+        if source == "baseline_output":
+            dashboard_path = Path(
+                str(
+                    ((payload.get("run") or {}).get("dashboard_path"))
+                    or "artifacts/baselines/openai_fixed_levels_dashboard.html"
+                )
             )
-        )
-        if dashboard_path.exists():
-            snapshot["dashboard_path"] = str(dashboard_path)
-        snapshot["summary"] = dict(baseline_payload["summary"])
-        snapshot["source"] = "baseline_output"
-        return snapshot
+            if dashboard_path.exists():
+                snapshot["dashboard_path"] = str(dashboard_path)
+            return snapshot
 
-    evaluation_payload = _load_json(LATEST_EVALUATION_OUTPUT)
-    if evaluation_payload is not None and isinstance(evaluation_payload.get("summary"), dict):
         env = _build_environment()
         dashboard_path = export_dashboard(
             env=env,
-            evaluation=evaluation_payload,
+            evaluation=payload,
             leaderboard_records=[],
             output_path=str(SPACE_DASHBOARD),
         )
-        snapshot["summary"] = dict(evaluation_payload["summary"])
         snapshot["dashboard_path"] = dashboard_path
-        snapshot["source"] = "latest_evaluation"
         return snapshot
 
     preview = _preview_snapshot()

src/osint_env/baselines/openai_runner.py

@@ -22,6 +22,9 @@ Available actions are provided as function tools. On every turn, call exactly on
 Rules:
 - Solve the question using only tool outputs and the current graph snapshot.
 - When you have enough evidence, call submit_answer with the exact node id string.
+- Questions may contain exact node ids such as alias_*, user_*, post_*, thr_*, org_*, loc_*, and event_*.
+- Prefer direct id lookups when an exact id is present in the question.
+- get_post and get_thread retrieve exact seeded records by id.
 - Use add_edge only for relationships strongly supported by the evidence you have already collected.
 - Prefer concise, high-signal tool queries.
 - Never guess free-form prose when a node id answer is required.
@@ -74,13 +77,19 @@ def build_action_tools() -> list[dict[str, Any]]:
     return [
         _tool_schema(
             "search_posts",
-            "Search microblog posts by substring query.",
+            "Search microblog posts by substring over post text, post id, author id, canonical user id, or referenced entity ids/names.",
             {"query": {"type": "string", "description": "Substring to search for in post text."}},
             ["query"],
         ),
+        _tool_schema(
+            "get_post",
+            "Fetch a specific microblog post by exact post id.",
+            {"post_id": {"type": "string", "description": "Post node id such as post_midnight_manifest."}},
+            ["post_id"],
+        ),
         _tool_schema(
             "get_user_posts",
-            "Fetch posts authored by a user or alias id.",
+            "Fetch posts authored by a user or alias id. Alias ids are resolved to the canonical user and vice versa.",
             {"user_id": {"type": "string", "description": "User or alias node id."}},
             ["user_id"],
         ),
@@ -110,13 +119,13 @@ def build_action_tools() -> list[dict[str, Any]]:
         ),
         _tool_schema(
             "get_profile",
-            "Fetch a profile record by canonical user id.",
-            {"user_id": {"type": "string", "description": "Canonical user node id."}},
+            "Fetch a profile record by canonical user id or alias id.",
+            {"user_id": {"type": "string", "description": "Canonical user node id or alias id."}},
             ["user_id"],
         ),
         _tool_schema(
             "search_people",
-            "Search profiles by name and or organization.",
+            "Search profiles by name, alias id, organization name, or organization id.",
             {
                 "name": {"type": "string", "description": "Optional name substring.", "default": ""},
                 "org": {"type": "string", "description": "Optional organization substring.", "default": ""},
@@ -125,8 +134,8 @@ def build_action_tools() -> list[dict[str, Any]]:
         ),
         _tool_schema(
             "get_connections",
-            "Fetch explicit profile connections for a user.",
-            {"user_id": {"type": "string", "description": "Canonical user node id."}},
+            "Fetch explicit profile connections for a user or alias id.",
+            {"user_id": {"type": "string", "description": "Canonical user node id or alias id."}},
             ["user_id"],
         ),
         _tool_schema(
@@ -284,11 +293,12 @@ class OpenAIBaselineRunner:
 
     def _episode(self, env: OSINTEnvironment, episode_index: int) -> tuple[dict[str, Any], dict[str, Any]]:
         obs = env.reset()
+        initial_observation = _observation_payload(env, obs, env.config.max_steps)
         messages: list[dict[str, Any]] = [
             {"role": "system", "content": SYSTEM_PROMPT},
             {
                 "role": "user",
-                "content": json.dumps(_observation_payload(env, obs, env.config.max_steps), indent=2, sort_keys=True),
+                "content": json.dumps(initial_observation, indent=2, sort_keys=True),
             },
         ]
 
@@ -322,7 +332,14 @@ class OpenAIBaselineRunner:
                 }
                 messages.append({"role": "assistant", "content": content})
                 messages.append({"role": "tool", "tool_call_id": "fallback_submit", "content": json.dumps(tool_result)})
-                turn_trace.append({"assistant_content": content, "tool_name": "submit_answer", "args": {"answer": fallback_answer}})
+                turn_trace.append(
+                    {
+                        "assistant_content": content,
+                        "tool_name": "submit_answer",
+                        "args": {"answer": fallback_answer},
+                        "tool_payload": tool_result,
+                    }
+                )
                 break
 
             tool_call = tool_calls[0]
@@ -360,16 +377,41 @@ class OpenAIBaselineRunner:
             }
             messages.append(assistant_message)
             messages.append({"role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(tool_payload, sort_keys=True)})
-            turn_trace.append({"assistant_content": content, "tool_name": tool_name, "args": args, "reward": reward, "done": done})
+            turn_trace.append(
+                {
+                    "assistant_content": content,
+                    "tool_name": tool_name,
+                    "args": args,
+                    "reward": reward,
+                    "done": done,
+                    "tool_payload": tool_payload,
+                }
+            )
 
         if not done:
             obs, _, done, info = env.step(Action(ActionType.ANSWER, {"answer": "unknown"}))
-            turn_trace.append({"assistant_content": "", "tool_name": "submit_answer", "args": {"answer": "unknown"}, "reward": 0.0, "done": done})
+            final_payload = {
+                "submitted_answer": "unknown",
+                "reward": 0.0,
+                "done": done,
+                "observation": _observation_payload(env, obs, env.config.max_steps),
+                "info": _safe_info(info),
+            }
+            turn_trace.append(
+                {
+                    "assistant_content": "",
+                    "tool_name": "submit_answer",
+                    "args": {"answer": "unknown"},
+                    "reward": 0.0,
+                    "done": done,
+                    "tool_payload": final_payload,
+                }
+            )
 
         info = dict(info)
         info["openai_system_fingerprints"] = raw_fingerprints
         info["usage"] = usage_totals
-        return info, {"turns": turn_trace}
+        return info, {"initial_observation": initial_observation, "turns": turn_trace}
 
     def run(self) -> dict[str, Any]:
         env = self._build_environment()

src/osint_env/data/generator.py

@@ -27,6 +27,7 @@ class PlatformViews:
     microblog_posts: list[dict]
     forum_threads: list[dict]
     profiles: list[dict]
+    alias_lookup: dict[str, str]
 
 
 class DatasetGenerator:
@@ -589,6 +590,13 @@ class DatasetGenerator:
         users = [n for n in graph.nodes.values() if n.node_type == NodeType.USER]
         aliases = [n for n in graph.nodes.values() if n.node_type == NodeType.ALIAS]
         alias_owner = {e.src: e.dst for e in graph.edges if e.rel == "alias_of"}
+        user_aliases: dict[str, list[str]] = {}
+        for alias_id, user_id in alias_owner.items():
+            user_aliases.setdefault(user_id, []).append(alias_id)
+        node_names = {
+            node_id: str((node.attrs or {}).get("name") or (node.attrs or {}).get("handle") or node_id)
+            for node_id, node in graph.nodes.items()
+        }
 
         microblog_posts: list[dict] = []
         for i, user in enumerate(users):
@@ -605,11 +613,46 @@ class DatasetGenerator:
                     "user_id": poster,
                     "canonical_user": alias_owner.get(poster, user.node_id),
                     "text": text,
+                    "references": [],
+                    "reference_names": [],
                     "mentions": [f"user_{self.rng.randint(0, self.config.n_users - 1)}"],
                     "timestamp": 1000 + i,
                 }
             )
 
+        authored_posts: dict[str, str] = {}
+        post_references: dict[str, list[str]] = {}
+        for edge in graph.edges:
+            if edge.rel == "authored_post":
+                authored_posts[edge.dst] = edge.src
+            elif edge.rel == "references" and edge.src.startswith("post_"):
+                post_references.setdefault(edge.src, []).append(edge.dst)
+
+        for post_id, author_id in authored_posts.items():
+            refs = post_references.get(post_id, [])
+            ref_names = [node_names.get(ref, ref) for ref in refs]
+            author_label = node_names.get(author_id, author_id)
+            text_parts = [f"{post_id} update from {author_label}"]
+            if ref_names:
+                text_parts.append("references " + ", ".join(ref_names))
+            if refs:
+                text_parts.append("ids " + ", ".join(refs))
+            post_payload = {
+                "post_id": post_id,
+                "user_id": author_id,
+                "canonical_user": alias_owner.get(author_id, author_id),
+                "text": ". ".join(text_parts),
+                "references": refs,
+                "reference_names": ref_names,
+                "mentions": [],
+                "timestamp": 5000 + len(microblog_posts),
+            }
+            existing_idx = next((idx for idx, row in enumerate(microblog_posts) if row["post_id"] == post_id), None)
+            if existing_idx is None:
+                microblog_posts.append(post_payload)
+            else:
+                microblog_posts[existing_idx] = post_payload
+
         forum_threads: list[dict] = []
         for i in range(max(8, self.config.n_users // 3)):
             author = self.rng.choice(users).node_id
@@ -622,18 +665,60 @@ class DatasetGenerator:
                         {"user_id": self.rng.choice(users).node_id, "text": "Following this."},
                         {"user_id": self.rng.choice(users).node_id, "text": "Interesting link."},
                     ],
+                    "references": [],
+                    "discusses": [],
                 }
             )
 
+        authored_threads: dict[str, str] = {}
+        thread_refs: dict[str, list[str]] = {}
+        thread_discusses: dict[str, list[str]] = {}
+        for edge in graph.edges:
+            if edge.rel == "authored_thread":
+                authored_threads[edge.dst] = edge.src
+            elif edge.rel == "references" and edge.src.startswith(("thr_", "thread_")):
+                thread_refs.setdefault(edge.src, []).append(edge.dst)
+            elif edge.rel == "discusses" and edge.src.startswith(("thr_", "thread_")):
+                thread_discusses.setdefault(edge.src, []).append(edge.dst)
+
+        for thread_id, author_id in authored_threads.items():
+            node = graph.nodes.get(thread_id)
+            refs = thread_refs.get(thread_id, [])
+            discussed = thread_discusses.get(thread_id, [])
+            comments = []
+            for ref in refs:
+                comments.append({"user_id": author_id, "text": f"Reference: {node_names.get(ref, ref)} ({ref})"})
+            for item in discussed:
+                comments.append({"user_id": author_id, "text": f"Discusses: {node_names.get(item, item)} ({item})"})
+            thread_payload = {
+                "thread_id": thread_id,
+                "topic": str((node.attrs or {}).get("topic", "seeded")) if node else "seeded",
+                "author_id": author_id,
+                "title": node_names.get(thread_id, thread_id),
+                "comments": comments,
+                "references": refs,
+                "discusses": discussed,
+            }
+            existing_idx = next((idx for idx, row in enumerate(forum_threads) if row["thread_id"] == thread_id), None)
+            if existing_idx is None:
+                forum_threads.append(thread_payload)
+            else:
+                forum_threads[existing_idx] = thread_payload
+
         profiles: list[dict] = []
         for user in users:
             conns = [e.dst for e in graph.edges if e.src == user.node_id and e.rel == "connected_to"][:5]
+            org_id = next((e.dst for e in graph.edges if e.src == user.node_id and e.rel == "works_at"), "")
+            location_id = next((e.dst for e in graph.edges if e.src == user.node_id and e.rel == "located_in"), "")
             profiles.append(
                 {
                     "user_id": user.node_id,
                     "name": user.attrs["name"],
                     "org": user.attrs["org"],
+                    "org_id": org_id,
                     "location": user.attrs["location"],
+                    "location_id": location_id,
+                    "alias_ids": sorted(user_aliases.get(user.node_id, [])),
                     "connections": conns,
                     "work_history": [user.attrs["org"]],
                 }
@@ -645,12 +730,15 @@ class DatasetGenerator:
                     "user_id": f"noise_{i}",
                     "name": f"P{self.rng.randint(100,999)}",
                     "org": self.rng.choice(["Stealth Co", "Unknown Ventures"]),
+                    "org_id": "",
                     "location": self.rng.choice(["Remote", "Unknown"]),
+                    "location_id": "",
+                    "alias_ids": [],
                     "connections": [],
                     "work_history": [],
                 }
             )
-        return PlatformViews(microblog_posts, forum_threads, profiles)
+        return PlatformViews(microblog_posts, forum_threads, profiles, alias_lookup=alias_owner)
 
     def generate_tasks(self, graph: CanonicalGraph, views: PlatformViews, count: int = 12) -> list[TaskInstance]:
         tasks = self._seeded_tasks(graph)

src/osint_env/platforms/tools.py

@@ -9,13 +9,40 @@ from osint_env.data.generator import PlatformViews
 class ToolRegistry:
     def __init__(self, views: PlatformViews):
         self.views = views
+        self.alias_lookup = dict(getattr(views, "alias_lookup", {}))
         self._index()
 
+    @staticmethod
+    def _normalize_lookup_token(value: str) -> str:
+        token = str(value or "").strip().lower()
+        for prefix in ("org_", "loc_", "event_", "post_", "thr_", "thread_", "alias_", "user_"):
+            if token.startswith(prefix):
+                token = token[len(prefix) :]
+                break
+        return token.replace("_", " ")
+
+    def _resolve_user_ids(self, user_id: str) -> list[str]:
+        user_id = str(user_id or "").strip()
+        if not user_id:
+            return []
+        resolved = [user_id]
+        canonical = self.alias_lookup.get(user_id)
+        if canonical and canonical not in resolved:
+            resolved.append(canonical)
+        for alias_id, owner in self.alias_lookup.items():
+            if owner == user_id and alias_id not in resolved:
+                resolved.append(alias_id)
+        return resolved
+
     def _index(self) -> None:
         self.posts_by_user: dict[str, list[dict[str, Any]]] = defaultdict(list)
         self.mentions_by_user: dict[str, list[dict[str, Any]]] = defaultdict(list)
+        self.posts_by_id = {post["post_id"]: post for post in self.views.microblog_posts}
         for post in self.views.microblog_posts:
             self.posts_by_user[post["user_id"]].append(post)
+            canonical_user = post.get("canonical_user")
+            if canonical_user:
+                self.posts_by_user[canonical_user].append(post)
             for m in post.get("mentions", []):
                 self.mentions_by_user[m].append(post)
 
@@ -36,19 +63,59 @@ class ToolRegistry:
 
     def search_posts(self, query: str, time_range: tuple[int, int] | None = None) -> dict[str, Any]:
         start, end = time_range or (0, 10**9)
+        needle = str(query or "").lower()
         results = [
-            p for p in self.views.microblog_posts if query.lower() in p["text"].lower() and start <= p["timestamp"] <= end
+            p
+            for p in self.views.microblog_posts
+            if start <= p["timestamp"] <= end
+            and (
+                needle in p["text"].lower()
+                or needle in str(p.get("post_id", "")).lower()
+                or needle in str(p.get("user_id", "")).lower()
+                or needle in str(p.get("canonical_user", "")).lower()
+                or any(needle in str(ref).lower() for ref in p.get("references", []))
+                or any(needle in str(ref).lower() for ref in p.get("reference_names", []))
+            )
         ]
         return {"results": results[:20], "count": len(results)}
 
+    def get_post(self, post_id: str) -> dict[str, Any]:
+        post = self.posts_by_id.get(post_id)
+        return {"result": post, "found": post is not None}
+
     def get_user_posts(self, user_id: str) -> dict[str, Any]:
-        return {"results": self.posts_by_user.get(user_id, []), "count": len(self.posts_by_user.get(user_id, []))}
+        results: list[dict[str, Any]] = []
+        seen_post_ids: set[str] = set()
+        for resolved_id in self._resolve_user_ids(user_id):
+            for post in self.posts_by_user.get(resolved_id, []):
+                post_id = str(post.get("post_id", ""))
+                if post_id in seen_post_ids:
+                    continue
+                seen_post_ids.add(post_id)
+                results.append(post)
+        return {"results": results, "count": len(results)}
 
     def get_mentions(self, user_id: str) -> dict[str, Any]:
-        return {"results": self.mentions_by_user.get(user_id, []), "count": len(self.mentions_by_user.get(user_id, []))}
+        results: list[dict[str, Any]] = []
+        seen_post_ids: set[str] = set()
+        for resolved_id in self._resolve_user_ids(user_id):
+            for post in self.mentions_by_user.get(resolved_id, []):
+                post_id = str(post.get("post_id", ""))
+                if post_id in seen_post_ids:
+                    continue
+                seen_post_ids.add(post_id)
+                results.append(post)
+        return {"results": results, "count": len(results)}
 
     def search_threads(self, topic: str) -> dict[str, Any]:
-        results = [t for t in self.views.forum_threads if t["topic"] == topic]
+        needle = str(topic or "").strip().lower()
+        results = [
+            t
+            for t in self.views.forum_threads
+            if t["topic"] == topic
+            or needle in str(t.get("thread_id", "")).lower()
+            or needle in str(t.get("title", "")).lower()
+        ]
         return {"results": results[:20], "count": len(results)}
 
     def get_thread(self, thread_id: str) -> dict[str, Any]:
@@ -56,21 +123,46 @@ class ToolRegistry:
         return {"result": thread, "found": thread is not None}
 
     def get_user_activity(self, user_id: str) -> dict[str, Any]:
-        acts = self.activity_by_user.get(user_id, [])
+        acts: list[dict[str, Any]] = []
+        seen = set()
+        for resolved_id in self._resolve_user_ids(user_id):
+            for activity in self.activity_by_user.get(resolved_id, []):
+                key = (activity.get("kind"), activity.get("thread_id"))
+                if key in seen:
+                    continue
+                seen.add(key)
+                acts.append(activity)
         return {"results": acts, "count": len(acts)}
 
     def get_profile(self, user_id: str) -> dict[str, Any]:
-        profile = self.profiles_by_user.get(user_id)
+        resolved_ids = self._resolve_user_ids(user_id)
+        profile = next((self.profiles_by_user.get(candidate) for candidate in resolved_ids if self.profiles_by_user.get(candidate)), None)
         return {"result": profile, "found": profile is not None}
 
     def search_people(self, name: str | None = None, org: str | None = None) -> dict[str, Any]:
         results = self.views.profiles
         if name:
-            results = [p for p in results if name.lower() in p["name"].lower()]
+            name_query = str(name).lower()
+            results = [
+                p
+                for p in results
+                if name_query in p["name"].lower()
+                or name_query in p["user_id"].lower()
+                or any(name_query in alias.lower() for alias in p.get("alias_ids", []))
+            ]
         if org:
-            results = [p for p in results if org.lower() in p["org"].lower()]
+            org_query = str(org).lower()
+            normalized_org = self._normalize_lookup_token(org_query)
+            results = [
+                p
+                for p in results
+                if org_query in p["org"].lower()
+                or org_query in str(p.get("org_id", "")).lower()
+                or (normalized_org and normalized_org in p["org"].lower())
+            ]
         return {"results": results[:20], "count": len(results)}
 
     def get_connections(self, user_id: str) -> dict[str, Any]:
-        profile = self.profiles_by_user.get(user_id)
+        resolved_ids = self._resolve_user_ids(user_id)
+        profile = next((self.profiles_by_user.get(candidate) for candidate in resolved_ids if self.profiles_by_user.get(candidate)), None)
         return {"results": profile["connections"] if profile else [], "count": len(profile["connections"]) if profile else 0}

tests/test_generator.py

@@ -66,10 +66,31 @@ def test_generator_outputs():
     views = gen.build_platform_views(graph)
     tasks = gen.generate_tasks(graph, views, count=5)
     assert len(graph.nodes) >= 20
-    assert len(views.microblog_posts) == 20
+    assert len(views.microblog_posts) >= 20
     assert len(tasks) == 5
 
 
+def test_seeded_views_include_seeded_posts_and_threads():
+    from osint_env.config import clone_environment_config, load_seeding_config, load_shared_config
+
+    shared = load_shared_config("datasets/fixed_levels/shared_config_fixed_levels.json")
+    cfg = clone_environment_config(shared.environment)
+    cfg.seeding = load_seeding_config("datasets/fixed_levels/seed_fixed_levels.json")
+    cfg.llm.provider = "mock"
+
+    gen = DatasetGenerator(cfg)
+    graph = gen.build_canonical_graph()
+    views = gen.build_platform_views(graph)
+
+    seeded_post = next((post for post in views.microblog_posts if post["post_id"] == "post_midnight_manifest"), None)
+    seeded_thread = next((thread for thread in views.forum_threads if thread["thread_id"] == "thr_supply_leak"), None)
+
+    assert seeded_post is not None
+    assert "loc_dockyard17" in seeded_post["references"]
+    assert seeded_thread is not None
+    assert "org_northbridge_logistics" in seeded_thread["references"]
+
+
 def test_graph_generation_uses_parallel_shared_context_workers():
     cfg = EnvironmentConfig(n_users=12, seed=9)
     cfg.seeding.llm_generate_remaining_graph = True

tests/test_openai_baseline.py

@@ -7,6 +7,7 @@ def test_openai_baseline_toolset_contains_answer_and_graph_actions():
     assert "submit_answer" in names
     assert "add_edge" in names
     assert "search_memory" in names
+    assert "get_post" in names
 
 
 def test_gpt5_request_kwargs_avoid_temperature_and_use_max_completion_tokens():

tests/test_server.py

@@ -1,5 +1,8 @@
+import json
+
 from fastapi.testclient import TestClient
 
+import server
 from server import app
 
 
@@ -20,3 +23,48 @@ def test_server_environment_metadata():
     assert "observation_space" in body
     assert "summary" in body
 
+
+def test_space_snapshot_prefers_newer_evaluation_payload(tmp_path, monkeypatch):
+    baseline_path = tmp_path / "baseline.json"
+    evaluation_path = tmp_path / "evaluation.json"
+    baseline_dashboard = tmp_path / "baseline_dashboard.html"
+    space_dashboard = tmp_path / "space_dashboard.html"
+
+    baseline_path.write_text(
+        json.dumps(
+            {
+                "run": {"dashboard_path": str(baseline_dashboard)},
+                "summary": {"leaderboard_score": 0.1, "task_success_rate": 0.1},
+            }
+        ),
+        encoding="utf-8",
+    )
+    baseline_dashboard.write_text("<html>baseline</html>", encoding="utf-8")
+    evaluation_path.write_text(
+        json.dumps({"summary": {"leaderboard_score": 0.9, "task_success_rate": 0.9}, "episodes": []}),
+        encoding="utf-8",
+    )
+    space_dashboard.write_text("<html>space</html>", encoding="utf-8")
+
+    monkeypatch.setattr(server, "LATEST_BASELINE_OUTPUT", baseline_path)
+    monkeypatch.setattr(server, "LATEST_EVALUATION_OUTPUT", evaluation_path)
+    monkeypatch.setattr(server, "SPACE_DASHBOARD", space_dashboard)
+    monkeypatch.setattr(
+        server,
+        "_base_environment_snapshot",
+        lambda: {
+            "task_count": 30,
+            "difficulty_counts": {},
+            "action_space": ["CALL_TOOL", "ADD_EDGE", "ANSWER"],
+            "observation_space": {},
+            "task_types": [],
+            "config": {},
+        },
+    )
+    monkeypatch.setattr(server, "_build_environment", lambda: object())
+    monkeypatch.setattr(server, "export_dashboard", lambda env, evaluation, leaderboard_records, output_path: str(space_dashboard))
+
+    snapshot = server._space_snapshot()
+    assert snapshot["source"] == "latest_evaluation"
+    assert snapshot["summary"]["leaderboard_score"] == 0.9
+    assert snapshot["dashboard_path"] == str(space_dashboard)

tests/test_tools.py

@@ -1,5 +1,7 @@
+from osint_env.config import clone_environment_config, load_seeding_config, load_shared_config
 from osint_env.data.generator import DatasetGenerator
 from osint_env.domain.models import EnvironmentConfig
+from osint_env.env.environment import OSINTEnvironment
 from osint_env.platforms.tools import ToolRegistry
 
 
@@ -13,3 +15,25 @@ def test_tools_basics():
     profile_any = next(iter([p["user_id"] for p in views.profiles if p["user_id"].startswith("user_")]))
     profile = tools.get_profile(profile_any)
     assert profile["found"] is True
+
+
+def test_seeded_tools_expose_seed_question_entities():
+    shared = load_shared_config("datasets/fixed_levels/shared_config_fixed_levels.json")
+    env_cfg = clone_environment_config(shared.environment)
+    env_cfg.seeding = load_seeding_config("datasets/fixed_levels/seed_fixed_levels.json")
+    env_cfg.llm.provider = "mock"
+    env = OSINTEnvironment(env_cfg)
+    tools = env.tools
+
+    post = tools.get_post("post_midnight_manifest")
+    assert post["found"] is True
+    assert "loc_dockyard17" in post["result"]["references"]
+
+    people = tools.search_people(org="org_northbridge_logistics")
+    user_ids = {row["user_id"] for row in people["results"]}
+    assert "user_bharat" in user_ids
+    assert "user_hiro" in user_ids
+
+    alias_profile = tools.get_profile("alias_docksparrow")
+    assert alias_profile["found"] is True
+    assert alias_profile["result"]["user_id"] == "user_hiro"