@researai/deepscientist 1.5.14 → 1.5.16

package/src/deepscientist/config/service.py

@@ -4,13 +4,17 @@ import json
 import os
 import subprocess
 import tempfile
-from shutil import copy2
 from copy import deepcopy
 from pathlib import Path
 from urllib.error import URLError
 from urllib.request import Request
 
-from ..codex_cli_compat import adapt_profile_only_provider_config, normalize_codex_reasoning_effort
+from ..codex_cli_compat import (
+    adapt_profile_only_provider_config,
+    materialize_codex_runtime_home,
+    normalize_codex_reasoning_effort,
+    provider_profile_metadata_from_home,
+)
 from ..connector.connector_profiles import PROFILEABLE_CONNECTOR_NAMES, list_connector_profiles, normalize_connector_config
 from ..connector_runtime import build_discovered_target, infer_connector_transport
 from ..home import repo_root
@@ -48,6 +52,7 @@ from .models import (
     ConfigFileInfo,
     SYSTEM_CONNECTOR_NAMES,
     config_filename,
+    default_system_enabled_connectors,
     default_payload,
 )
 
@@ -112,8 +117,9 @@ class ConfigManager:
         config = self.load_runtime_config()
         connectors = config.get("connectors") if isinstance(config.get("connectors"), dict) else {}
         system_enabled = connectors.get("system_enabled") if isinstance(connectors.get("system_enabled"), dict) else {}
+        defaults = default_system_enabled_connectors()
         return {
-            name: self._coerce_bool(system_enabled.get(name), default=name in {"qq", "weixin"})
+            name: self._coerce_bool(system_enabled.get(name), default=defaults.get(name, False))
             for name in SYSTEM_CONNECTOR_NAMES
         }
 
@@ -1190,6 +1196,14 @@ Use **Test** when the file exposes runtime dependencies.
             return "gpt-5.4"
         return str(raw_model).strip()
 
+    @staticmethod
+    def _codex_effective_model(config: dict) -> str:
+        requested = ConfigManager._codex_requested_model(config)
+        profile = ConfigManager._codex_profile_name(config)
+        if profile and not ConfigManager._codex_should_inherit_model(requested):
+            return "inherit"
+        return requested
+
     @staticmethod
     def _codex_profile_name(config: dict) -> str:
         raw_profile = config.get("profile")
@@ -1207,7 +1221,10 @@ Use **Test** when the file exposes runtime dependencies.
             env_key = str(key or "").strip()
             if not env_key or value is None:
                 continue
