@researai/deepscientist 1.5.7 → 1.5.9

package/src/deepscientist/bash_exec/monitor.py

@@ -448,7 +448,7 @@ def run_monitor(session_dir: Path) -> int:
                 _terminate_process(process, process_group_id)
                 stop_requested = True
 
-            if session_kind == "terminal" and output_fd is not None and process.poll() is None:
+            if output_fd is not None and process.poll() is None:
                 cursor_payload = read_json(input_cursor_path, {}) or {}
                 offset = int(cursor_payload.get("offset") or 0)
                 input_entries = read_jsonl(input_path)

package/src/deepscientist/bash_exec/service.py

@@ -555,6 +555,7 @@ class BashExecService:
         before_seq: int | None = None,
         after_seq: int | None = None,
         order: str = "asc",
+        prefer_visible: bool = False,
     ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
         if not self.meta_path(quest_root, bash_id).exists():
             raise FileNotFoundError(f"Unknown bash session `{bash_id}`.")
@@ -579,9 +580,16 @@ class BashExecService:
             entries = [entry for entry in entries if int(entry.get("seq") or 0) > normalized_after]
         if normalized_before is not None:
             entries = [entry for entry in entries if int(entry.get("seq") or 0) < normalized_before]
+        selection_pool = entries
+        if prefer_visible:
+            visible_entries = [
+                entry for entry in entries if str(entry.get("stream") or "") not in {"system", "prompt"}
+            ]
+            if visible_entries:
+                selection_pool = visible_entries
         normalized_limit = max(1, limit)
-        truncated = len(entries) > normalized_limit
-        selected = entries[-normalized_limit:]
+        truncated = len(selection_pool) > normalized_limit
+        selected = selection_pool[-normalized_limit:]
         if order == "desc":
             selected = list(reversed(selected))
         tail_start_seq = int(selected[0].get("seq") or 0) if selected else None
@@ -1025,15 +1033,14 @@ class BashExecService:
         if not normalized_data:
             raise ValueError("terminal_input_required")
         session = self.reconcile_session(quest_root, bash_id)
-        if _normalize_string(session.get("kind")).lower() != "terminal":
-            raise ValueError("not_terminal_session")
         status = _normalize_string(session.get("status")).lower()
         if status in TERMINAL_STATUSES:
             raise ValueError("terminal_session_inactive")
         runtime = self._terminal_runtime_manager.get_runtime(quest_root, bash_id)
-        if runtime is None:
+        if runtime is None and _normalize_string(session.get("kind")).lower() == "terminal":
             raise ValueError("terminal_runtime_inactive")
