@researai/deepscientist 1.5.2 → 1.5.3

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/prompts/builder.py

@@ -87,7 +87,7 @@ 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")
@@ -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,12 @@ 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",
+            "- 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, then report real evidence plus the next planned check time and estimated next reply time",
+            "- 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",
+            "- 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 +760,16 @@ 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",
+            "- 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 unless the boundary itself matters",
+            "- 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/prompts/connectors/qq.md

@@ -4,6 +4,14 @@
 - connector_contract_scope: loaded only when QQ is the active or bound external connector for this quest
 - connector_contract_goal: use `artifact.interact(...)` as the main durable user-visible thread on QQ instead of exposing raw internal runner or tool chatter
 - qq_reply_style: keep QQ replies concise, milestone-first, respectful, and easy to scan on a phone
+- qq_reply_length_rule: for ordinary QQ progress updates, normally use only 2 to 4 short sentences, or 3 short bullets at most
+- qq_summary_first_rule: start with the conclusion the user cares about, then what it means, then the next action
+- qq_progress_shape_rule: make the current task, the main difficulty or latest real progress, and the next concrete measure explicit whenever possible
+- 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 or the next update; if uncertain, say that and still give the next check-in window
+- qq_tool_call_keepalive_rule: for ordinary active work, if roughly 10 to 30 tool calls pass without a user-visible checkpoint, send one concise QQ progress update before continuing
+- qq_internal_detail_rule: omit worker names, heartbeat timestamps, retry counters, pending/running/completed counts, file names, and monitor-window narration unless the user asked for them or the detail changes the recommended action
+- qq_translation_rule: convert internal execution and file-management work into user value, such as saying the baseline record is now organized for easier later comparison instead of listing touched files
+- qq_preflight_rule: before sending a QQ progress update, rewrite it if it still sounds like a monitoring log, execution diary, or file inventory
 - qq_operator_surface_rule: treat QQ as an operator surface for coordination and milestone delivery, not as a full artifact browser
 - qq_default_text_rule: plain text is the default and safest QQ mode
 - qq_absolute_path_rule: when you request native QQ image or file delivery via an attachment `path`, prefer an absolute path
@@ -39,12 +47,44 @@
 
 ## Examples
 
+### 0. Bad vs good QQ progress update
+
+Bad:
+
+```text
+我刚结束新的 60 秒监控窗，当前还是 15 pending / 2 running / 3 completed。local-gptoss + tare + GSM8K_DSPy 的 heartbeat 已推进到 00:07:10 UTC，local-qwen + atare + BBH_tracking_shuffled_objects_five_objects 也推进到 00:06:38 UTC。我已经同步更新 status、summary、execution 和 inventory，接下来继续看下一段 120 秒恢复窗。
+```
+
+Why bad:
+
+- it forces the user to infer the conclusion from telemetry
+- it exposes internal counters, timestamps, worker labels, and file actions that usually do not help the user
+- it reads like a monitoring transcript, not like a collaborator update
+
+Good:
+
+```text
+公开 baseline 还在继续推进，暂时不需要额外修补。当前主要情况是整体在往前走，但其中一条线仍然更慢、更不稳定。接下来我会继续盯下一轮结果，预计 20 到 30 分钟内会有下一次关键判断；如果更早出现完成、再次卡住，或者需要干预，我会提前同步给您。
+```
+
+Why good:
+
+- it starts with the conclusion the user actually needs
+- it keeps the meaningful risk but removes unnecessary internal telemetry
+- it tells the user exactly what will happen next
+
+English-style reference shape:
+
+```text
+I'm working on {current task}. The main issue right now is {difficulty or risk}, but {latest real progress or current judgment}. Next I'll {concrete next measure}. You should hear from me again in about {ETA}, or sooner if {important condition} happens.
+```
+
 ### 1. Plain-text QQ progress update
 
 ```python
 artifact.interact(
     kind="progress",
-    message="主实验第一轮已经跑完，结果稳定。我正在继续做消融，下一次会同步关键变化。",
+    message="主实验第一轮已经跑完，结果目前比较稳定。接下来我会继续补消融，确认这个提升是不是稳得住。下一次我只同步关键变化给您。",
     reply_mode="threaded",
 )
 ```
@@ -56,7 +96,7 @@ Use the normal `artifact.interact(...)` call. When DeepScientist already knows t
 ```python
 artifact.interact(
     kind="progress",
-    message="我已经看完您刚才提到的那篇论文，正在整理它和当前 baseline 的核心差异，稍后给您一个更完整的结论。",
+    message="我已经看完您刚才提到的那篇论文，也确认了它和当前 baseline 的核心差异。接下来我会把真正影响路线选择的部分整理出来，再给您一个更完整的结论。",
     reply_mode="threaded",
 )
 ```