-            resolved[env_key] = str(value)
+            env_value = str(value)
+            if env_value == "":
+                continue
+            resolved[env_key] = env_value
         return resolved
 
     def _prepare_codex_probe_home(
@@ -1228,10 +1245,11 @@ Use **Test** when the file exposes runtime dependencies.
 
         temp_home = tempfile.TemporaryDirectory(prefix="ds-codex-probe-")
         temp_root = Path(temp_home.name)
-        for filename in ("auth.json",):
-            source_path = expanded / filename
-            if source_path.exists():
-                copy2(source_path, temp_root / filename)
+        materialize_codex_runtime_home(
+            source_home=expanded,
+            target_home=temp_root,
+            profile=profile,
+        )
         write_text(temp_root / "config.toml", adapted_text)
         return str(temp_root), warning, temp_home
 
@@ -1356,6 +1374,7 @@ Use **Test** when the file exposes runtime dependencies.
         resolved_binary = resolve_runner_binary(binary, runner_name="codex")
         profile = self._codex_profile_name(config)
         requested_model = self._codex_requested_model(config)
+        effective_model = self._codex_effective_model(config)
         raw_reasoning_effort = config.get("model_reasoning_effort")
         requested_reasoning_effort = (
             str(raw_reasoning_effort).strip()
@@ -1371,9 +1390,9 @@ Use **Test** when the file exposes runtime dependencies.
             "resolved_binary": resolved_binary,
             "config_dir": str(config.get("config_dir") or "~/.codex"),
             "profile": profile,
-            "model": requested_model or "inherit",
+            "model": effective_model or "inherit",
             "requested_model": requested_model or "inherit",
-            "effective_model": requested_model or "inherit",
+            "effective_model": effective_model or "inherit",
             "approval_policy": str(config.get("approval_policy") or "on-request"),
             "sandbox_mode": str(config.get("sandbox_mode") or "workspace-write"),
             "reasoning_effort": reasoning_effort,
@@ -1411,9 +1430,17 @@ Use **Test** when the file exposes runtime dependencies.
             env["CODEX_HOME"] = prepared_home
             if profile_config_warning:
                 compatibility_warnings.append(profile_config_warning)
+        metadata = provider_profile_metadata_from_home(env.get("CODEX_HOME") or config_dir, profile=profile)
+        if metadata.get("requires_openai_auth") is False:
+            env.pop("OPENAI_API_KEY", None)
+            env.pop("OPENAI_BASE_URL", None)
         prompt = "Reply with exactly HELLO."
         if reasoning_effort_warning:
             compatibility_warnings.append(reasoning_effort_warning)
+        if profile and effective_model == "inherit" and not self._codex_should_inherit_model(requested_model):
+            compatibility_warnings.append(
+                f"Codex profile `{profile}` is provider-backed. DeepScientist is probing it with `model: inherit`."
+            )
         base_warnings: list[str] = list(compatibility_warnings)
 
         def run_probe_once(model_for_command: str) -> tuple[list[str], subprocess.CompletedProcess[str] | None, subprocess.TimeoutExpired | None]:
@@ -1440,7 +1467,7 @@ Use **Test** when the file exposes runtime dependencies.
                 return command, None, exc
             return command, result, None
 
-        command, result, timeout_error = run_probe_once(requested_model)
+        command, result, timeout_error = run_probe_once(effective_model)
         if timeout_error is not None:
             details.update(
                 {

package/src/deepscientist/connector/weixin_support.py

@@ -13,7 +13,7 @@ from urllib.request import Request
 
 from .. import __version__ as DEEPSCIENTIST_VERSION
 from ..network import urlopen_with_proxy as urlopen
-from ..shared import ensure_dir, read_json, write_json
+from ..shared import ensure_dir, read_json, utc_now, write_json
 
 DEFAULT_WEIXIN_BASE_URL = "https://ilinkai.weixin.qq.com"
 DEFAULT_WEIXIN_CDN_BASE_URL = "https://novac2c.cdn.weixin.qq.com/c2c"
@@ -611,6 +611,22 @@ def save_weixin_context_tokens(root: Path, items: dict[str, dict[str, Any]]) ->
     write_json(weixin_context_tokens_path(root), {"tokens": items})
 
 
+def _weixin_replay_cursor(value: Any) -> int:
+    try:
+        return max(0, int(value or 0))
+    except (TypeError, ValueError):
+        return 0
+
+
+def get_weixin_context_entry(root: Path, user_id: str) -> dict[str, Any]:
+    normalized_user_id = str(user_id or "").strip()
+    if not normalized_user_id:
+        return {}
+    items = load_weixin_context_tokens(root)
+    current = items.get(normalized_user_id)
+    return dict(current) if isinstance(current, dict) else {}
+
+
 def remember_weixin_context_token(
     root: Path,
     *,
@@ -635,6 +651,16 @@ def remember_weixin_context_token(
         "conversation_id": str(conversation_id or current.get("conversation_id") or "").strip() or None,
         "message_id": str(message_id or current.get("message_id") or "").strip() or None,
         "updated_at": str(updated_at or current.get("updated_at") or "").strip() or None,
+        "stale_context": False,
+        "stale_since": None,
+        "last_ret_minus_2_at": None,
+        "last_outbound_error": None,
+        "last_outbound_kind": None,
+        "queued_replay_cursor": _weixin_replay_cursor(current.get("queued_replay_cursor")),
+        "last_replay_at": str(current.get("last_replay_at") or "").strip() or None,
+        "last_replay_trigger_message_id": str(current.get("last_replay_trigger_message_id") or "").strip() or None,
+        "last_replayed_count": _weixin_replay_cursor(current.get("last_replayed_count")) or None,
+        "last_replay_dropped_count": _weixin_replay_cursor(current.get("last_replay_dropped_count")) or None,
     }
     save_weixin_context_tokens(root, items)
 
@@ -648,6 +674,101 @@ def get_weixin_context_token(root: Path, user_id: str) -> str | None:
     return token or None
 
 
+def get_weixin_replay_cursor(root: Path, user_id: str) -> int:
+    entry = get_weixin_context_entry(root, user_id)
+    return _weixin_replay_cursor(entry.get("queued_replay_cursor"))
+
+
+def update_weixin_replay_cursor(
+    root: Path,
+    *,
+    user_id: str,
+    queued_replay_cursor: int,
+    last_replay_at: str | None = None,
+    last_replay_trigger_message_id: str | None = None,
+    last_replayed_count: int | None = None,
+    last_replay_dropped_count: int | None = None,
+) -> dict[str, Any]:
+    normalized_user_id = str(user_id or "").strip()
+    if not normalized_user_id:
+        return {}
+    items = load_weixin_context_tokens(root)
+    current = dict(items.get(normalized_user_id) or {})
+    current.update(
+        {
+            "user_id": normalized_user_id,
+            "queued_replay_cursor": _weixin_replay_cursor(queued_replay_cursor),
+            "last_replay_at": str(last_replay_at or utc_now()).strip() or utc_now(),
+            "last_replay_trigger_message_id": str(last_replay_trigger_message_id or "").strip() or None,
+            "last_replayed_count": _weixin_replay_cursor(last_replayed_count) if last_replayed_count is not None else None,
+            "last_replay_dropped_count": _weixin_replay_cursor(last_replay_dropped_count)
+            if last_replay_dropped_count is not None
+            else None,
+        }
+    )
+    items[normalized_user_id] = current
+    save_weixin_context_tokens(root, items)
+    return current
+
+
+def mark_weixin_context_stale(
+    root: Path,
+    *,
+    user_id: str,
+    error: str,
+    kind: str | None = None,
+    updated_at: str | None = None,
+) -> dict[str, Any]:
+    normalized_user_id = str(user_id or "").strip()
+    if not normalized_user_id:
+        return {}
+    timestamp = str(updated_at or utc_now()).strip() or utc_now()
+    items = load_weixin_context_tokens(root)
+    current = dict(items.get(normalized_user_id) or {})
+    current.update(
+        {
+            "user_id": normalized_user_id,
+            "stale_context": True,
+            "stale_since": str(current.get("stale_since") or "").strip() or timestamp,
+            "last_ret_minus_2_at": timestamp,
+            "last_outbound_error": str(error or "").strip() or None,
+            "last_outbound_kind": str(kind or "").strip() or None,
+        }
+    )
+    items[normalized_user_id] = current
+    save_weixin_context_tokens(root, items)
+    return current
+
+
+def clear_weixin_context_send_state(
+    root: Path,
+    *,
+    user_id: str,
+    kind: str | None = None,
+    updated_at: str | None = None,
+) -> dict[str, Any]:
+    normalized_user_id = str(user_id or "").strip()
+    if not normalized_user_id:
+        return {}
+    timestamp = str(updated_at or utc_now()).strip() or utc_now()
+    items = load_weixin_context_tokens(root)
+    current = dict(items.get(normalized_user_id) or {})
+    current.update(
+        {
+            "user_id": normalized_user_id,
+            "stale_context": False,
+            "stale_since": None,
+            "last_ret_minus_2_at": None,
+            "last_outbound_error": None,
+            "last_outbound_kind": str(kind or "").strip() or None,
+            "last_success_at": timestamp,
+        }
+    )
+    items[normalized_user_id] = current
+    save_weixin_context_tokens(root, items)
+    return current
+
+
 def weixin_sync_state_path(root: Path) -> Path:
     return ensure_dir(root) / "sync_state.json"
 

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

@@ -11,12 +11,17 @@ 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 ...gitops import commit_detail, compare_refs, diff_file_between_refs, diff_file_for_commit, export_git_graph, log_ref_history
 from ...memory import MemoryService
 from ...quest import QuestService
 from ...shared import generate_id, read_json, read_text, resolve_within, run_command, sha256_text, utc_now
 from ...runners import RunRequest
 
+_COPILOT_LEAD_MESSAGE = (
+    "我是 DeepScientist，任何事情都可以找我帮忙。"
+    "你可以让我读论文、改代码、看实验、整理思路，或者直接开始执行一个任务。"
+)
+
 
 class ApiHandlers:
     def __init__(self, app: "DaemonApp") -> None:
@@ -73,6 +78,8 @@ class ApiHandlers:
         runtime_payload = {
             "surface": "quest",
             "version": DEEPSCIENTIST_VERSION,
+            "homePath": str(self.app.home),
+            "auth": self.app.browser_auth_runtime_payload(),
             "supports": {
                 "productApis": False,
                 "socketIo": False,
@@ -158,9 +165,87 @@ npm --prefix src/ui run build</pre>
             "daemon_id": self.app.daemon_id,
             "managed_by": self.app.daemon_managed_by,
             "pid": os.getpid(),
+            "auth_enabled": self.app.browser_auth_enabled,
             "sessions": self.app.sessions.snapshot(),
         }
 
+    def auth_login(self, body: dict | None = None) -> tuple[int, dict, str] | tuple[int, dict]:
+        if not self.app.browser_auth_enabled:
+            payload = {
+                "ok": True,
+                "authenticated": True,
+                "auth_enabled": False,
+            }
+            return 200, {"Content-Type": "application/json; charset=utf-8"}, json.dumps(payload, ensure_ascii=False)
+
+        candidate = str(((body or {}) if isinstance(body, dict) else {}).get("token") or "").strip()
+        if not candidate:
+            return 400, {
+                "ok": False,
+                "message": "Token is required.",
+                "auth_required": True,
+                "auth_enabled": True,
+            }
+        if not self.app.browser_auth_matches(candidate):
+            return 401, {
+                "ok": False,
+                "message": "Invalid token.",
+                "auth_required": True,
+                "auth_enabled": True,
+            }
+        payload = {
+            "ok": True,
+            "authenticated": True,
+            "auth_enabled": True,
+            "token_masked": self.app.masked_browser_auth_token(),
+        }
+        return (
+            200,
+            {
+                "Content-Type": "application/json; charset=utf-8",
+                "Cache-Control": "no-store, max-age=0, must-revalidate",
+                "Set-Cookie": self.app._browser_auth_cookie_header(candidate),
+            },
+            json.dumps(payload, ensure_ascii=False),
+        )
+
+    def auth_token(self) -> dict:
+        return {
+            "ok": True,
+            "auth_enabled": self.app.browser_auth_enabled,
+            "token": self.app.browser_auth_token,
+            "token_masked": self.app.masked_browser_auth_token(),
+        }
+
+    def auth_rotate(self, body: dict | None = None) -> tuple[int, dict, str] | tuple[int, dict]:
+        if not self.app.browser_auth_enabled:
+            payload = {
+                "ok": True,
+                "auth_enabled": False,
+                "rotated": False,
+                "token": None,
+                "token_masked": None,
+            }
+            return 200, {"Content-Type": "application/json; charset=utf-8"}, json.dumps(payload, ensure_ascii=False)
+
+        rotated = self.app.rotate_browser_auth_token()
+        payload = {
+            "ok": True,
+            "auth_enabled": True,
+            "rotated": True,
+            "token": rotated,
+            "token_masked": self.app.masked_browser_auth_token(),
+        }
+        return (
+            200,
+            {
+                "Content-Type": "application/json; charset=utf-8",
+                "Cache-Control": "no-store, max-age=0, must-revalidate",
+                "Set-Cookie": self.app._browser_auth_cookie_header(rotated),
+            },
+            json.dumps(payload, ensure_ascii=False),
+        )
+
     def system_update(self) -> dict:
         return self.app.system_update_status()
 
@@ -324,6 +409,33 @@ npm --prefix src/ui run build</pre>
             return 400, {"ok": False, "message": str(exc)}
         except RuntimeError as exc:
             return 409, {"ok": False, "message": str(exc)}
+        workspace_mode = (
+            str(startup_contract.get("workspace_mode") or "").strip().lower()
+            if isinstance(startup_contract, dict)
+            else ""
+        )
+        if workspace_mode in {"copilot", "autonomous"}:
+            quest_root = self.app.quest_service._quest_root(snapshot["quest_id"])
+            self.app.quest_service.update_research_state(quest_root, workspace_mode=workspace_mode)
+            if workspace_mode == "copilot":
+                self.app.quest_service.append_message(
+                    snapshot["quest_id"],
+                    "assistant",
+                    _COPILOT_LEAD_MESSAGE,
+                    source="deepscientist",
+                )
+                self.app.quest_service.update_runtime_state(
+                    quest_root=quest_root,
+                    status="idle",
+                    display_status="idle",
+                )
+                self.app.quest_service.set_continuation_state(
+                    quest_root,
+                    policy="wait_for_user_or_resume",
+                    anchor="decision",
+                    reason="copilot_mode",
+                )
+            snapshot = self.app.quest_service.snapshot(snapshot["quest_id"])
         payload: dict[str, object] = {"ok": True, "snapshot": snapshot}
         if auto_start:
             startup = self.app.submit_user_message(
@@ -474,6 +586,12 @@ npm --prefix src/ui run build</pre>
 
     def quest_session(self, quest_id: str) -> dict:
         snapshot = self.app.quest_service.snapshot_fast(quest_id)
+        for kind in ("details", "canvas", "git_canvas"):
+            try:
+                self.app.quest_service.prime_projection(quest_id, kind)
+            except Exception:
+                continue
+        self.app.schedule_latest_quest_terminal_prewarm(quest_id)
         return {
             "ok": True,
             "quest_id": quest_id,
@@ -491,7 +609,7 @@ npm --prefix src/ui run build</pre>
         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(
+        payload = self.app.quest_service.events(
             quest_id,
             after=after,
             before=before,
@@ -768,7 +886,20 @@ npm --prefix src/ui run build</pre>
         return self.app.control_quest(quest_id, action=action, source=source)
 
     def workflow(self, quest_id: str) -> dict:
-        return self.app.quest_service.workflow(quest_id)
+        payload = self.app.quest_service.workflow(quest_id)
+        projection_state = str(((payload or {}).get("projection_status") or {}).get("state") or "").strip().lower()
+        if projection_state and projection_state != "ready":
+            if isinstance(payload, dict):
+                payload["optimization_frontier"] = None
+            return payload
+        quest_root = self._fresh_quest_service()._quest_root(quest_id)
+        try:
+            frontier = self.app.artifact_service.get_optimization_frontier(quest_root)
+        except Exception:
+            frontier = {"ok": False}
+        if isinstance(payload, dict):
+            payload["optimization_frontier"] = frontier.get("optimization_frontier") if isinstance(frontier, dict) else None
+        return payload
 
     def quest_layout(self, quest_id: str) -> dict:
         quest_root = self._fresh_quest_service()._quest_root(quest_id)
@@ -816,15 +947,21 @@ npm --prefix src/ui run build</pre>
     def metrics_timeline(self, quest_id: str) -> dict:
         return self.app.quest_service.metrics_timeline(quest_id)
 
+    def baseline_compare(self, quest_id: str) -> dict:
+        return self.app.quest_service.baseline_compare(quest_id)
+
     def git_branches(self, quest_id: str) -> dict:
         quest_root = self._fresh_quest_service()._quest_root(quest_id)
-        payload = list_branch_canvas(quest_root, quest_id=quest_id)
+        payload = self.app.quest_service.git_branch_canvas(quest_id)
         research_state = self.app.quest_service.read_research_state(quest_root)
         active_workspace_branch = str(research_state.get("current_workspace_branch") or "").strip() or None
         research_head_branch = str(research_state.get("research_head_branch") or "").strip() or None
         payload["active_workspace_ref"] = active_workspace_branch
         payload["research_head_ref"] = research_head_branch
         payload["workspace_mode"] = str(research_state.get("workspace_mode") or "quest").strip() or "quest"
+        projection_state = str(((payload or {}).get("projection_status") or {}).get("state") or "").strip().lower()
+        if projection_state and projection_state != "ready" and not (payload.get("nodes") or []):
+            return payload
         quest_data = self.app.quest_service.read_quest_yaml(quest_root)
         active_anchor = str(quest_data.get("active_anchor") or "").strip().lower()
         active_analysis_campaign_id = str(research_state.get("active_analysis_campaign_id") or "").strip() or None
@@ -837,11 +974,40 @@ npm --prefix src/ui run build</pre>
             branch_summary = self.app.artifact_service.list_research_branches(quest_root)
         except Exception:
             branch_summary = {"branches": []}
+        try:
+            optimization_frontier = self.app.artifact_service.get_optimization_frontier(quest_root)
+        except Exception:
+            optimization_frontier = {"ok": False}
         branch_summary_by_name = {
             str(item.get("branch_name") or "").strip(): item
             for item in (branch_summary.get("branches") or [])
             if str(item.get("branch_name") or "").strip()
         }
+        frontier_payload = (
+            dict(optimization_frontier.get("optimization_frontier") or {})
+            if isinstance(optimization_frontier, dict)
+            and isinstance(optimization_frontier.get("optimization_frontier"), dict)
+            else {}
+        )
+        best_branch_name = str(((frontier_payload.get("best_branch") or {}) if isinstance(frontier_payload.get("best_branch"), dict) else {}).get("branch_name") or "").strip() or None
+        stagnant_branch_names = {
+            str(item.get("branch_name") or "").strip()
+            for item in (frontier_payload.get("stagnant_branches") or [])
+            if isinstance(item, dict) and str(item.get("branch_name") or "").strip()
+        }
+        fusion_candidate_names = {
+            str(item.get("branch_name") or "").strip()
+            for item in (frontier_payload.get("fusion_candidates") or [])
+            if isinstance(item, dict) and str(item.get("branch_name") or "").strip()
+        }
+        candidate_count_by_branch: dict[str, int] = {}
+        for item in frontier_payload.get("implementation_candidates") or []:
+            if not isinstance(item, dict):
+                continue
+            branch_name = str(item.get("branch") or "").strip()
+            if not branch_name:
+                continue
+            candidate_count_by_branch[branch_name] = candidate_count_by_branch.get(branch_name, 0) + 1
         active_campaign = {}
         if active_analysis_campaign_id:
             try:
@@ -856,6 +1022,11 @@ npm --prefix src/ui run build</pre>
             if isinstance(active_campaign, dict)
             else None
         )
+        campaign_paper_line_branch = (
+            str(active_campaign.get("paper_line_branch") or "").strip() or None
+            if isinstance(active_campaign, dict)
+            else None
+        )
         campaign_slices = [
             dict(item)
             for item in ((active_campaign or {}).get("slices") or [])
@@ -903,6 +1074,14 @@ npm --prefix src/ui run build</pre>
                     workflow_state["status_reason"] = "Analysis slice pending."
                 return workflow_state
             if branch_kind == "paper":
+                if campaign_paper_line_branch and ref == campaign_paper_line_branch and next_pending_slice_id is not None:
+                    workflow_state["analysis_state"] = "active"
+                    workflow_state["writing_state"] = "blocked_by_analysis"
+                    workflow_state["status_reason"] = (
+                        f"Analysis {campaign_completed_slices}/{campaign_total_slices} done"
+                        + (f" · next: {next_pending_slice_id}" if next_pending_slice_id else "")
+                    )
+                    return workflow_state
                 if ref == current_workspace_branch and workspace_mode == "paper":
                     workflow_state["writing_state"] = "completed" if active_anchor == "finalize" else "active"
                     workflow_state["status_reason"] = (
@@ -912,7 +1091,7 @@ npm --prefix src/ui run build</pre>
                     workflow_state["writing_state"] = "ready"
                     workflow_state["status_reason"] = "Writing workspace prepared."
                 return workflow_state
-            if campaign_parent_branch and ref == campaign_parent_branch:
+            if campaign_parent_branch and not campaign_paper_line_branch and ref == campaign_parent_branch:
                 workflow_state["analysis_state"] = "completed" if next_pending_slice_id is None else "active"
                 if has_main_result:
                     workflow_state["writing_state"] = "ready" if next_pending_slice_id is None else "blocked_by_analysis"
@@ -955,6 +1134,20 @@ npm --prefix src/ui run build</pre>
             node["latest_main_experiment"] = summary.get("latest_main_experiment")
             node["experiment_count"] = summary.get("experiment_count")
             node["has_main_result"] = summary.get("has_main_result")
+            node["optimization_mode"] = frontier_payload.get("mode")
+            node["optimization_best"] = ref == best_branch_name
+            node["optimization_stagnant"] = ref in stagnant_branch_names
+            node["optimization_fusion_candidate"] = ref in fusion_candidate_names
+            node["optimization_candidate_count"] = candidate_count_by_branch.get(ref, 0)
+        return payload
+
+    def git_canvas(self, quest_id: str) -> dict:
+        quest_root = self._fresh_quest_service()._quest_root(quest_id)
+        payload = self.app.quest_service.git_commit_canvas(quest_id)
+        research_state = self.app.quest_service.read_research_state(quest_root)
+        active_workspace_branch = str(research_state.get("current_workspace_branch") or "").strip() or None
+        payload["active_workspace_ref"] = active_workspace_branch
+        payload["workspace_mode"] = str(research_state.get("workspace_mode") or "copilot").strip() or "copilot"
         return payload
 
     def git_log(self, quest_id: str, path: str) -> dict:
@@ -1319,10 +1512,7 @@ npm --prefix src/ui run build</pre>
             mime_type = mimetypes.guess_type(file_path.name)[0] or "application/octet-stream"
             content = quest_service._read_git_bytes(quest_root, revision, relative)
             return 200, self._asset_headers(mime_type), content
-        path, _writable, _scope, _source_kind = quest_service._resolve_document(
-            quest_service._quest_root(quest_id),
-            document_id,
-        )
+        path, _writable, _scope, _source_kind = quest_service.resolve_document(quest_id, document_id)
         if not path.exists() or not path.is_file():
             return 404, {"Content-Type": "text/plain; charset=utf-8"}, b"Not Found"
         mime_type = mimetypes.guess_type(path.name)[0] or "application/octet-stream"

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

@@ -9,6 +9,9 @@ ROUTES: list[tuple[str, re.Pattern[str], str]] = [
     ("GET", re.compile(r"^/metis/agent/api/health$"), "lingzhu_health"),
     ("POST", re.compile(r"^/metis/agent/api/sse$"), "lingzhu_sse"),
     ("GET", re.compile(r"^/(?P<spa_path>(?!api(?:/|$)|metis(?:/|$)|ui(?:/|$)|assets(?:/|$)).+)$"), "spa_root"),
+    ("POST", re.compile(r"^/api/auth/login$"), "auth_login"),
+    ("GET", re.compile(r"^/api/auth/token$"), "auth_token"),
+    ("POST", re.compile(r"^/api/auth/rotate$"), "auth_rotate"),
     ("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"),
@@ -61,7 +64,9 @@ ROUTES: list[tuple[str, re.Pattern[str], str]] = [
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/graph$"), "graph"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/graph/(?P<kind>svg|png|json)$"), "graph_asset"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/metrics/timeline$"), "metrics_timeline"),
+    ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/baselines/compare$"), "baseline_compare"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/branches$"), "git_branches"),
+    ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/canvas$"), "git_canvas"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/log$"), "git_log"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/compare$"), "git_compare"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/commit$"), "git_commit"),