@researai/deepscientist 1.5.1 → 1.5.2

package/src/deepscientist/config/service.py

@@ -1052,7 +1052,7 @@ Use **Test** when the file exposes runtime dependencies.
                 "warnings": [],
                 "errors": [
                     "Codex binary is not installed or could not be resolved.",
-                    "Install `@openai/codex` and ensure the `codex` CLI is available to DeepScientist.",
+                    "DeepScientist could not resolve the bundled or configured `codex` CLI.",
                 ],
                 "details": details,
                 "guidance": [

package/src/deepscientist/daemon/api/handlers.py

@@ -10,6 +10,7 @@ from urllib.parse import parse_qs, unquote
 
 from ...acp import OptionalACPBridge, build_session_descriptor, build_session_update, get_acp_bridge_status
 from ...bash_exec.service import DEFAULT_TERMINAL_SESSION_ID
+from ... import __version__ as DEEPSCIENTIST_VERSION
 from ...gitops import commit_detail, compare_refs, diff_file_between_refs, diff_file_for_commit, export_git_graph, list_branch_canvas, log_ref_history
 from ...memory import MemoryService
 from ...quest import QuestService
@@ -71,6 +72,7 @@ class ApiHandlers:
     def _inject_ui_runtime(self, payload: str) -> str:
         runtime_payload = {
             "surface": "quest",
+            "version": DEEPSCIENTIST_VERSION,
             "supports": {
                 "productApis": False,
                 "socketIo": False,
@@ -160,6 +162,13 @@ npm --prefix src/ui run build</pre>
             "sessions": self.app.sessions.snapshot(),
         }
 
+    def system_update(self) -> dict:
+        return self.app.system_update_status()
+
+    def system_update_action(self, body: dict) -> dict:
+        action = str(body.get("action") or "").strip().lower()
+        return self.app.request_system_update(action=action)
+
     def cli_health(self) -> dict:
         online_channels = [
             channel.status()
@@ -394,12 +403,20 @@ npm --prefix src/ui run build</pre>
     def quest_events(self, quest_id: str, path: str) -> dict:
         query = self.parse_query(path)
         after = int((query.get("after") or ["0"])[0] or "0")
+        before_raw = ((query.get("before") or [""])[0] or "").strip()
+        before = int(before_raw) if before_raw.isdigit() else None
         limit = int((query.get("limit") or ["200"])[0] or "200")
         tail_raw = ((query.get("tail") or ["0"])[0] or "0").strip().lower()
         tail = tail_raw in {"1", "true", "yes", "on"}
         format_name = ((query.get("format") or ["both"])[0] or "both").lower()
         session_id = ((query.get("session_id") or [f"quest:{quest_id}"])[0] or f"quest:{quest_id}")
-        payload = self._fresh_quest_service().events(quest_id, after=after, limit=limit, tail=tail)
+        payload = self._fresh_quest_service().events(
+            quest_id,
+            after=after,
+            before=before,
+            limit=limit,
+            tail=tail,
+        )
         if format_name in {"acp", "both"}:
             payload["acp_updates"] = [
                 build_session_update(

package/src/deepscientist/daemon/api/router.py

@@ -8,6 +8,8 @@ ROUTES: list[tuple[str, re.Pattern[str], str]] = [
     ("GET", re.compile(r"^/ui/(?P<ui_path>.+)$"), "ui_asset"),
     ("GET", re.compile(r"^/(?P<spa_path>(?!api(?:/|$)|ui(?:/|$)|assets(?:/|$)).+)$"), "spa_root"),
     ("GET", re.compile(r"^/api/health$"), "health"),
+    ("GET", re.compile(r"^/api/system/update$"), "system_update"),
+    ("POST", re.compile(r"^/api/system/update$"), "system_update_action"),
     ("GET", re.compile(r"^/api/v1/health/cli$"), "cli_health"),
     ("POST", re.compile(r"^/api/admin/shutdown$"), "admin_shutdown"),
     ("GET", re.compile(r"^/api/acp/status$"), "acp_status"),

package/src/deepscientist/daemon/app.py

@@ -5,6 +5,7 @@ import json
 import mimetypes
 import os
 import shutil
+import subprocess
 import threading
 import time
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
@@ -106,6 +107,8 @@ class DaemonApp:
         self._terminal_attach_thread: threading.Thread | None = None
         self._terminal_attach_host: str | None = None
         self._terminal_attach_port: int | None = None
+        self._serve_host: str | None = None
+        self._serve_port: int | None = None
         self._shutdown_requested = threading.Event()
         self._qq_gateway: QQGatewayService | None = None
         self._telegram_polling: TelegramPollingService | None = None
@@ -122,6 +125,88 @@ class DaemonApp:
             items.append(self.config_manager.lingzhu_snapshot(lingzhu_config))
         return items
 
+    def _launcher_update_base_command(self) -> list[str]:
+        node_binary = str(os.environ.get("DEEPSCIENTIST_NODE_BINARY") or "").strip() or which("node") or which("nodejs")
+        launcher_path = str(os.environ.get("DEEPSCIENTIST_LAUNCHER_PATH") or "").strip()
+        if not launcher_path:
+            launcher_path = str(self.repo_root / "bin" / "ds.js")
+        if not node_binary:
+            raise RuntimeError("Node.js is not available on PATH, so DeepScientist cannot check npm updates.")
+        if not Path(launcher_path).exists():
+            raise RuntimeError(f"DeepScientist launcher path does not exist: {launcher_path}")
+        return [node_binary, launcher_path, "update", "--home", str(self.home)]
+
+    def system_update_status(self) -> dict[str, object]:
+        command = [*self._launcher_update_base_command(), "--check", "--json"]
+        try:
+            result = subprocess.run(
+                command,
+                cwd=str(self.repo_root),
+                capture_output=True,
+                text=True,
+                timeout=8,
+                check=False,
+                env=os.environ.copy(),
+            )
+        except subprocess.TimeoutExpired as exc:
+            raise RuntimeError("DeepScientist update check timed out.") from exc
+        if result.returncode != 0:
+            raise RuntimeError((result.stderr or result.stdout or "Update check failed.").strip())
+        try:
+            payload = json.loads(result.stdout or "{}")
+        except json.JSONDecodeError as exc:
+            raise RuntimeError("DeepScientist update check returned invalid JSON.") from exc
+        if not isinstance(payload, dict):
+            raise RuntimeError("DeepScientist update check returned an invalid payload.")
+        return payload
+
+    def request_system_update(self, *, action: str) -> dict[str, object]:
+        normalized = str(action or "").strip().lower()
+        if normalized not in {"install_latest", "remind_later", "skip_version"}:
+            raise ValueError(f"Unsupported update action `{action}`.")
+        command = self._launcher_update_base_command()
+        if normalized == "install_latest":
+            host = self._serve_host or "0.0.0.0"
+            port = self._serve_port or 20999
+            command.extend(
+                [
+                    "--yes",
+                    "--background",
+                    "--restart-daemon",
+                    "--host",
+                    str(host),
+                    "--port",
+                    str(port),
+                    "--json",
+                ]
+            )
+        elif normalized == "remind_later":
+            command.extend(["--remind-later", "--json"])
+        else:
+            command.extend(["--skip-version", "--json"])
+
+        try:
+            result = subprocess.run(
+                command,
+                cwd=str(self.repo_root),
+                capture_output=True,
+                text=True,
+                timeout=8,
+                check=False,
+                env=os.environ.copy(),
+            )
+        except subprocess.TimeoutExpired as exc:
+            raise RuntimeError("DeepScientist update request timed out.") from exc
+        if result.returncode != 0:
+            raise RuntimeError((result.stderr or result.stdout or "Update request failed.").strip())
+        try:
+            payload = json.loads(result.stdout or "{}")
+        except json.JSONDecodeError as exc:
+            raise RuntimeError("DeepScientist update request returned invalid JSON.") from exc
+        if not isinstance(payload, dict):
+            raise RuntimeError("DeepScientist update request returned an invalid payload.")
+        return payload
+
     def _process_terminal_attach_request(
         self,
         connection: ServerConnection,
@@ -3667,7 +3752,7 @@ class DaemonApp:
                             headers=dict(self.headers.items()),
                             body=body,
                         )
-                    elif route_name in {"document_open", "document_asset_upload", "chat", "command", "quest_control", "config_save", "quest_create", "quest_baseline_binding", "run_create", "qq_inbound", "connector_inbound", "docs_open", "admin_shutdown", "bash_stop", "quest_settings", "quest_bindings", "quest_delete", "terminal_session_ensure", "terminal_attach", "terminal_input", "stage_view", "latex_init", "latex_compile"}:
+                    elif route_name in {"document_open", "document_asset_upload", "chat", "command", "quest_control", "config_save", "quest_create", "quest_baseline_binding", "run_create", "qq_inbound", "connector_inbound", "docs_open", "admin_shutdown", "bash_stop", "quest_settings", "quest_bindings", "quest_delete", "terminal_session_ensure", "terminal_attach", "terminal_input", "stage_view", "latex_init", "latex_compile", "system_update_action"}:
                         payload = result(**params, body=body)
                     elif route_name == "config_validate":
                         payload = result(body)
@@ -3711,6 +3796,8 @@ class DaemonApp:
         server = ThreadingHTTPServer((host, port), RequestHandler)
         server.daemon_threads = True
         self._server = server
+        self._serve_host = host
+        self._serve_port = port
         self._shutdown_requested.clear()
         self._start_terminal_attach_server(host, port)
         self._start_background_connectors()
@@ -3724,4 +3811,6 @@ class DaemonApp:
             self._stop_terminal_attach_server()
             self.bash_exec_service.shutdown()
             self._server = None
+            self._serve_host = None
+            self._serve_port = None
             server.server_close()

package/src/deepscientist/doctor.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
+import os
 import socket
+import subprocess
 import sys
 import tempfile
+from shutil import which
 from pathlib import Path
 from typing import Any
 from urllib.error import URLError
@@ -108,6 +111,69 @@ def _check_home_writable(home: Path) -> dict[str, Any]:
     )
 
 
+def _resolve_uv_binary(home: Path) -> str | None:
+    for env_name in ("DEEPSCIENTIST_UV", "UV_BIN"):
+        override = str(os.environ.get(env_name) or "").strip()
+        if not override:
+            continue
+        override_path = Path(override).expanduser()
+        if override_path.exists():
+            return str(override_path)
+        resolved_override = which(override)
+        if resolved_override:
+            return resolved_override
+
+    local_candidates = [
+        home / "runtime" / "tools" / "uv" / "bin" / "uv",
+        home / "runtime" / "tools" / "uv" / "bin" / "uv.exe",
+    ]
+    for candidate in local_candidates:
+        if candidate.exists():
+            return str(candidate)
+    return which("uv")
+
+
+def _check_uv(home: Path) -> dict[str, Any]:
+    resolved = _resolve_uv_binary(home)
+    if not resolved:
+        guidance = [
+            "Run `ds` once so DeepScientist can bootstrap a local uv runtime manager automatically.",
+        ]
+        if sys.platform == "win32":
+            guidance.append('PowerShell: `powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"`')
+        else:
+            guidance.append("macOS/Linux: `curl -LsSf https://astral.sh/uv/install.sh | sh`")
+        return _make_check(
+            check_id="uv",
+            label="uv runtime manager",
+            ok=False,
+            summary="uv is not available to DeepScientist.",
+            errors=["DeepScientist cannot provision or repair its local Python runtime without `uv`."],
+            guidance=guidance,
+        )
+
+    version = ""
+    try:
+        result = subprocess.run(
+            [resolved, "--version"],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            version = (result.stdout or result.stderr or "").strip()
+    except OSError:
+        version = ""
+
+    return _make_check(
+        check_id="uv",
+        label="uv runtime manager",
+        ok=True,
+        summary="uv is available for locked Python runtime management.",
+        details={"resolved_binary": resolved, "version": version or None},
+    )
+
+
 def _check_git(config_manager: ConfigManager) -> dict[str, Any]:
     readiness = config_manager.git_readiness()
     return _make_check(
@@ -195,10 +261,10 @@ def _check_codex(config_manager: ConfigManager) -> dict[str, Any]:
             check_id="codex",
             label="Codex CLI",
             ok=False,
-            summary="Codex CLI is not available on PATH.",
+            summary="Codex CLI is not available to DeepScientist.",
             errors=[f"Runner binary `{binary}` could not be resolved."],
             guidance=[
-                "Install Codex first: `npm install -g @openai/codex`.",
+                "Run `npm install -g @researai/deepscientist` again so the bundled Codex dependency is installed.",
                 "Then run `codex` once and complete login.",
             ],
             details={"binary": binary},
@@ -370,6 +436,7 @@ def run_doctor(home: Path, *, repo_root: Path) -> dict[str, Any]:
     checks = [
         _check_python_runtime(),
         _check_home_writable(home),
+        _check_uv(home),
         _check_git(config_manager),
         _check_config_validation(config_manager),
         _check_runner_support(config_manager),

package/src/deepscientist/gitops/diff.py

@@ -333,6 +333,9 @@ def _collect_branch_state(repo: Path) -> dict[str, dict[str, Any]]:
                 "baseline_ref": record.get("baseline_ref") or {},
                 "baseline_comparisons": record.get("baseline_comparisons") or {},
                 "progress_eval": record.get("progress_eval") or {},
+                "evaluation_summary": record.get("evaluation_summary")
+                or ((record.get("details") or {}) if isinstance(record.get("details"), dict) else {}).get("evaluation_summary")
+                or {},
                 "files_changed": record.get("files_changed") or [],
                 "evidence_paths": record.get("evidence_paths") or [],
                 "updated_at": record.get("updated_at"),

package/src/deepscientist/home.py

@@ -1,12 +1,34 @@
 from __future__ import annotations
 
+import os
 from pathlib import Path
 
 from .shared import ensure_dir
 
 
+def _looks_like_repo_root(path: Path) -> bool:
+    return (
+        (path / "pyproject.toml").exists()
+        and (path / "src" / "deepscientist").exists()
+        and (path / "src" / "skills").exists()
+    )
+
+
 def repo_root() -> Path:
-    return Path(__file__).resolve().parents[2]
+    configured = str(os.environ.get("DEEPSCIENTIST_REPO_ROOT") or "").strip()
+    if configured:
+        candidate = Path(configured).expanduser().resolve()
+        if _looks_like_repo_root(candidate):
+            return candidate
+
+    cwd = Path.cwd().resolve()
+    if _looks_like_repo_root(cwd):
+        return cwd
+
+    candidate = Path(__file__).resolve().parents[2]
+    if _looks_like_repo_root(candidate):
+        return candidate
+    return candidate
 
 
 def default_home() -> Path:
@@ -15,9 +37,10 @@ def default_home() -> Path:
 
 def ensure_home_layout(home: Path) -> dict[str, Path]:
     runtime = ensure_dir(home / "runtime")
-    ensure_dir(runtime / "venv")
     ensure_dir(runtime / "bundle")
     ensure_dir(runtime / "tools")
+    ensure_dir(runtime / "python")
+    ensure_dir(runtime / "uv-cache")
 
     config = ensure_dir(home / "config")
     ensure_dir(config / "baselines")

package/src/deepscientist/mcp/context.py

@@ -4,6 +4,8 @@ import os
 from dataclasses import dataclass
 from pathlib import Path
 
+from ..home import default_home
+
 
 @dataclass(frozen=True)
 class McpContext:
@@ -24,7 +26,7 @@ class McpContext:
             value = os.environ.get(name, "").strip()
             return Path(value).expanduser() if value else None
 
-        home = _path("DS_HOME") or (Path.home() / "DeepScientist")
+        home = _path("DEEPSCIENTIST_HOME") or _path("DS_HOME") or default_home()
         return cls(
             home=home,
             quest_id=os.environ.get("DS_QUEST_ID") or None,

package/src/deepscientist/mcp/server.py

@@ -307,6 +307,7 @@ def build_artifact_server(context: McpContext) -> FastMCP:
         status: str = "completed",
         baseline_id: str | None = None,
         baseline_variant_id: str | None = None,
+        evaluation_summary: dict[str, Any] | None = None,
         comment: str | dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         return service.record_main_experiment(
@@ -330,6 +331,7 @@ def build_artifact_server(context: McpContext) -> FastMCP:
             status=status,
             baseline_id=baseline_id,
             baseline_variant_id=baseline_variant_id,
+            evaluation_summary=evaluation_summary,
         )
 
     @server.tool(
@@ -462,6 +464,8 @@ def build_artifact_server(context: McpContext) -> FastMCP:
         next_recommendation: str | None = None,
         dataset_scope: str = "full",
         subset_approval_ref: str | None = None,
+        comparison_baselines: list[dict[str, Any]] | None = None,
+        evaluation_summary: dict[str, Any] | None = None,
         comment: str | dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         return service.record_analysis_slice(
@@ -481,6 +485,8 @@ def build_artifact_server(context: McpContext) -> FastMCP:
             next_recommendation=next_recommendation,
             dataset_scope=dataset_scope,
             subset_approval_ref=subset_approval_ref,
+            comparison_baselines=comparison_baselines,
+            evaluation_summary=evaluation_summary,
         )
 
     @server.tool(name="publish_baseline", description="Publish a quest baseline to the global baseline registry.")

package/src/deepscientist/prompts/builder.py

@@ -735,7 +735,10 @@ class PromptBuilder:
             "- acknowledgment_protocol: after artifact.interact returns any human message, immediately call artifact.interact(...) again to confirm receipt; if answerable, answer directly, otherwise state the short plan, nearest checkpoint, and that the current background subtask is paused",
             "- progress_protocol: emit artifact.interact(kind='progress', reply_mode='threaded', ...) only at real human-meaningful checkpoints, after the first meaningful signal from long-running work, and then only occasional keepalives during truly long work, usually about every 20 to 30 minutes",
             "- long_run_reporting_protocol: for long-running bash_exec monitoring loops, report after each completed sleep/await cycle with real evidence plus the next planned check time and estimated next reply time",
+            "- timeout_protocol: before using bash_exec(mode='await', ...), estimate whether the command can finish within the selected wait window; if runtime is uncertain or likely longer, use bash_exec(mode='detach', ...) and monitor, or set timeout_seconds intentionally",
             "- blocking_protocol: use reply_mode='blocking' only for true unresolved user decisions; ordinary progress updates should stay threaded and non-blocking",
+            "- credential_blocking_protocol: if continuation requires user-supplied external credentials or secrets such as an API key, GitHub key/token, or Hugging Face key/token, emit one structured blocking decision request that asks the user to provide the credential or choose an alternative route; do not invent placeholders or silently skip the blocked step",
+            "- credential_wait_protocol: if that credential request remains unanswered, keep the quest waiting rather than self-resolving; if you are resumed without new credentials and no other work is possible, a long low-frequency park such as `bash_exec(command='sleep 3600', mode='await', timeout_seconds=3700)` is acceptable to avoid busy-looping",
             f"- standby_prefix_rule: when you intentionally leave one blocking standby interaction after task completion, prefix it with {'[等待决策]' if chinese_turn else '[Waiting for decision]'} and wait for a new user reply before continuing",
             "- stop_notice_protocol: if work must pause or stop, send a user-visible notice that explains why, confirms preserved context, and states that any new message or `/resume` will continue from the same quest",
             "- respect_protocol: write user-facing updates as natural, respectful, easy-to-follow chat; do not sound like a formal status report or internal tool log",
@@ -913,6 +916,26 @@ class PromptBuilder:
                     "- active_baseline_metric_contract_rule: before planning or running `experiment` or `analysis-campaign`, read this JSON file and treat it as the canonical baseline comparison contract unless a newer confirmed baseline explicitly replaces it.",
                 ]
             )
+        analysis_baseline_inventory = read_json(quest_root / "artifacts" / "baselines" / "analysis_inventory.json", {})
+        analysis_baseline_inventory = analysis_baseline_inventory if isinstance(analysis_baseline_inventory, dict) else {}
+        analysis_inventory_entries = (
+            analysis_baseline_inventory.get("entries") if isinstance(analysis_baseline_inventory.get("entries"), list) else []
+        )
+        registered_count = sum(
+            1
+            for item in analysis_inventory_entries
+            if isinstance(item, dict) and str(item.get("status") or "").strip().lower() == "registered"
+        )
+        if analysis_inventory_entries:
+            lines.extend(
+                [
+                    f"- supplementary_baseline_inventory_status: artifacts/baselines/analysis_inventory.json [exists]",
+                    f"- supplementary_baseline_count: {len(analysis_inventory_entries)}",
+                    f"- supplementary_baseline_registered_count: {registered_count}",
+                ]
+            )
+        else:
+            lines.append("- supplementary_baseline_inventory_status: artifacts/baselines/analysis_inventory.json [missing]")
         lines.extend(["", "Active interactions:"])
         active_interactions = snapshot.get("active_interactions") or []
         if active_interactions:
@@ -1001,10 +1024,14 @@ class PromptBuilder:
         )
         bundle_manifest = read_json(paper_root / "paper_bundle_manifest.json", {})
         bundle_manifest = bundle_manifest if isinstance(bundle_manifest, dict) else {}
+        paper_baseline_inventory = read_json(paper_root / "baseline_inventory.json", {})
+        paper_baseline_inventory = paper_baseline_inventory if isinstance(paper_baseline_inventory, dict) else {}
         claim_evidence_map = read_json(paper_root / "claim_evidence_map.json", {})
         claim_evidence_map = claim_evidence_map if isinstance(claim_evidence_map, dict) else {}
         compile_report = read_json(paper_root / "build" / "compile_report.json", {})
         compile_report = compile_report if isinstance(compile_report, dict) else {}
+        open_source_manifest = read_json(quest_root / "release" / "open_source" / "manifest.json", {})
+        open_source_manifest = open_source_manifest if isinstance(open_source_manifest, dict) else {}
 
         selected_outline_ref = str(
             selected_outline.get("outline_id") or bundle_manifest.get("selected_outline_ref") or ""
@@ -1045,6 +1072,7 @@ class PromptBuilder:
                 f"- draft_status: {_path_status(bundle_manifest.get('draft_path'), fallback='paper/draft.md')}",
                 f"- references_status: {_path_status(bundle_manifest.get('references_path'), fallback='paper/references.bib')}",
                 f"- claim_evidence_map_status: {_path_status(bundle_manifest.get('claim_evidence_map_path'), fallback='paper/claim_evidence_map.json')}",
+                f"- baseline_inventory_status: {_path_status(bundle_manifest.get('baseline_inventory_path'), fallback='paper/baseline_inventory.json')}",
                 f"- review_status: {'paper/review/review.md [exists]' if (paper_root / 'review' / 'review.md').exists() else 'paper/review/review.md [missing]'}",
                 f"- proofing_report_status: {'paper/proofing/proofing_report.md [exists]' if (paper_root / 'proofing' / 'proofing_report.md').exists() else 'paper/proofing/proofing_report.md [missing]'}",
                 f"- page_images_manifest_status: {'paper/proofing/page_images_manifest.json [exists]' if (paper_root / 'proofing' / 'page_images_manifest.json').exists() else 'paper/proofing/page_images_manifest.json [missing]'}",
@@ -1061,6 +1089,8 @@ class PromptBuilder:
                     f"- bundle_pdf_status: {_path_status(pdf_rel_path, fallback='paper/paper.pdf')}",
                     f"- bundle_compile_report_status: {_path_status(compile_rel_path, fallback='paper/build/compile_report.json')}",
                     f"- bundle_latex_root: {latex_root_path or 'none'}",
+                    f"- open_source_manifest_status: {_path_status(bundle_manifest.get('open_source_manifest_path'), fallback='release/open_source/manifest.json')}",
+                    f"- open_source_cleanup_plan_status: {_path_status(bundle_manifest.get('open_source_cleanup_plan_path'), fallback='release/open_source/cleanup_plan.md')}",
                 ]
             )
         else:
@@ -1089,6 +1119,17 @@ class PromptBuilder:
 
         if compile_report:
             lines.append(f"- compile_report_ok: {compile_report.get('ok') if 'ok' in compile_report else 'unknown'}")
+        supplementary_baselines = (
+            paper_baseline_inventory.get("supplementary_baselines")
+            if isinstance(paper_baseline_inventory.get("supplementary_baselines"), list)
+            else []
+        )
+        if paper_baseline_inventory:
+            lines.append(f"- paper_supplementary_baseline_count: {len(supplementary_baselines)}")
+        if open_source_manifest:
+            lines.append(
+                f"- open_source_release_branch: {str(open_source_manifest.get('release_branch') or '').strip() or 'none'}"
+            )
 
         lines.extend(["", "Recent supporting runs:"])
         recent_runs = snapshot.get("recent_runs") or []

package/src/deepscientist/quest/layout.py

@@ -29,6 +29,7 @@ QUEST_DIRECTORIES = (
     "memory/knowledge",
     "memory/papers",
     "paper",
+    "release/open_source",
     ".codex/skills",
     ".claude/agents",
     ".ds/bash_exec",

package/src/deepscientist/quest/service.py

@@ -1548,11 +1548,16 @@ class QuestService:
             if normalized in seen_files:
                 return
             seen_files.add(normalized)
+            resolved_document_id = document_id or self._path_to_document_id(
+                normalized,
+                quest_root=quest_root,
+                workspace_root=workspace_root,
+            )
             changed_files.append(
                 {
                     "path": normalized,
                     "source": source,
-                    "document_id": document_id,
+                    "document_id": resolved_document_id,
                     "writable": writable,
                 }
             )
@@ -1621,14 +1626,30 @@ class QuestService:
             "changed_files": changed_files[-30:],
         }
 
-    def events(self, quest_id: str, *, after: int = 0, limit: int = 200, tail: bool = False) -> dict:
+    def events(
+        self,
+        quest_id: str,
+        *,
+        after: int = 0,
+        before: int | None = None,
+        limit: int = 200,
+        tail: bool = False,
+    ) -> dict:
         records = self._read_cached_jsonl(self._quest_root(quest_id) / ".ds" / "events.jsonl")
         normalized_limit = max(limit, 0)
-        if tail and normalized_limit > 0:
+        direction = "after"
+        if before is not None:
+            direction = "before"
+            end = max(int(before) - 1, 0)
+            start = max(end - normalized_limit, 0)
+            sliced = records[start:end]
+        elif tail and normalized_limit > 0:
+            direction = "tail"
             start = max(len(records) - normalized_limit, 0)
+            sliced = records[start : start + normalized_limit]
         else:
             start = max(after, 0)
-        sliced = records[start : start + normalized_limit]
+            sliced = records[start : start + normalized_limit]
         enriched = []
         for index, item in enumerate(sliced, start=start + 1):
             enriched.append(
@@ -1638,11 +1659,23 @@ class QuestService:
                     **item,
                 }
             )
-        next_cursor = len(records) if tail else start + len(sliced)
+        if before is not None:
+            next_cursor = start + len(sliced)
+        else:
+            next_cursor = len(records) if tail else start + len(sliced)
+        oldest_cursor = enriched[0]["cursor"] if enriched else None
+        newest_cursor = enriched[-1]["cursor"] if enriched else None
+        if before is not None:
+            has_more = start > 0
+        else:
+            has_more = start > 0 if tail else next_cursor < len(records)
         return {
             "quest_id": quest_id,
             "cursor": next_cursor,
-            "has_more": start > 0 if tail else next_cursor < len(records),
+            "has_more": has_more,
+            "oldest_cursor": oldest_cursor,
+            "newest_cursor": newest_cursor,
+            "direction": direction,
             "events": enriched,
         }
 
@@ -1790,18 +1823,13 @@ class QuestService:
 
         quest_root = self._quest_root(quest_id)
         workspace_root = self.active_workspace_root(quest_root)
-        changed_paths = {
-            item["path"]: item
-            for item in self.workflow(quest_id).get("changed_files", [])
-            if item.get("path")
-        }
         git_status = self._git_status_map(workspace_root)
 
         root_nodes = self._tree_children(
             workspace_root,
             workspace_root,
             git_status=git_status,
-            changed_paths=changed_paths,
+            changed_paths={},
             profile=profile,
         )
         sections = self._group_explorer_sections(root_nodes)
@@ -2036,6 +2064,36 @@ class QuestService:
             return None, None
         return document_id, None
 
+    @staticmethod
+    def _path_to_document_id(
+        path: str | Path | None,
+        *,
+        quest_root: Path,
+        workspace_root: Path,
+    ) -> str | None:
+        if not path:
+            return None
+        try:
+            candidate = Path(path).expanduser()
+            if not candidate.is_absolute():
+                candidate = (workspace_root / candidate).resolve()
+            else:
+                candidate = candidate.resolve()
+        except OSError:
+            return None
+
+        try:
+            relative_to_workspace = candidate.relative_to(workspace_root.resolve()).as_posix()
+            return f"path::{relative_to_workspace}"
+        except ValueError:
+            pass
+
+        try:
+            relative_to_quest = candidate.relative_to(quest_root.resolve()).as_posix()
+            return f"questpath::{relative_to_quest}"
+        except ValueError:
+            return None
+
     @staticmethod
     def _markdown_asset_directory(relative_path: str) -> PurePosixPath:
         base_path = PurePosixPath(relative_path)