@researai/deepscientist 1.5.6 → 1.5.8

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/cli.py

@@ -236,7 +236,7 @@ def run_command(home: Path, quest_id: str, skill_id: str, message: str, model: s
     config_manager = ConfigManager(home)
     config_manager.ensure_files()
     config = config_manager.load_named("config")
-    runners = config_manager.load_named("runners")
+    runners = config_manager.load_runners_config()
     quest_root = home / "quests" / quest_id
     codex_cfg = runners.get("codex", {})
     logger = JsonlLogger(home / "logs", level=config.get("logging", {}).get("level", "info"))

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,
@@ -128,7 +134,7 @@ def default_connectors() -> dict:
             "profiles": [],
             "app_id": None,
             "app_secret": None,
-            "app_secret_env": "QQ_APP_SECRET",
+            "app_secret_env": None,
             "bot_name": "DeepScientist",
             "command_prefix": "/",
             "main_chat_id": None,
@@ -149,7 +155,7 @@ def default_connectors() -> dict:
             "bot_name": "DeepScientist",
             "command_prefix": "/",
             "bot_token": None,
-            "bot_token_env": "TELEGRAM_BOT_TOKEN",
+            "bot_token_env": None,
             "dm_policy": "pairing",
             "allow_from": [],
             "group_policy": "open",
@@ -165,7 +171,7 @@ def default_connectors() -> dict:
             "bot_name": "DeepScientist",
             "command_prefix": "/",
             "bot_token": None,
-            "bot_token_env": "DISCORD_BOT_TOKEN",
+            "bot_token_env": None,
             "application_id": None,
             "dm_policy": "pairing",
             "allow_from": [],
@@ -183,10 +189,10 @@ def default_connectors() -> dict:
             "bot_name": "DeepScientist",
             "command_prefix": "/",
             "bot_token": None,
-            "bot_token_env": "SLACK_BOT_TOKEN",
+            "bot_token_env": None,
             "bot_user_id": None,
             "app_token": None,
-            "app_token_env": "SLACK_APP_TOKEN",
+            "app_token_env": None,
             "dm_policy": "pairing",
             "allow_from": [],
             "group_policy": "open",
@@ -203,7 +209,7 @@ def default_connectors() -> dict:
             "command_prefix": "/",
             "app_id": None,
             "app_secret": None,
-            "app_secret_env": "FEISHU_APP_SECRET",
+            "app_secret_env": None,
             "api_base_url": "https://open.feishu.cn",
             "dm_policy": "pairing",
             "allow_from": [],

package/src/deepscientist/config/service.py

@@ -30,12 +30,14 @@ from ..qq_profiles import (
     qq_profile_label,
 )
 from ..network import urlopen_with_proxy as urlopen
+from ..runners.runtime_overrides import apply_codex_runtime_overrides, apply_runners_runtime_overrides
 from ..shared import read_json, read_text, read_yaml, resolve_runner_binary, run_command, sha256_text, utc_now, which, write_text, write_yaml
 from .models import (
     CONFIG_NAMES,
     OPTIONAL_CONFIG_NAMES,
     REQUIRED_CONFIG_NAMES,
     ConfigFileInfo,
+    SYSTEM_CONNECTOR_NAMES,
     config_filename,
     default_payload,
 )
@@ -91,6 +93,36 @@ class ConfigManager:
     def load_named_normalized(self, name: str, create_optional: bool = False) -> dict:
         return self._normalize_named_payload(name, self.load_named(name, create_optional=create_optional))
 
+    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():
@@ -1039,9 +1071,16 @@ Use **Test** when the file exposes runtime dependencies.
         )
 
     def _probe_codex_runner(self, config: dict) -> dict:
+        config = apply_codex_runtime_overrides(config)
         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,
@@ -1049,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:
@@ -1082,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()
@@ -1373,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()
@@ -1396,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
@@ -1408,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):

package/src/deepscientist/connector_profiles.py

@@ -10,6 +10,13 @@ from .shared import slugify
 PROFILEABLE_CONNECTOR_NAMES = ("telegram", "discord", "slack", "feishu", "whatsapp")
 
 
