@researai/deepscientist 1.5.14 → 1.5.15

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,7 +11,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 ...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
@@ -474,6 +474,11 @@ 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"):
+            try:
+                self.app.quest_service.prime_projection(quest_id, kind)
+            except Exception:
+                continue
         return {
             "ok": True,
             "quest_id": quest_id,
@@ -768,7 +773,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 +834,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 +861,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 +909,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 +961,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 +978,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 +1021,11 @@ 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_log(self, quest_id: str, path: str) -> dict:

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

@@ -61,6 +61,7 @@ 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/log$"), "git_log"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/compare$"), "git_compare"),