-        runtime.write_input(normalized_data)
+        if runtime is not None:
+            runtime.write_input(normalized_data)
 
         entry = {
             "input_id": generate_id("tin"),
@@ -1081,9 +1088,10 @@ class BashExecService:
         return True
 
     def issue_terminal_attach_token(self, quest_root: Path, bash_id: str, *, ttl_seconds: int = 60) -> dict[str, Any]:
-        runtime = self._terminal_runtime_manager.get_runtime(quest_root, bash_id)
-        if runtime is None:
-            raise ValueError("terminal_runtime_inactive")
+        session = self.reconcile_session(quest_root, bash_id)
+        status = _normalize_string(session.get("status")).lower()
+        if status in TERMINAL_STATUSES:
+            raise ValueError("terminal_session_inactive")
         token = self._terminal_runtime_manager.issue_attach_token(
             quest_root,
             bash_id,

package/src/deepscientist/channels/qq.py

@@ -293,6 +293,20 @@ class QQRelayChannel(BaseChannel):
         def matches_profile(item: dict[str, Any], profile_id: str) -> bool:
             item_profile_id = str(item.get("profile_id") or "").strip()
             return item_profile_id == profile_id or (not item_profile_id and len(profiles) == 1)
+
+        def count_profile_records(path: Path, profile_id: str) -> int:
+            total = 0
+            for raw in read_jsonl(path):
+                if not isinstance(raw, dict):
+                    continue
+                record_profile_id = str(raw.get("profile_id") or "").strip()
+                if not record_profile_id:
+                    parsed = parse_conversation_id(str(raw.get("conversation_id") or "").strip())
+                    record_profile_id = str((parsed or {}).get("profile_id") or "").strip()
+                if record_profile_id == profile_id or (not record_profile_id and len(profiles) == 1):
+                    total += 1
+            return total
+
         profile_snapshots = []
         for profile in profiles:
             profile_id = str(profile.get("profile_id") or "").strip()
@@ -342,6 +356,9 @@ class QQRelayChannel(BaseChannel):
                     "discovered_targets": profile_targets,
                     "recent_conversations": profile_recent_conversations,
                     "bindings": profile_bindings,
+                    "inbox_count": count_profile_records(self.inbox_path, profile_id),
+                    "outbox_count": count_profile_records(self.outbox_path, profile_id),
+                    "ignored_count": count_profile_records(self.ignored_path, profile_id),
                     "target_count": len(profile_targets),
                     "binding_count": len(profile_bindings),
                     "last_error": gateway_state.get("last_error") if isinstance(gateway_state, dict) else None,

package/src/deepscientist/channels/relay.py

@@ -282,6 +282,19 @@ class GenericRelayChannel(BaseChannel):
             item_profile_id = str(item.get("profile_id") or "").strip()
             return item_profile_id == profile_id or (not item_profile_id and len(profiles) == 1)
 
+        def count_profile_records(path: Path, profile_id: str) -> int:
+            total = 0
+            for raw in read_jsonl(path):
+                if not isinstance(raw, dict):
+                    continue
+                record_profile_id = str(raw.get("profile_id") or "").strip()
+                if not record_profile_id:
+                    parsed = parse_conversation_id(str(raw.get("conversation_id") or "").strip())
+                    record_profile_id = str((parsed or {}).get("profile_id") or "").strip()
+                if record_profile_id == profile_id or (not record_profile_id and len(profiles) == 1):
+                    total += 1
+            return total
+
         profile_snapshots = []
         for profile in profiles:
             profile_id = str(profile.get("profile_id") or "").strip()
@@ -322,6 +335,9 @@ class GenericRelayChannel(BaseChannel):
                     "discovered_targets": profile_targets,
                     "recent_conversations": profile_recent_conversations,
                     "bindings": profile_bindings,
+                    "inbox_count": count_profile_records(self.inbox_path, profile_id),
+                    "outbox_count": count_profile_records(self.outbox_path, profile_id),
+                    "ignored_count": count_profile_records(self.ignored_path, profile_id),
                     "target_count": len(profile_targets),
                     "binding_count": len(profile_bindings),
                     "last_error": profile_runtime_state.get("last_error") if isinstance(profile_runtime_state, dict) else None,

package/src/deepscientist/config/models.py

@@ -6,6 +6,7 @@ from pathlib import Path
 CONFIG_NAMES = ("config", "runners", "connectors", "plugins", "mcp_servers")
 REQUIRED_CONFIG_NAMES = ("config", "runners", "connectors")
 OPTIONAL_CONFIG_NAMES = ("plugins", "mcp_servers")
+SYSTEM_CONNECTOR_NAMES = ("qq", "telegram", "discord", "slack", "feishu", "whatsapp", "lingzhu")
 
 
 @dataclass(frozen=True)
@@ -20,6 +21,10 @@ def config_filename(name: str) -> str:
     return f"{name}.yaml"
 
 
+def default_system_enabled_connectors() -> dict[str, bool]:
+    return {name: name == "qq" for name in SYSTEM_CONNECTOR_NAMES}
+
+
 def default_config(home: Path) -> dict:
     return {
         "home": str(home),
@@ -65,6 +70,7 @@ def default_config(home: Path) -> dict:
             "auto_ack": True,
             "milestone_push": True,
             "direct_chat_enabled": True,
+            "system_enabled": default_system_enabled_connectors(),
         },
         "cloud": {
             "enabled": False,

package/src/deepscientist/config/service.py

@@ -37,6 +37,7 @@ from .models import (
     OPTIONAL_CONFIG_NAMES,
     REQUIRED_CONFIG_NAMES,
     ConfigFileInfo,
+    SYSTEM_CONNECTOR_NAMES,
     config_filename,
     default_payload,
 )
@@ -95,6 +96,33 @@ class ConfigManager:
     def load_runners_config(self) -> dict:
         return apply_runners_runtime_overrides(self.load_named_normalized("runners"))
 
+    def load_runtime_config(self) -> dict:
+        return self.load_named_normalized("config")
+
+    def system_connector_gates(self) -> dict[str, bool]:
+        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 {}
+        return {
+            name: self._coerce_bool(system_enabled.get(name), default=name == "qq")
+            for name in SYSTEM_CONNECTOR_NAMES
+        }
+
+    def system_enabled_connector_names(self) -> list[str]:
+        gates = self.system_connector_gates()
+        return [name for name in SYSTEM_CONNECTOR_NAMES if gates.get(name, False)]
+
+    def is_connector_system_enabled(self, name: str) -> bool:
+        normalized = str(name or "").strip().lower()
+        if not normalized:
+            return False
+        if normalized == "local":
+            return True
+        gates = self.system_connector_gates()
+        if normalized in gates:
+            return gates[normalized]
+        return True
+
     def load_named_text(self, name: str, create_optional: bool = False) -> str:
         path = self.path_for(name)
         if create_optional and name in OPTIONAL_CONFIG_NAMES and not path.exists():
@@ -1047,6 +1075,12 @@ Use **Test** when the file exposes runtime dependencies.
         checked_at = utc_now()
         binary = str(config.get("binary") or "codex").strip() or "codex"
         resolved_binary = resolve_runner_binary(binary, runner_name="codex")
+        raw_reasoning_effort = config.get("model_reasoning_effort")
+        reasoning_effort = (
+            str(raw_reasoning_effort).strip()
+            if raw_reasoning_effort is not None and str(raw_reasoning_effort).strip()
+            else ("xhigh" if raw_reasoning_effort is None else None)
+        )
         details: dict[str, object] = {
             "binary": binary,
             "resolved_binary": resolved_binary,
@@ -1054,7 +1088,7 @@ Use **Test** when the file exposes runtime dependencies.
             "model": str(config.get("model") or "gpt-5.4"),
             "approval_policy": str(config.get("approval_policy") or "on-request"),
             "sandbox_mode": str(config.get("sandbox_mode") or "workspace-write"),
-            "reasoning_effort": str(config.get("model_reasoning_effort") or "xhigh"),
+            "reasoning_effort": reasoning_effort,
             "checked_at": checked_at,
         }
         if not resolved_binary:
@@ -1087,7 +1121,6 @@ Use **Test** when the file exposes runtime dependencies.
         approval_policy = str(config.get("approval_policy") or "on-request").strip()
         if approval_policy:
             command.extend(["-c", f'approval_policy="{approval_policy}"'])
-        reasoning_effort = str(config.get("model_reasoning_effort") or "xhigh").strip()
         if reasoning_effort:
             command.extend(["-c", f'model_reasoning_effort="{reasoning_effort}"'])
         sandbox_mode = str(config.get("sandbox_mode") or "workspace-write").strip()
@@ -1378,6 +1411,8 @@ Use **Test** when the file exposes runtime dependencies.
         normalized = self._deep_merge(defaults, payload)
         bootstrap = normalized.get("bootstrap") if isinstance(normalized.get("bootstrap"), dict) else {}
         raw_bootstrap = payload.get("bootstrap") if isinstance(payload.get("bootstrap"), dict) else {}
+        connectors = normalized.get("connectors") if isinstance(normalized.get("connectors"), dict) else {}
+        raw_connectors = payload.get("connectors") if isinstance(payload.get("connectors"), dict) else {}
         default_locale = str(defaults.get("default_locale") or "").strip()
         current_locale = str(normalized.get("default_locale") or "").strip()
         locale_source = str(raw_bootstrap.get("locale_source") or "").strip().lower()
@@ -1401,6 +1436,25 @@ Use **Test** when the file exposes runtime dependencies.
         bootstrap["locale_initialized_at"] = bootstrap.get("locale_initialized_at")
         bootstrap["locale_initialized_browser_locale"] = bootstrap.get("locale_initialized_browser_locale")
         normalized["bootstrap"] = bootstrap
+        raw_system_enabled = raw_connectors.get("system_enabled") if isinstance(raw_connectors.get("system_enabled"), dict) else {}
+        default_system_enabled = (
+            defaults.get("connectors", {}).get("system_enabled")
+            if isinstance(defaults.get("connectors"), dict)
+            else {}
+        )
+        current_system_enabled = (
+            connectors.get("system_enabled")
+            if isinstance(connectors.get("system_enabled"), dict)
+            else {}
+        )
+        connectors["system_enabled"] = {
+            name: self._coerce_bool(
+                raw_system_enabled.get(name, current_system_enabled.get(name)),
+                default=bool(default_system_enabled.get(name, False)),
+            )
+            for name in SYSTEM_CONNECTOR_NAMES
+        }
+        normalized["connectors"] = connectors
         return normalized
 
     @staticmethod
@@ -1413,6 +1467,20 @@ Use **Test** when the file exposes runtime dependencies.
             return False
         return abs(initial - 1.0) < 1e-9 and abs(multiplier - 2.0) < 1e-9 and abs(max_backoff - 8.0) < 1e-9
 
+    @staticmethod
+    def _coerce_bool(value: object, *, default: bool = False) -> bool:
+        if value is None:
+            return default
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, str):
+            normalized = value.strip().lower()
+            if normalized in {"1", "true", "yes", "on", "y"}:
+                return True
+            if normalized in {"0", "false", "no", "off", "n", ""}:
+                return False
+        return bool(value)
+
     def _normalize_plugins_payload(self, payload: dict) -> dict:
         normalized = deepcopy(payload)
         if "load_paths" not in normalized and isinstance(normalized.get("search_paths"), list):