+def _normalize_secret_pair(payload: dict[str, Any], direct_key: str, env_key: str) -> None:
+    direct = _as_text(payload.get(direct_key))
+    env_name = _as_text(payload.get(env_key))
+    payload[direct_key] = direct
+    payload[env_key] = None if direct else env_name
+
+
 CONNECTOR_PROFILE_SPECS: dict[str, dict[str, Any]] = {
     "telegram": {
         "profile_id_prefix": "telegram-profile",
@@ -35,7 +42,7 @@ CONNECTOR_PROFILE_SPECS: dict[str, dict[str, Any]] = {
             "transport": "polling",
             "bot_name": "DeepScientist",
             "bot_token": None,
-            "bot_token_env": "TELEGRAM_BOT_TOKEN",
+            "bot_token_env": None,
         },
         "profile_fields": (
             "enabled",
@@ -47,6 +54,7 @@ CONNECTOR_PROFILE_SPECS: dict[str, dict[str, Any]] = {
         "migration_keys": ("bot_token",),
         "label_fields": ("bot_name",),
         "id_fields": ("bot_name",),
+        "secret_pairs": (("bot_token", "bot_token_env"),),
     },
     "discord": {
         "profile_id_prefix": "discord-profile",
@@ -74,7 +82,7 @@ CONNECTOR_PROFILE_SPECS: dict[str, dict[str, Any]] = {
             "transport": "gateway",
             "bot_name": "DeepScientist",
             "bot_token": None,
-            "bot_token_env": "DISCORD_BOT_TOKEN",
+            "bot_token_env": None,
             "application_id": None,
         },
         "profile_fields": (
@@ -88,6 +96,7 @@ CONNECTOR_PROFILE_SPECS: dict[str, dict[str, Any]] = {
         "migration_keys": ("bot_token", "application_id"),
         "label_fields": ("bot_name", "application_id"),
         "id_fields": ("application_id", "bot_name"),
+        "secret_pairs": (("bot_token", "bot_token_env"),),
     },
     "slack": {
         "profile_id_prefix": "slack-profile",
@@ -116,10 +125,10 @@ CONNECTOR_PROFILE_SPECS: dict[str, dict[str, Any]] = {
             "transport": "socket_mode",
             "bot_name": "DeepScientist",
             "bot_token": None,
-            "bot_token_env": "SLACK_BOT_TOKEN",
+            "bot_token_env": None,
             "bot_user_id": None,
             "app_token": None,
-            "app_token_env": "SLACK_APP_TOKEN",
+            "app_token_env": None,
         },
         "profile_fields": (
             "enabled",
@@ -134,6 +143,10 @@ CONNECTOR_PROFILE_SPECS: dict[str, dict[str, Any]] = {
         "migration_keys": ("bot_token", "bot_user_id", "app_token"),
         "label_fields": ("bot_name", "bot_user_id"),
         "id_fields": ("bot_user_id", "bot_name"),
+        "secret_pairs": (
+            ("bot_token", "bot_token_env"),
+            ("app_token", "app_token_env"),
+        ),
     },
     "feishu": {
         "profile_id_prefix": "feishu-profile",
@@ -162,7 +175,7 @@ CONNECTOR_PROFILE_SPECS: dict[str, dict[str, Any]] = {
             "bot_name": "DeepScientist",
             "app_id": None,
             "app_secret": None,
-            "app_secret_env": "FEISHU_APP_SECRET",
+            "app_secret_env": None,
             "api_base_url": "https://open.feishu.cn",
         },
         "profile_fields": (
@@ -177,6 +190,7 @@ CONNECTOR_PROFILE_SPECS: dict[str, dict[str, Any]] = {
         "migration_keys": ("app_id", "app_secret"),
         "label_fields": ("bot_name", "app_id"),
         "id_fields": ("app_id", "bot_name"),
+        "secret_pairs": (("app_secret", "app_secret_env"),),
     },
     "whatsapp": {
         "profile_id_prefix": "whatsapp-profile",
@@ -213,6 +227,7 @@ CONNECTOR_PROFILE_SPECS: dict[str, dict[str, Any]] = {
         "migration_keys": ("session_dir",),
         "label_fields": ("bot_name",),
         "id_fields": ("bot_name",),
+        "secret_pairs": (),
     },
 }
 
@@ -270,10 +285,17 @@ def normalize_connector_config(connector_name: str, config: dict[str, Any] | Non
         if key in payload
     }
     shared["profiles"] = []
+    for direct_key, env_key in spec.get("secret_pairs", ()):
+        _normalize_secret_pair(shared, direct_key, env_key)
 
     raw_profiles = payload.get("profiles")
     items = list(raw_profiles) if isinstance(raw_profiles, list) else []
-    if not items and any(_as_text(payload.get(key)) for key in spec["migration_keys"]):
+    has_direct_migration_value = any(_as_text(payload.get(key)) for key in spec["migration_keys"])
+    has_env_only_secret = bool(payload.get("enabled")) and any(
+        _as_text(payload.get(env_key))
+        for _, env_key in spec.get("secret_pairs", ())
+    )
+    if not items and (has_direct_migration_value or has_env_only_secret):
         items = [{key: payload.get(key) for key in spec["profile_fields"]}]
 
     used_ids: set[str] = set()
@@ -297,6 +319,8 @@ def normalize_connector_config(connector_name: str, config: dict[str, Any] | Non
         current["transport"] = infer_connector_transport(connector_name, current)
         if "mode" in spec["profile_defaults"] or current.get("mode") is not None:
             current["mode"] = _as_text(current.get("mode")) or str(spec["profile_defaults"].get("mode") or "")
+        for direct_key, env_key in spec.get("secret_pairs", ()):
+            _normalize_secret_pair(current, direct_key, env_key)
         current["profile_id"] = _unique_profile_id(
             _profile_seed(connector_name, current, index=index),
             prefix=str(spec["profile_id_prefix"]),
@@ -309,6 +333,10 @@ def normalize_connector_config(connector_name: str, config: dict[str, Any] | Non
     if len(profiles) == 1:
         for key in spec["profile_fields"]:
             shared[key] = profiles[0].get(key)
+    elif len(profiles) > 1:
+        for direct_key, env_key in spec.get("secret_pairs", ()):
+            shared[direct_key] = None
+            shared[env_key] = None
     return shared