@researai/deepscientist 1.5.2 → 1.5.4

package/src/deepscientist/mcp/server.py

@@ -661,8 +661,8 @@ def build_bash_exec_server(context: McpContext) -> FastMCP:
         description=(
             "Execute a bash command inside the current quest. "
             "mode=detach returns immediately. mode=await/create waits for completion. "
-            "mode=read returns the saved log. mode=kill requests termination. "
-            "mode=list shows known quest-local bash sessions."
+            "mode=read returns the saved log or a tailed log window. mode=kill requests termination. "
+            "mode=list shows known quest-local bash sessions. mode=history shows a compact reverse-chronological bash id list."
         ),
     )
     def bash_exec(
@@ -676,39 +676,88 @@ def build_bash_exec_server(context: McpContext) -> FastMCP:
         export_log_to: str | None = None,
         timeout_seconds: int | None = None,
         status: str | None = None,
+        kind: str | None = None,
         agent_ids: list[str] | None = None,
         agent_instance_ids: list[str] | None = None,
         chat_session_id: str | None = None,
         limit: int = 20,
+        tail_limit: int | None = None,
+        before_seq: int | None = None,
+        after_seq: int | None = None,
+        order: str = "asc",
+        include_log: bool = False,
+        wait: bool = False,
+        force: bool = False,
         comment: str | dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         quest_root = context.require_quest_root().resolve()
         normalized_mode = (mode or "detach").strip().lower()
         if normalized_mode == "create":
             normalized_mode = "await"
-        if normalized_mode not in {"detach", "await", "read", "kill", "list"}:
-            raise ValueError("Mode must be one of `detach`, `await`, `create`, `read`, `kill`, or `list`.")
-        if normalized_mode == "list":
+        if normalized_mode not in {"detach", "await", "read", "kill", "list", "history"}:
+            raise ValueError("Mode must be one of `detach`, `await`, `create`, `read`, `kill`, `list`, or `history`.")
+        if normalized_mode in {"list", "history"}:
+            resolved_limit = 500 if normalized_mode == "history" and limit == 20 else max(1, min(limit, 500))
             items = service.list_sessions(
                 quest_root,
                 status=status,
+                kind=kind,
                 agent_ids=agent_ids,
                 agent_instance_ids=agent_instance_ids,
                 chat_session_id=chat_session_id,
-                limit=max(1, min(limit, 500)),
+                limit=resolved_limit,
             )
+            history_lines = [service.format_history_line(item) for item in items]
             counts: dict[str, int] = {}
             for item in items:
                 item_status = str(item.get("status") or "unknown")
                 counts[item_status] = counts.get(item_status, 0) + 1
-            return {
+            payload = {
                 "count": len(items),
                 "items": items,
                 "status_counts": counts,
+                "summary": service.summary(quest_root),
+                "history_lines": history_lines,
             }
+            if normalized_mode == "history":
+                return {
+                    "count": len(items),
+                    "lines": history_lines,
+                    "items": items,
+                }
+            return payload
         if normalized_mode == "read":
             bash_id = service.resolve_session_id(quest_root, id)
             session = service.get_session(quest_root, bash_id)
+            normalized_order = (order or "asc").strip().lower()
+            if normalized_order not in {"asc", "desc"}:
+                normalized_order = "asc"
+            use_tail = tail_limit is not None or before_seq is not None or after_seq is not None or normalized_order != "asc"
+            if use_tail:
+                resolved_tail_limit = max(1, min(int(tail_limit or 200), 1000))
+                entries, tail_meta = service.read_log_entries(
+                    quest_root,
+                    bash_id,
+                    limit=resolved_tail_limit,
+                    before_seq=before_seq,
+                    after_seq=after_seq,
+                    order=normalized_order,
+                )
+                payload = service.build_tool_result(
+                    context,
+                    session=session,
+                    include_log=include_log,
+                    export_log=export_log,
+                    export_log_to=export_log_to,
+                )
+                payload["tail"] = entries
+                payload["tail_limit"] = tail_meta.get("tail_limit")
+                payload["tail_start_seq"] = tail_meta.get("tail_start_seq")
+                payload["latest_seq"] = tail_meta.get("latest_seq")
+                payload["after_seq"] = tail_meta.get("after_seq")
+                payload["before_seq"] = tail_meta.get("before_seq")
+                payload["order"] = normalized_order
+                return payload
             return service.build_tool_result(
                 context,
                 session=session,
@@ -723,7 +772,10 @@ def build_bash_exec_server(context: McpContext) -> FastMCP:
                 bash_id,
                 reason=reason,
                 user_id=f"agent:{context.agent_role or 'pi'}",
+                force=force,
             )
+            if wait:
+                session = service.wait_for_session(quest_root, bash_id, timeout_seconds=timeout_seconds)
             return service.build_tool_result(context, session=session, include_log=False)
         if normalized_mode == "await" and not command:
             bash_id = service.resolve_session_id(quest_root, id)
@@ -744,6 +796,7 @@ def build_bash_exec_server(context: McpContext) -> FastMCP:
             workdir=workdir,
             env=env,
             timeout_seconds=timeout_seconds,
+            comment=comment,
         )
         if normalized_mode == "detach":
             return service.build_tool_result(context, session=session, include_log=False)

package/src/deepscientist/migration.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import os
+import shutil
+import uuid
+from pathlib import Path
+from typing import Any
+
+
+HOME_SIGNATURES = (
+    "runtime",
+    "config",
+    "memory",
+    "quests",
+    "plugins",
+    "logs",
+    "cache",
+    "cli",
+)
+
+
+def looks_like_deepscientist_root(path: Path) -> bool:
+    if not path.exists() or not path.is_dir():
+        return False
+    if (path / "cli" / "bin" / "ds.js").exists():
+        return True
+    return any((path / name).exists() for name in HOME_SIGNATURES)
+
+
+def _is_relative_to(candidate: Path, other: Path) -> bool:
+    try:
+        candidate.relative_to(other)
+        return True
+    except ValueError:
+        return False
+
+
+def _collect_manifest(root: Path) -> dict[str, Any]:
+    manifest: dict[str, Any] = {}
+    file_count = 0
+    dir_count = 0
+    symlink_count = 0
+    total_bytes = 0
+    stack = [Path("")]
+    while stack:
+        rel_root = stack.pop()
+        current_root = root / rel_root
+        for child in sorted(current_root.iterdir(), key=lambda item: item.name):
+            rel_path = (rel_root / child.name).as_posix()
+            if child.is_symlink():
+                manifest[rel_path] = {"kind": "symlink", "target": os.readlink(child)}
+                symlink_count += 1
+                continue
+            if child.is_dir():
+                manifest[rel_path] = {"kind": "dir"}
+                dir_count += 1
+                stack.append(rel_root / child.name)
+                continue
+            size = child.stat().st_size
+            manifest[rel_path] = {"kind": "file", "size": size}
+            file_count += 1
+            total_bytes += size
+    return {
+        "entries": manifest,
+        "stats": {
+            "file_count": file_count,
+            "dir_count": dir_count,
+            "symlink_count": symlink_count,
+            "total_bytes": total_bytes,
+            "entry_count": len(manifest),
+        },
+    }
+
+
+def migrate_deepscientist_root(source: Path, target: Path) -> dict[str, Any]:
+    source = source.expanduser().resolve()
+    target = target.expanduser().resolve()
+    if not source.exists():
+        raise ValueError(f"Source path does not exist: {source}")
+    if not source.is_dir():
+        raise ValueError(f"Source path is not a directory: {source}")
+    if not looks_like_deepscientist_root(source):
+        raise ValueError(f"Source path does not look like a DeepScientist home or install root: {source}")
+    if source == target:
+        raise ValueError("Source path and target path must be different.")
+    if _is_relative_to(target, source):
+        raise ValueError("Target path cannot be placed inside the current DeepScientist root.")
+    if _is_relative_to(source, target):
+        raise ValueError("Target path cannot be a parent of the current DeepScientist root.")
+    if target.exists():
+        raise ValueError(f"Target path already exists: {target}")
+    target.parent.mkdir(parents=True, exist_ok=True)
+
+    staging = target.parent / f".{target.name}.migrating-{uuid.uuid4().hex[:10]}"
+    if staging.exists():
+        shutil.rmtree(staging, ignore_errors=True)
+    try:
+        shutil.copytree(source, staging, symlinks=True, copy_function=shutil.copy2)
+        source_manifest = _collect_manifest(source)
+        staging_manifest = _collect_manifest(staging)
+        if source_manifest["entries"] != staging_manifest["entries"]:
+            raise ValueError("Copied tree validation failed: source and target contents do not match.")
+        staging.rename(target)
+        return {
+            "ok": True,
+            "source": str(source),
+            "target": str(target),
+            "staging": str(staging),
+            "stats": source_manifest["stats"],
+            "summary": "DeepScientist root copied and verified successfully.",
+        }
+    except Exception:
+        shutil.rmtree(staging, ignore_errors=True)
+        raise

package/src/deepscientist/network.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import os
+from urllib.parse import urlparse
+from urllib.request import ProxyHandler, Request, build_opener, urlopen as stdlib_urlopen
+
+from websockets.sync.client import connect as stdlib_websocket_connect
+
+_RUNTIME_PROXY_URL: str | None = None
+_NO_PROXY_OPENER = build_opener(ProxyHandler({}))
+_PROXY_OPENERS: dict[str, object] = {}
+
+
+def normalize_proxy_url(value: str | None) -> str | None:
+    text = str(value or "").strip()
+    return text or None
+
+
+def configure_runtime_proxy(proxy_url: str | None) -> str | None:
+    normalized = normalize_proxy_url(proxy_url)
+    global _RUNTIME_PROXY_URL
+    previous = _RUNTIME_PROXY_URL
+    _RUNTIME_PROXY_URL = normalized
+    if normalized is None:
+        if previous is not None:
+            for key in ("HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "all_proxy"):
+                if os.environ.get(key) == previous:
+                    os.environ.pop(key, None)
+        return None
+    for key in ("HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "all_proxy"):
+        os.environ[key] = normalized
+    # Keep local daemon traffic and loopback websocket attaches off the proxy path.
+    for key in ("NO_PROXY", "no_proxy"):
+        current = str(os.environ.get(key) or "").strip()
+        values = [item.strip() for item in current.split(",") if item.strip()]
+        for host in ("127.0.0.1", "localhost", "::1", "0.0.0.0"):
+            if host not in values:
+                values.append(host)
+        os.environ[key] = ",".join(values)
+    return normalized
+
+
+def runtime_proxy_url() -> str | None:
+    return _RUNTIME_PROXY_URL
+
+
+def should_bypass_proxy(url: str) -> bool:
+    parsed = urlparse(str(url or "").strip())
+    host = (parsed.hostname or "").strip().lower()
+    return host in {"", "127.0.0.1", "localhost", "::1", "0.0.0.0"}
+
+
+def _proxy_opener(proxy_url: str):
+    opener = _PROXY_OPENERS.get(proxy_url)
+    if opener is None:
+        opener = build_opener(ProxyHandler({"http": proxy_url, "https": proxy_url}))
+        _PROXY_OPENERS[proxy_url] = opener
+    return opener
+
+
+def urlopen_with_proxy(request: Request | str, timeout: float | None = None):
+    url = request.full_url if isinstance(request, Request) else str(request)
+    if should_bypass_proxy(url):
+        return _NO_PROXY_OPENER.open(request, timeout=timeout)
+    proxy_url = runtime_proxy_url()
+    if proxy_url:
+        return _proxy_opener(proxy_url).open(request, timeout=timeout)
+    return stdlib_urlopen(request, timeout=timeout)
+
+
+def websocket_connect_with_proxy(uri: str, /, **kwargs):
+    if should_bypass_proxy(uri):
+        kwargs.setdefault("proxy", None)
+    else:
+        proxy_url = runtime_proxy_url()
+        if proxy_url:
+            kwargs.setdefault("proxy", proxy_url)
+    return stdlib_websocket_connect(uri, **kwargs)

package/src/deepscientist/prompts/builder.py

@@ -87,10 +87,10 @@ class PromptBuilder:
     ) -> str:
         snapshot = self.quest_service.snapshot(quest_id)
         runtime_config = self.config_manager.load_named("config")
-        connectors_config = self.config_manager.load_named("connectors")
+        connectors_config = self.config_manager.load_named_normalized("connectors")
         quest_root = Path(snapshot["quest_root"])
         active_anchor = str(snapshot.get("active_anchor") or skill_id)
-        default_locale = str(runtime_config.get("default_locale") or "zh-CN")
+        default_locale = str(runtime_config.get("default_locale") or "en-US")
         system_block = self._prompt_fragment("src/prompts/system.md")
         connector_contract_block = self._connector_contract_block(quest_id=quest_id, snapshot=snapshot)
         sections = [
@@ -260,6 +260,11 @@ class PromptBuilder:
                     "- qq_surface_rule: QQ is a milestone-report surface, not a full artifact browser.",
                     "- qq_default_mode: keep outbound replies concise, respectful, text-first, and progress-aware.",
                     "- qq_detail_rule: do not proactively dump file inventories, path lists, or low-level file details unless the user explicitly asked for them.",
+                    "- qq_length_rule: for ordinary QQ progress replies, normally use only 2 to 4 short sentences, or 3 very short bullets at most.",
+                    "- qq_summary_first_rule: start with the user-facing conclusion, then the immediate meaning, then the next action; do not make the user reverse-engineer the status from telemetry.",
+                    "- qq_internal_signal_rule: omit worker names, heartbeat timestamps, retry counters, pending/running/completed counts, file names, and monitor-window narration unless that detail is necessary for a user decision or to explain a real risk.",
+                    "- qq_translation_rule: translate internal actions into user value, for example say that you organized the baseline record for easier comparison later instead of listing the files you touched.",
+                    "- qq_eta_rule: for baseline reproduction, main experiments, analysis experiments, and other important long-running research phases, include a rough ETA for the next meaningful result, next step, or next update; if the runtime is uncertain, say that directly and still give the next check-in window.",
                     f"- qq_auto_send_main_experiment_png: {bool(qq_config.get('auto_send_main_experiment_png', True))}",
                     f"- qq_auto_send_analysis_summary_png: {bool(qq_config.get('auto_send_analysis_summary_png', True))}",
                     f"- qq_auto_send_slice_png: {bool(qq_config.get('auto_send_slice_png', False))}",
@@ -387,6 +392,14 @@ class PromptBuilder:
                     "- must_continue_rule: unless there is a real blocking user decision, keep advancing the quest automatically from durable state",
                 ]
             )
+        bash_running_count = int(((snapshot.get("counts") or {}).get("bash_running_count")) or 0)
+        if bash_running_count > 0:
+            lines.extend(
+                [
+                    f"- active_bash_run_count: {bash_running_count}",
+                    "- long_run_watchdog_rule: while an important long-running bash_exec session is active, never let more than 30 minutes pass without inspecting real logs/status and sending a concise artifact.interact progress update if the run is still ongoing",
+                ]
+            )
         if str(turn_reason or "").strip() == "auto_continue":
             lines.append(
                 "- auto_continue_rule: this turn has no new user message; continue from the active requirements, durable artifacts, and current quest state instead of replaying the previous user message"
@@ -733,8 +746,16 @@ class PromptBuilder:
             "- interaction_protocol: first message may be plain conversation; after that, treat artifact.interact threads and mailbox polls as the main continuity spine across TUI, web, and connectors",
             "- mailbox_protocol: artifact.interact(include_recent_inbound_messages=True) is the queued human-message mailbox; when it returns user text, treat that input as higher priority than background subtasks until it has been acknowledged",
             "- acknowledgment_protocol: after artifact.interact returns any human message, immediately call artifact.interact(...) again to confirm receipt; if answerable, answer directly, otherwise state the short plan, nearest checkpoint, and that the current background subtask is paused",
-            "- progress_protocol: emit artifact.interact(kind='progress', reply_mode='threaded', ...) only at real human-meaningful checkpoints, after the first meaningful signal from long-running work, and then only occasional keepalives during truly long work, usually about every 20 to 30 minutes",
-            "- long_run_reporting_protocol: for long-running bash_exec monitoring loops, report after each completed sleep/await cycle with real evidence plus the next planned check time and estimated next reply time",
+            "- progress_protocol: emit artifact.interact(kind='progress', reply_mode='threaded', ...) at real human-meaningful checkpoints; if no natural checkpoint appears during active user-relevant work, send a concise keepalive before you drift beyond roughly 10 to 30 tool calls without a user-visible update",
+            "- smoke_then_detach_protocol: for baseline reproduction, main experiments, and analysis experiments, first validate the command path with a bounded smoke test; once the smoke test passes, launch the real long run with bash_exec(mode='detach', ...) and usually leave timeout_seconds unset rather than guessing a fake deadline",
+            "- progress_first_monitoring_protocol: when supervising a long-running bash_exec session, judge health by forward progress rather than by whether the final artifact has already appeared within a short window",
+            "- delta_monitoring_protocol: compare deltas such as new sample counters, new task counters, new saved files, new last_output_seq values, or changed last_progress payloads; if any of these move forward, treat the run as alive and keep observing",
+            "- long_run_reporting_protocol: for long-running bash_exec monitoring loops, inspect real logs or status after each completed sleep/await cycle and at least once every 30 minutes at worst, but only send a user-visible update when there is a human-meaningful delta or when the 30-minute visibility bound would otherwise be exceeded",
+            "- long_run_watchdog_protocol: for baseline reproduction, baseline-running stages, main experiments, and other important detached runs, do not let more than 30 minutes pass without a real progress inspection and, if the run is still active, a user-visible artifact.interact progress update",
+            "- intervention_threshold_protocol: do not kill or restart a run merely because a short watch window passed without final completion; intervene only on explicit failure, clear invalidity, process exit, or no meaningful delta across a sufficiently long observation window",
+            "- slow_model_patience_protocol: if the user says the model, endpoint, or workload is expected to be slow, widen the observation window before intervention and avoid repeated no-change updates",
+            "- tail_monitoring_protocol: when monitoring a detached run, prefer bash_exec(mode='read', id=..., tail_limit=..., order='desc') so you inspect the newest evidence first instead of re-reading full logs every time",
+            "- managed_recovery_protocol: if a detached baseline, main-experiment, or analysis run is clearly invalid, wedged, or superseded, stop it with bash_exec(mode='kill', id=...), document the reason, fix the issue, and relaunch cleanly instead of letting a bad run linger",
             "- timeout_protocol: before using bash_exec(mode='await', ...), estimate whether the command can finish within the selected wait window; if runtime is uncertain or likely longer, use bash_exec(mode='detach', ...) and monitor, or set timeout_seconds intentionally",
             "- blocking_protocol: use reply_mode='blocking' only for true unresolved user decisions; ordinary progress updates should stay threaded and non-blocking",
             "- credential_blocking_protocol: if continuation requires user-supplied external credentials or secrets such as an API key, GitHub key/token, or Hugging Face key/token, emit one structured blocking decision request that asks the user to provide the credential or choose an alternative route; do not invent placeholders or silently skip the blocked step",
@@ -743,6 +764,31 @@ class PromptBuilder:
             "- stop_notice_protocol: if work must pause or stop, send a user-visible notice that explains why, confirms preserved context, and states that any new message or `/resume` will continue from the same quest",
             "- respect_protocol: write user-facing updates as natural, respectful, easy-to-follow chat; do not sound like a formal status report or internal tool log",
             "- omission_protocol: for ordinary user-facing updates, omit file paths, artifact ids, branch/worktree ids, session ids, raw commands, raw logs, and internal tool names unless the user asked for them or needs them to act",
+            "- compaction_protocol: ordinary artifact.interact progress updates should usually fit in 2 to 4 short sentences and should not read like a monitoring transcript or execution diary",
+            "- tool_call_keepalive_protocol: for active multi-step work outside long detached experiment waits, if you have spent roughly 10 to 30 tool calls without a user-visible checkpoint, send one concise artifact.interact progress update before continuing",
+            "- human_progress_shape_protocol: ordinary progress updates should usually make three things explicit in human language: the current task, the main difficulty or latest real progress, and the concrete next measure you will take",
+            "- eta_visibility_protocol: for baseline reproduction, main experiments, analysis experiments, and other important long-running phases, progress updates should also make the expected time to the next meaningful result, next milestone, or next user-visible update explicit; use roughly 10 to 30 minutes as the normal update window, and if the ETA is unreliable, say that and give a realistic next check-in window instead",
+            "- idea_milestone_protocol: immediately after a successful accepted artifact.submit_idea(...), send a threaded milestone that explains the idea in plain language and explicitly states whether it currently looks valid, research-worthy, and insight-bearing, plus the main risk and exact next experiment",
+            "- idea_divergence_protocol: in the idea stage, separate divergence from convergence; unless strong durable evidence already narrows the route to one obvious serious option, do not collapse onto the first plausible route before generating a small but meaningfully diverse candidate slate",
+            "- idea_lens_protocol: when idea candidates cluster around one mechanism family, deliberately switch ideation lenses such as problem-first vs solution-first, tension hunting, analogy transfer, inversion, or adjacent-possible reasoning before final selection",
+            "- idea_frontier_protocol: a temporary raw ideation slate may be larger, but after convergence the serious frontier should usually shrink back to 2 to 3 candidates and at most 5",
+            "- idea_why_now_protocol: every serious idea candidate should answer why now or what changed, not just what the mechanism is",
+            "- idea_balance_protocol: when the search space is not tiny, carry at least one conservative route and one higher-upside route into the final comparison",
+            "- idea_pitch_protocol: before artifact.submit_idea(...), make the winner pass a two-sentence pitch, a strongest-objection check, and a concrete why-now statement",
+            "- experiment_milestone_protocol: immediately after artifact.record_main_experiment(...) writes the durable result, send a threaded milestone that explains what was run, the main result, whether primary performance improved / worsened / stayed mixed versus the active baseline or best prior anchor, whether the route still looks promising, and the exact next step",
+            "- asset_grounded_analysis_protocol: before artifact.create_analysis_campaign(...), reuse current quest and user-provided assets first and only plan slices that are executable with the current assets, runtime/tooling, and available credentials",
+            "- infeasible_slice_protocol: if an analysis slice cannot actually be executed after bounded recovery, do not fake completion; record the slice with a non-success status, report the blocker explicitly, and do not pretend the system can do it",
+            "- explicit_improvement_protocol: never make the user infer performance improvement only from raw metrics; say plainly whether performance improved, worsened, or stayed mixed",
+            "- verified_reference_breadth_protocol: for paper-like writing, run broad literature search and reading, aim for roughly 30 to 50 verified references unless scope clearly justifies fewer, use one consistent citation workflow SEARCH -> VERIFY -> RETRIEVE -> VALIDATE -> ADD, use Semantic Scholar by default or Google Scholar manual search/export for discovery, use DOI/Crossref or other real metadata backfills for BibTeX and verification, Every final citation must correspond to a real paper from an actual source, store actual bibliography entries in paper/references.bib as valid BibTeX, do one explicit reference audit before bundling, and never invent citations from memory or hand-write BibTeX from scratch",
+            "- narrative_focus_protocol: for paper-like writing, organize the paper around one cohesive contribution, make What / Why / So What clear early, assume many readers judge in the order title -> abstract -> introduction -> figures, front-load value in those surfaces, use a five-part abstract formula, keep the introduction concise with 2 to 4 specific contribution bullets, and if the first sentence could be pasted into many unrelated ML papers then rewrite it until it becomes specific",
+            "- writing_reasoning_externalization_protocol: for paper-like writing, externalize major reasoning into durable notes such as paper/outline_selection.md, paper/claim_evidence_map.json, paper/related_work_map.md, paper/figure_storyboard.md, and paper/reviewer_first_pass.md; those notes should summarize current judgment, alternatives considered, evidence used, risks, and next revision action rather than hidden chain-of-thought",
+            "- outline_intro_value_protocol: for outlines and introductions, make research value explicit early and use a standard introduction arc: problem and stakes -> concrete gap/bottleneck -> remedy/core idea -> evidence preview -> contributions",
+            "- teammate_voice_protocol: write like a calm capable teammate using natural first-person phrasing when helpful, for example 'I'm working on ...', 'The main issue right now is ...', 'Next I'll ...'; do not sound like a dashboard or incident log",
+            "- tqdm_progress_protocol: when you control the experiment code for baseline reproduction, main experiments, or analysis experiments, instrument long loops with a throttled tqdm-style progress reporter when feasible and also prefer periodic __DS_PROGRESS__ JSON markers so monitoring stays both human-readable and machine-usable",
+            "- translation_protocol: convert internal actions into user-facing meaning; describe what was finished and why it matters instead of naming every touched file, counter, timestamp, or subprocess",
+            "- detail_gate_protocol: include exact counters, worker labels, timestamps, retry counts, or file names only when the user explicitly asked for them, when they change the recommended action, or when they are the only honest way to explain a real blocker",
+            "- monitoring_summary_protocol: for long-running monitoring loops, summarize the frontier state in plain language such as still progressing, temporarily stalled, recovered, or needs intervention; do not narrate each watch window and do not send a no-change update merely because a sleep finished unless the user-visible timing bound requires it",
+            "- preflight_rewrite_protocol: before sending artifact.interact, quickly self-check whether the draft reads like a monitoring log, file inventory, or internal diary; if it mentions watch windows, heartbeats, retry counters, raw counts, timestamps, or multiple file names without being necessary for user action, rewrite it into conclusion -> meaning -> next step first",
             "- non_research_mode_protocol: if the user message looks like a non-research request, ask for a second confirmation before engaging stage skills or research workflow; after completion, leave one blocking standby interaction instead of repeatedly pinging",
             "- workspace_discipline: read and modify code inside current_workspace_root; treat quest_root as the canonical repo identity and durable runtime root",
             "- binary_safety: do not open or rewrite large binary assets unless truly necessary; prefer summaries, metadata, and targeted inspection first",

package/src/deepscientist/qq_profiles.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+
+from .shared import slugify
+
+
+QQ_PROFILE_ID_PREFIX = "qq-profile"
+QQ_DEFAULT_SECRET_ENV = "QQ_APP_SECRET"
+
+
+def default_qq_profile() -> dict[str, Any]:
+    return {
+        "profile_id": None,
+        "enabled": True,
+        "app_id": None,
+        "app_secret": None,
+        "app_secret_env": QQ_DEFAULT_SECRET_ENV,
+        "bot_name": "DeepScientist",
+        "main_chat_id": None,
+    }
+
+
+def _as_text(value: Any) -> str | None:
+    text = str(value or "").strip()
+    return text or None
+
+
+def _profile_id_seed(*, profile_id: Any, app_id: Any, bot_name: Any, index: int) -> str:
+    explicit = _as_text(profile_id)
+    if explicit:
+        return explicit
+    app_text = _as_text(app_id)
+    if app_text:
+        return f"qq-{app_text}"
+    bot_text = slugify(str(bot_name or "").strip(), default="")
+    if bot_text:
+        return f"{QQ_PROFILE_ID_PREFIX}-{bot_text}"
+    return f"{QQ_PROFILE_ID_PREFIX}-{index:03d}"
+
+
+def _unique_profile_id(seed: str, *, used: set[str]) -> str:
+    base = slugify(seed, default=QQ_PROFILE_ID_PREFIX)
+    candidate = base
+    suffix = 2
+    while candidate in used:
+        candidate = f"{base}-{suffix}"
+        suffix += 1
+    used.add(candidate)
+    return candidate
+
+
+def list_qq_profiles(config: dict[str, Any] | None) -> list[dict[str, Any]]:
+    normalized = normalize_qq_connector_config(config)
+    profiles = normalized.get("profiles")
+    return [dict(item) for item in profiles] if isinstance(profiles, list) else []
+
+
+def find_qq_profile(
+    config: dict[str, Any] | None,
+    *,
+    profile_id: str | None = None,
+    app_id: str | None = None,
+) -> dict[str, Any] | None:
+    normalized_profile_id = _as_text(profile_id)
+    normalized_app_id = _as_text(app_id)
+    for profile in list_qq_profiles(config):
+        if normalized_profile_id and str(profile.get("profile_id") or "").strip() == normalized_profile_id:
+            return profile
+        if normalized_app_id and str(profile.get("app_id") or "").strip() == normalized_app_id:
+            return profile
+    return None
+
+
+def merge_qq_profile_config(shared_config: dict[str, Any] | None, profile: dict[str, Any]) -> dict[str, Any]:
+    normalized = normalize_qq_connector_config(shared_config)
+    merged = deepcopy(normalized)
+    merged.pop("profiles", None)
+    merged.update(
+        {
+            "profile_id": str(profile.get("profile_id") or "").strip() or None,
+            "app_id": _as_text(profile.get("app_id")),
+            "app_secret": _as_text(profile.get("app_secret")),
+            "app_secret_env": _as_text(profile.get("app_secret_env")) or QQ_DEFAULT_SECRET_ENV,
+            "bot_name": _as_text(profile.get("bot_name")) or str(normalized.get("bot_name") or "DeepScientist"),
+            "main_chat_id": _as_text(profile.get("main_chat_id")),
+            "enabled": bool(normalized.get("enabled", False)) and bool(profile.get("enabled", True)),
+            "transport": "gateway_direct",
+        }
+    )
+    return merged
+
+
+def qq_profile_label(profile: dict[str, Any] | None) -> str:
+    if not isinstance(profile, dict):
+        return "QQ"
+    bot_name = _as_text(profile.get("bot_name"))
+    app_id = _as_text(profile.get("app_id"))
+    if bot_name and app_id:
+        return f"{bot_name} · {app_id}"
+    if bot_name:
+        return bot_name
+    if app_id:
+        return f"QQ · {app_id}"
+    return "QQ"
+
+
+def normalize_qq_connector_config(config: dict[str, Any] | None) -> dict[str, Any]:
+    payload = deepcopy(config or {})
+    shared_defaults = {
+        "enabled": False,
+        "transport": "gateway_direct",
+        "app_id": None,
+        "app_secret": None,
+        "app_secret_env": QQ_DEFAULT_SECRET_ENV,
+        "bot_name": "DeepScientist",
+        "command_prefix": "/",
+        "main_chat_id": None,
+        "require_at_in_groups": True,
+        "auto_bind_dm_to_active_quest": True,
+        "gateway_restart_on_config_change": True,
+        "auto_send_main_experiment_png": True,
+        "auto_send_analysis_summary_png": True,
+        "auto_send_slice_png": True,
+        "auto_send_paper_pdf": True,
+        "enable_markdown_send": False,
+        "enable_file_upload_experimental": False,
+        "profiles": [],
+    }
+    shared = {**shared_defaults, **payload}
+    shared["transport"] = "gateway_direct"
+    shared["command_prefix"] = _as_text(shared.get("command_prefix")) or "/"
+    shared["bot_name"] = _as_text(shared.get("bot_name")) or "DeepScientist"
+    shared["app_secret_env"] = _as_text(shared.get("app_secret_env")) or QQ_DEFAULT_SECRET_ENV
+
+    raw_profiles = payload.get("profiles")
+    items = list(raw_profiles) if isinstance(raw_profiles, list) else []
+    legacy_profile_seed = {
+        "app_id": payload.get("app_id"),
+        "app_secret": payload.get("app_secret"),
+        "app_secret_env": payload.get("app_secret_env"),
+        "bot_name": payload.get("bot_name"),
+        "main_chat_id": payload.get("main_chat_id"),
+    }
+    if not items:
+        if any(_as_text(legacy_profile_seed.get(key)) for key in ("app_id", "app_secret", "main_chat_id", "bot_name")):
+            items = [legacy_profile_seed]
+
+    profiles: list[dict[str, Any]] = []
+    used_ids: set[str] = set()
+    for index, raw in enumerate(items, start=1):
+        if not isinstance(raw, dict):
+            continue
+        current = {**default_qq_profile(), **raw}
+        current["enabled"] = bool(current.get("enabled", True))
+        current["app_id"] = _as_text(current.get("app_id"))
+        current["app_secret"] = _as_text(current.get("app_secret"))
+        current["app_secret_env"] = _as_text(current.get("app_secret_env")) or shared["app_secret_env"]
+        current["bot_name"] = _as_text(current.get("bot_name")) or shared["bot_name"]
+        current["main_chat_id"] = _as_text(current.get("main_chat_id"))
+        current["profile_id"] = _unique_profile_id(
+            _profile_id_seed(
+                profile_id=current.get("profile_id"),
+                app_id=current.get("app_id"),
+                bot_name=current.get("bot_name"),
+                index=index,
+            ),
+            used=used_ids,
+        )
+        profiles.append(current)
+
+    shared["profiles"] = profiles
+    if len(profiles) == 1:
+        mirror = profiles[0]
+        shared["app_id"] = mirror.get("app_id")
+        shared["app_secret"] = mirror.get("app_secret")
+        shared["app_secret_env"] = mirror.get("app_secret_env")
+        shared["bot_name"] = mirror.get("bot_name")
+        shared["main_chat_id"] = mirror.get("main_chat_id")
+    else:
+        shared["app_id"] = None
+        shared["app_secret"] = None
+        shared["main_chat_id"] = None
+
+    return shared

package/src/deepscientist/quest/service.py

@@ -74,7 +74,7 @@ class QuestService:
                     if value:
                         return value.lower()
         config = ConfigManager(self.home).load_named("config")
-        return str(config.get("default_locale") or "zh-CN").lower()
+        return str(config.get("default_locale") or "en-US").lower()
 
     def localized_copy(self, *, zh: str, en: str, quest_root: Path | None = None) -> str:
         return zh if self.preferred_locale(quest_root).startswith("zh") else en