@researai/deepscientist 1.5.9 → 1.5.11

package/src/deepscientist/quest/node_traces.py

@@ -6,6 +6,8 @@ from typing import Any
 
 from ..shared import ensure_dir, read_json, sha256_text, utc_now, write_json
 
+NODE_TRACE_SCHEMA_VERSION = 2
+
 
 def _format_state_label(value: str | None) -> str:
     normalized = str(value or "").strip().replace("_", " ").replace("-", " ")
@@ -36,6 +38,23 @@ def _normalize_branch_name(value: object, *, fallback: str) -> str:
     return text or fallback
 
 
+def _infer_stage_from_branch_name(value: object) -> str | None:
+    normalized = str(value or "").strip().lower()
+    if not normalized:
+        return None
+    if normalized.startswith("analysis/"):
+        return "analysis"
+    if normalized.startswith("run/"):
+        return "experiment"
+    if normalized.startswith("idea/"):
+        return "idea"
+    if normalized.startswith("paper/") or normalized.startswith("write/"):
+        return "writing"
+    if normalized.startswith("baseline/"):
+        return "baseline"
+    return None
+
+
 def _infer_stage_from_skill(skill_id: object) -> str | None:
     normalized = str(skill_id or "").strip().lower()
     if not normalized:
@@ -240,6 +259,7 @@ def _resolve_entry_context(
         or _infer_stage_from_artifact((((run_artifact or {}).get("record") or {}) if run_artifact else {}))
         or (run_context or {}).get("stage_key")
         or _infer_stage_from_event_type(raw_event_type)
+        or _infer_stage_from_branch_name(branch_name)
         or "general"
     )
     return {
@@ -440,6 +460,7 @@ class QuestNodeTraceManager:
         source_signature = sha256_text(
             json.dumps(
                 {
+                    "schema_version": NODE_TRACE_SCHEMA_VERSION,
                     "entries": workflow.get("entries") or [],
                     "branch": (snapshot or {}).get("branch"),
                 },
@@ -451,6 +472,7 @@ class QuestNodeTraceManager:
         if (
             isinstance(existing, dict)
             and existing.get("quest_id") == quest_id
+            and existing.get("schema_version") == NODE_TRACE_SCHEMA_VERSION
             and existing.get("source_signature") == source_signature
             and isinstance(existing.get("items"), list)
         ):
@@ -545,6 +567,7 @@ class QuestNodeTraceManager:
 
         payload = {
             "quest_id": quest_id,
+            "schema_version": NODE_TRACE_SCHEMA_VERSION,
             "generated_at": utc_now(),
             "source_signature": source_signature,
             "items": items,

package/src/deepscientist/quest/service.py

@@ -19,7 +19,7 @@ except ImportError:  # pragma: no cover
 
 from ..artifact.metrics import build_metrics_timeline, extract_latest_metric
 from ..config import ConfigManager
-from ..connector_runtime import conversation_identity_key, normalize_conversation_id
+from ..connector_runtime import conversation_identity_key, normalize_conversation_id, parse_conversation_id
 from ..gitops import current_branch, export_git_graph, head_commit, init_repo
 from ..home import repo_root
 from ..registries import BaselineRegistry
@@ -64,6 +64,35 @@ class QuestService:
     def _quest_root(self, quest_id: str) -> Path:
         return self.quests_root / quest_id
 
+    def _normalized_binding_sources(self, sources: list[Any] | None) -> list[str]:
+        local_present = False
+        external_source: str | None = None
+        for raw in sources or []:
+            normalized = self._normalize_binding_source(raw)
+            if not normalized:
+                continue
+            if normalized == "local:default":
+                local_present = True
+                continue
+            parsed = parse_conversation_id(normalized)
+            connector = str((parsed or {}).get("connector") or "").strip().lower()
+            if connector == "local":
+                local_present = True
+                continue
+            external_source = normalized
+        if external_source:
+            return ["local:default", external_source]
+        if local_present:
+            return ["local:default"]
+        return ["local:default"]
+
+    def _binding_sources_payload(self, quest_root: Path) -> dict[str, list[str]]:
+        bindings_path = quest_root / ".ds" / "bindings.json"
+        payload = read_json(bindings_path, {"sources": ["local:default"]})
+        raw_sources = payload.get("sources") if isinstance(payload, dict) else ["local:default"]
+        sources = self._normalized_binding_sources(raw_sources if isinstance(raw_sources, list) else ["local:default"])
+        return {"sources": sources}
+
     def preferred_locale(self, quest_root: Path | None = None) -> str:
         if quest_root is not None:
             try:
@@ -738,7 +767,7 @@ class QuestService:
             "last_artifact_interact_at": runtime_state.get("last_artifact_interact_at"),
             "last_delivered_batch_id": runtime_state.get("last_delivered_batch_id"),
             "last_delivered_at": runtime_state.get("last_delivered_at"),
-            "bound_conversations": (self._read_cached_json(quest_root / ".ds" / "bindings.json", {}).get("sources") or ["local:default"]),
+            "bound_conversations": self._binding_sources_payload(quest_root).get("sources") or ["local:default"],
             "created_at": quest_yaml.get("created_at"),
             "updated_at": quest_yaml.get("updated_at"),
             "branch": research_state.get("current_workspace_branch") or research_state.get("research_head_branch"),
@@ -1093,7 +1122,7 @@ class QuestService:
             "last_artifact_interact_at": runtime_state.get("last_artifact_interact_at"),
             "last_delivered_batch_id": runtime_state.get("last_delivered_batch_id"),
             "last_delivered_at": runtime_state.get("last_delivered_at"),
-            "bound_conversations": (self._read_cached_json(quest_root / ".ds" / "bindings.json", {}).get("sources") or ["local:default"]),
+            "bound_conversations": self._binding_sources_payload(quest_root).get("sources") or ["local:default"],
             "created_at": quest_yaml.get("created_at"),
             "updated_at": quest_yaml.get("updated_at"),
             "branch": current_branch(workspace_root),
@@ -1362,61 +1391,30 @@ class QuestService:
     def bind_source(self, quest_id: str, source: str) -> dict:
         quest_root = self._quest_root(quest_id)
         bindings_path = quest_root / ".ds" / "bindings.json"
-        bindings = read_json(bindings_path, {"sources": []})
+        bindings = self._binding_sources_payload(quest_root)
         normalized_source = self._normalize_binding_source(source)
-        normalized_key = conversation_identity_key(normalized_source)
-        changed = False
-        replaced = False
-        sources: list[str] = []
-        for item in list(bindings.get("sources") or []):
-            existing = self._normalize_binding_source(str(item))
-            if conversation_identity_key(existing) == normalized_key:
-                if not replaced:
-                    sources.append(normalized_source)
-                    replaced = True
-                    if existing != normalized_source:
-                        changed = True
-                else:
-                    changed = True
-                continue
-            sources.append(existing)
-            if existing != item:
-                changed = True
-        if not replaced:
-            sources.append(normalized_source)
-            changed = True
+        next_sources = self._normalized_binding_sources([*(bindings.get("sources") or []), normalized_source])
+        changed = list(bindings.get("sources") or []) != next_sources
         if changed:
-            bindings["sources"] = sources
+            bindings["sources"] = next_sources
             write_json(bindings_path, bindings)
         return bindings
 
     def binding_sources(self, quest_id: str) -> list[str]:
         quest_root = self._quest_root(quest_id)
-        bindings_path = quest_root / ".ds" / "bindings.json"
-        bindings = read_json(bindings_path, {"sources": ["local:default"]})
-        sources = [self._normalize_binding_source(item) for item in (bindings.get("sources") or [])]
-        return [item for item in sources if item]
+        return list(self._binding_sources_payload(quest_root).get("sources") or ["local:default"])
 
     def set_binding_sources(self, quest_id: str, sources: list[str]) -> dict:
         quest_root = self._quest_root(quest_id)
         bindings_path = quest_root / ".ds" / "bindings.json"
-        normalized_sources = [self._normalize_binding_source(item) for item in sources]
-        ordered: list[str] = []
-        seen: set[str] = set()
-        for item in normalized_sources:
-            key = conversation_identity_key(item)
-            if not item or key in seen:
-                continue
-            seen.add(key)
-            ordered.append(item)
-        payload = {"sources": ordered}
+        payload = {"sources": self._normalized_binding_sources(sources)}
         write_json(bindings_path, payload)
         return payload
 
     def unbind_source(self, quest_id: str, source: str) -> dict:
         quest_root = self._quest_root(quest_id)
         bindings_path = quest_root / ".ds" / "bindings.json"
-        bindings = read_json(bindings_path, {"sources": []})
+        bindings = self._binding_sources_payload(quest_root)
         normalized_source = self._normalize_binding_source(source)
         normalized_key = conversation_identity_key(normalized_source)
         changed = False
@@ -1429,8 +1427,11 @@ class QuestService:
             sources.append(existing)
             if existing != item:
                 changed = True
+        normalized_sources = self._normalized_binding_sources(sources)
+        if normalized_sources != list(bindings.get("sources") or []):
+            changed = True
         if changed:
-            bindings["sources"] = sources
+            bindings["sources"] = normalized_sources
             write_json(bindings_path, bindings)
         return bindings
 
@@ -1824,6 +1825,12 @@ class QuestService:
         resolved_selection = dict(selection or {})
         selection_ref = str(resolved_selection.get("selection_ref") or "").strip()
         selection_type = str(resolved_selection.get("selection_type") or "stage_node").strip() or None
+        if (
+            selection_type == "branch_node"
+            and selection_ref
+            and not str(resolved_selection.get("branch_name") or "").strip()
+        ):
+            resolved_selection["branch_name"] = selection_ref
         trace = None
         if selection_ref:
             try:
@@ -2080,7 +2087,18 @@ class QuestService:
             if document_id.startswith(("questpath::", "memory::"))
             else workspace_root
         )
-        path, writable, scope, source_kind = self._resolve_document(resolution_root, document_id)
+        try:
+            path, writable, scope, source_kind = self._resolve_document(resolution_root, document_id)
+        except FileNotFoundError:
+            legacy_relative = None
+            if document_id.startswith("path::"):
+                legacy_relative = document_id.split("::", 1)[1].lstrip("/")
+            if legacy_relative and legacy_relative.startswith("literature/arxiv/"):
+                path, writable, scope, source_kind = self._resolve_document(
+                    quest_root, f"questpath::{legacy_relative}"
+                )
+            else:
+                raise
         renderer_hint, mime_type = self._renderer_hint_for(path)
         is_text = self._is_text_document(path, mime_type, renderer_hint)
         content = read_text(path) if is_text else ""
@@ -3549,7 +3567,35 @@ def _tool_name(event: dict, item: dict) -> str:
     return "tool"
 
 
+def _structured_text(value: object) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value.strip()
+    try:
+        return json.dumps(value, ensure_ascii=False, indent=2)
+    except TypeError:
+        return str(value)
+
+
+def _is_bash_exec_item(event: dict, item: dict) -> bool:
+    server = str(item.get("server") or event.get("server") or "").strip()
+    tool = str(item.get("tool") or event.get("tool") or "").strip()
+    return server == "bash_exec" and tool == "bash_exec"
+
+
 def _tool_args(event: dict, item: dict) -> str:
+    if _is_bash_exec_item(event, item):
+        for value in (
+            item.get("arguments"),
+            event.get("arguments"),
+            item.get("input"),
+            event.get("input"),
+        ):
+            text = _structured_text(value)
+            if text:
+                return text
+        return ""
     for value in (
         item.get("command"),
         item.get("query"),
@@ -3569,6 +3615,21 @@ def _tool_args(event: dict, item: dict) -> str:
 
 
 def _tool_output(event: dict, item: dict) -> str:
+    if _is_bash_exec_item(event, item):
+        for value in (
+            item.get("result"),
+            item.get("output"),
+            item.get("content"),
+            event.get("result"),
+            event.get("output"),
+            event.get("content"),
+            item.get("aggregated_output"),
+            event.get("aggregated_output"),
+        ):
+            text = _structured_text(value)
+            if text:
+                return text
+        return ""
     for value in (
         item.get("aggregated_output"),
         item.get("changes"),
@@ -3611,17 +3672,25 @@ def _mcp_tool_metadata(*, quest_id: str, run_id: str, server: str, tool: str, it
         for key in ("command", "workdir", "mode", "timeout_seconds", "comment"):
             if key in arguments:
                 metadata[key] = arguments.get(key)
+        if server == "bash_exec" and tool == "bash_exec" and isinstance(arguments.get("id"), str):
+            metadata["bash_id"] = arguments.get("id")
     result_payload = _mcp_result_payload(item)
     if server == "bash_exec" and tool == "bash_exec":
         for key in (
             "bash_id",
             "status",
+            "command",
+            "workdir",
+            "cwd",
+            "kind",
+            "comment",
             "started_at",
             "finished_at",
             "exit_code",
             "stop_reason",
             "last_progress",
             "log_path",
+            "watchdog_after_seconds",
         ):
             if key in result_payload:
                 metadata[key] = result_payload.get(key)

package/src/deepscientist/quest/stage_views.py

@@ -153,8 +153,68 @@ class QuestStageViewBuilder:
                 return candidate
         return self.quest_root
 
+    def _infer_stage_from_branch_name(self) -> str | None:
+        normalized = str(self.branch_name or "").strip().lower()
+        if not normalized:
+            return None
+        if normalized.startswith("analysis/"):
+            return "analysis"
+        if normalized.startswith("run/"):
+            return "experiment"
+        if normalized.startswith("idea/"):
+            return "idea"
+        if normalized.startswith("paper/") or normalized.startswith("write/"):
+            return "paper"
+        if normalized.startswith("baseline/"):
+            return "baseline"
+        return None
+
+    def _has_paper_state(self) -> bool:
+        paper_root = self._paper_root()
+        return bool(
+            self._paper_candidates()
+            or (paper_root / "selected_outline.json").exists()
+            or (paper_root / "draft.md").exists()
+            or self._paper_bundle_manifest()
+        )
+
+    def _resolve_effective_stage_key(self) -> str:
+        normalized = normalize_stage_key(self.stage_key)
+        if normalized in {"baseline", "idea", "experiment", "analysis", "paper"}:
+            return normalized
+        if normalized != "general":
+            return normalized
+
+        inferred = self._infer_stage_from_branch_name()
+        if inferred:
+            return inferred
+        if self._analysis_stage_items(None):
+            return "analysis"
+        if self._experiment_stage_items():
+            return "experiment"
+        if self._idea_stage_items():
+            return "idea"
+        if self._has_paper_state():
+            return "paper"
+        if self._baseline_stage_items():
+            return "baseline"
+        return normalized
+
+    @staticmethod
+    def _artifact_detail(item: dict[str, Any] | None, payload: dict[str, Any]) -> dict[str, Any] | None:
+        if not isinstance(payload, dict) or not payload:
+            return None
+        record = dict(item or {})
+        return {
+            "artifact_id": payload.get("artifact_id") or payload.get("id"),
+            "artifact_kind": payload.get("kind"),
+            "artifact_path": record.get("path"),
+            "payload": payload,
+        }
+
     def build(self) -> dict[str, Any]:
         selection_type = str(self.selection.get("selection_type") or "").strip()
+        self.stage_key = self._resolve_effective_stage_key()
         if selection_type == "branch_node" and self.stage_key not in {"experiment", "analysis", "paper"}:
             return self._build_branch()
         if self.stage_key == "baseline":
@@ -855,7 +915,8 @@ class QuestStageViewBuilder:
                     "draft_markdown": draft_markdown,
                     "literature_files": literature_files,
                     "decision_reason": payload.get("reason"),
-                }
+                },
+                "latest_artifact": self._artifact_detail(latest, payload),
             },
             lineage_intent=lineage_intent,
             idea_draft_path=draft_md_rel_path,
@@ -1084,7 +1145,8 @@ class QuestStageViewBuilder:
                     else None,
                     "analysis_summary_path": self._relative_path_or_raw(analysis_summary_path),
                     "analysis_summary_markdown": analysis_summary_markdown,
-                }
+                },
+                "latest_artifact": self._artifact_detail(latest_experiment_item or latest_idea_item, latest_experiment_payload or latest_idea_payload),
             },
             lineage_intent=lineage_intent,
             idea_draft_path=idea_draft_rel_path,
@@ -1198,7 +1260,8 @@ class QuestStageViewBuilder:
                     "trace_summary": trace_summary,
                     "trace_markdown": trace_markdown,
                     "trace_actions": self._recent_trace_actions(),
-                }
+                },
+                "latest_artifact": self._artifact_detail(latest, payload),
             },
         )
 
@@ -1388,10 +1451,12 @@ class QuestStageViewBuilder:
                     "todo_manifest_markdown": self._markdown_body_for_path(manifest.get("todo_manifest_path")),
                     "summary_path": self._relative_path_or_raw(summary_path) if summary_path else None,
                     "summary_markdown": summary_markdown,
+                    "manifest_payload": manifest,
                     "trace_summary": trace_summary,
                     "trace_markdown": self._trace_markdown(),
                     "trace_actions": self._recent_trace_actions(),
-                }
+                },
+                "latest_artifact": self._artifact_detail(latest, latest_payload),
             },
         )
 
@@ -1532,6 +1597,7 @@ class QuestStageViewBuilder:
                         "latex_root_path": latex_root_rel,
                         "main_tex_path": main_tex_rel,
                     },
-                }
+                },
+                "latest_artifact": self._artifact_detail(paper_items[-1] if paper_items else None, self._payload(paper_items[-1] if paper_items else {})),
             },
         )

package/src/deepscientist/runners/codex.py

@@ -35,6 +35,17 @@ def _compact_text(value: object, *, limit: int = 1200) -> str:
     return text[: limit - 1].rstrip() + "…"
 
 
+def _structured_text(value: object) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value.strip()
+    try:
+        return json.dumps(value, ensure_ascii=False, indent=2)
+    except TypeError:
+        return str(value)
+
+
 def _iter_event_texts(event: dict[str, Any]) -> list[str]:
     texts: list[str] = []
     for key in ("text", "content", "message"):
@@ -184,7 +195,24 @@ def _tool_name(event: dict[str, Any], item: dict[str, Any]) -> str:
     return "tool"
 
 
+def _is_bash_exec_item(event: dict[str, Any], item: dict[str, Any]) -> bool:
+    server = str(item.get("server") or event.get("server") or "").strip()
+    tool = str(item.get("tool") or event.get("tool") or "").strip()
+    return server == "bash_exec" and tool == "bash_exec"
+
+
 def _tool_args(event: dict[str, Any], item: dict[str, Any]) -> str:
+    if _is_bash_exec_item(event, item):
+        for value in (
+            item.get("arguments"),
+            event.get("arguments"),
+            item.get("input"),
+            event.get("input"),
+        ):
+            text = _structured_text(value)
+            if text:
+                return text
+        return ""
     for value in (
         item.get("command"),
         item.get("query"),
@@ -204,6 +232,21 @@ def _tool_args(event: dict[str, Any], item: dict[str, Any]) -> str:
 
 
 def _tool_output(event: dict[str, Any], item: dict[str, Any]) -> str:
+    if _is_bash_exec_item(event, item):
+        for value in (
+            item.get("result"),
+            item.get("output"),
+            item.get("content"),
+            event.get("result"),
+            event.get("output"),
+            event.get("content"),
+            item.get("aggregated_output"),
+            event.get("aggregated_output"),
+        ):
+            text = _structured_text(value)
+            if text:
+                return text
+        return ""
     for value in (
         item.get("aggregated_output"),
         item.get("changes"),
@@ -253,10 +296,12 @@ def _mcp_tool_metadata(
             metadata["workdir"] = arguments.get("workdir")
         if isinstance(arguments.get("mode"), str):
             metadata["mode"] = arguments.get("mode")
-        if isinstance(arguments.get("timeout_seconds"), int):
+        if arguments.get("timeout_seconds") is not None:
             metadata["timeout_seconds"] = arguments.get("timeout_seconds")
         if "comment" in arguments:
             metadata["comment"] = arguments.get("comment")
+        if server == "bash_exec" and tool == "bash_exec" and isinstance(arguments.get("id"), str):
+            metadata["bash_id"] = arguments.get("id")
     metadata["session_id"] = f"quest:{quest_id}"
     metadata["agent_id"] = "pi"
     metadata["agent_instance_id"] = run_id
@@ -266,12 +311,18 @@ def _mcp_tool_metadata(
         for key in (
             "bash_id",
             "status",
+            "command",
+            "workdir",
+            "cwd",
+            "kind",
+            "comment",
             "started_at",
             "finished_at",
             "exit_code",
             "stop_reason",
             "last_progress",
             "log_path",
+            "watchdog_after_seconds",
         ):
             if key in result_payload:
                 metadata[key] = result_payload.get(key)
@@ -758,6 +809,7 @@ class CodexRunner:
         workspace_root = request.worktree_root or request.quest_root
         resolved_binary = resolve_runner_binary(self.binary, runner_name="codex")
         resolved_runner_config = runner_config if isinstance(runner_config, dict) else self._load_runner_config()
+        normalized_model = str(request.model or "").strip()
         command = [
             resolved_binary or self.binary,
             "--search",
@@ -766,9 +818,9 @@ class CodexRunner:
             "--cd",
             str(workspace_root),
             "--skip-git-repo-check",
-            "--model",
-            request.model,
         ]
+        if normalized_model.lower() not in {"", "inherit", "default", "codex-default"}:
+            command.extend(["--model", normalized_model])
         if request.approval_policy:
             command.extend(["-c", f'approval_policy="{request.approval_policy}"'])
         reasoning_effort = request.reasoning_effort

package/src/deepscientist/weixin_support.py

@@ -0,0 +1 @@
+from .connector.weixin_support import *  # noqa: F401,F403

package/src/prompts/connectors/lingzhu.md

@@ -11,5 +11,7 @@
 - lingzhu_safety_rule: request only actions that are clearly justified by the current quest and understandable to the human user
 - lingzhu_text_rule: even when requesting `surface_actions`, always include a clear text explanation of what is happening and why
 - lingzhu_reply_style_rule: for Lingzhu-facing user-visible text sent through `artifact.interact(...)`, keep the message clear, concise, respectful, and high-information-density
-- lingzhu_reply_length_rule: for each Lingzhu-facing `artifact.interact(...)` message, normally answer in at most 2 to 3 sentences unless the user explicitly asks for more detail
+- lingzhu_reply_length_rule: for each Lingzhu-facing `artifact.interact(...)` message, normally keep the text within about 20 Chinese characters or one very short sentence unless the user explicitly asks for more detail
 - lingzhu_summary_first_rule: in Lingzhu-facing `artifact.interact(...)` messages, usually give only the synopsis and key facts needed for the user's next decision or understanding; avoid long preambles, repetition, and low-signal detail
+- lingzhu_task_gate_rule: only treat a Lingzhu user utterance as a new quest instruction when the text explicitly starts with `我现在的任务是`; otherwise assume the device is polling for queued progress or buffered replies
+- lingzhu_poll_rule: when Lingzhu is polling rather than giving a new task, return only the buffered progress checkpoints or the latest short status; do not reinterpret the poll text as a fresh instruction