@researai/deepscientist 1.5.1 → 1.5.3

package/src/deepscientist/doctor.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
+import os
 import socket
+import subprocess
 import sys
 import tempfile
+from shutil import which
 from pathlib import Path
 from typing import Any
 from urllib.error import URLError
@@ -108,6 +111,69 @@ def _check_home_writable(home: Path) -> dict[str, Any]:
     )
 
 
+def _resolve_uv_binary(home: Path) -> str | None:
+    for env_name in ("DEEPSCIENTIST_UV", "UV_BIN"):
+        override = str(os.environ.get(env_name) or "").strip()
+        if not override:
+            continue
+        override_path = Path(override).expanduser()
+        if override_path.exists():
+            return str(override_path)
+        resolved_override = which(override)
+        if resolved_override:
+            return resolved_override
+
+    local_candidates = [
+        home / "runtime" / "tools" / "uv" / "bin" / "uv",
+        home / "runtime" / "tools" / "uv" / "bin" / "uv.exe",
+    ]
+    for candidate in local_candidates:
+        if candidate.exists():
+            return str(candidate)
+    return which("uv")
+
+
+def _check_uv(home: Path) -> dict[str, Any]:
+    resolved = _resolve_uv_binary(home)
+    if not resolved:
+        guidance = [
+            "Run `ds` once so DeepScientist can bootstrap a local uv runtime manager automatically.",
+        ]
+        if sys.platform == "win32":
+            guidance.append('PowerShell: `powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"`')
+        else:
+            guidance.append("macOS/Linux: `curl -LsSf https://astral.sh/uv/install.sh | sh`")
+        return _make_check(
+            check_id="uv",
+            label="uv runtime manager",
+            ok=False,
+            summary="uv is not available to DeepScientist.",
+            errors=["DeepScientist cannot provision or repair its local Python runtime without `uv`."],
+            guidance=guidance,
+        )
+
+    version = ""
+    try:
+        result = subprocess.run(
+            [resolved, "--version"],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            version = (result.stdout or result.stderr or "").strip()
+    except OSError:
+        version = ""
+
+    return _make_check(
+        check_id="uv",
+        label="uv runtime manager",
+        ok=True,
+        summary="uv is available for locked Python runtime management.",
+        details={"resolved_binary": resolved, "version": version or None},
+    )
+
+
 def _check_git(config_manager: ConfigManager) -> dict[str, Any]:
     readiness = config_manager.git_readiness()
     return _make_check(
@@ -195,10 +261,10 @@ def _check_codex(config_manager: ConfigManager) -> dict[str, Any]:
             check_id="codex",
             label="Codex CLI",
             ok=False,
-            summary="Codex CLI is not available on PATH.",
+            summary="Codex CLI is not available to DeepScientist.",
             errors=[f"Runner binary `{binary}` could not be resolved."],
             guidance=[
-                "Install Codex first: `npm install -g @openai/codex`.",
+                "Run `npm install -g @researai/deepscientist` again so the bundled Codex dependency is installed.",
                 "Then run `codex` once and complete login.",
             ],
             details={"binary": binary},
@@ -370,6 +436,7 @@ def run_doctor(home: Path, *, repo_root: Path) -> dict[str, Any]:
     checks = [
         _check_python_runtime(),
         _check_home_writable(home),
+        _check_uv(home),
         _check_git(config_manager),
         _check_config_validation(config_manager),
         _check_runner_support(config_manager),

package/src/deepscientist/gitops/diff.py

@@ -333,6 +333,9 @@ def _collect_branch_state(repo: Path) -> dict[str, dict[str, Any]]:
                 "baseline_ref": record.get("baseline_ref") or {},
                 "baseline_comparisons": record.get("baseline_comparisons") or {},
                 "progress_eval": record.get("progress_eval") or {},
+                "evaluation_summary": record.get("evaluation_summary")
+                or ((record.get("details") or {}) if isinstance(record.get("details"), dict) else {}).get("evaluation_summary")
+                or {},
                 "files_changed": record.get("files_changed") or [],
                 "evidence_paths": record.get("evidence_paths") or [],
                 "updated_at": record.get("updated_at"),

package/src/deepscientist/home.py

@@ -1,12 +1,34 @@
 from __future__ import annotations
 
+import os
 from pathlib import Path
 
 from .shared import ensure_dir
 
 
+def _looks_like_repo_root(path: Path) -> bool:
+    return (
+        (path / "pyproject.toml").exists()
+        and (path / "src" / "deepscientist").exists()
+        and (path / "src" / "skills").exists()
+    )
+
+
 def repo_root() -> Path:
-    return Path(__file__).resolve().parents[2]
+    configured = str(os.environ.get("DEEPSCIENTIST_REPO_ROOT") or "").strip()
+    if configured:
+        candidate = Path(configured).expanduser().resolve()
+        if _looks_like_repo_root(candidate):
+            return candidate
+
+    cwd = Path.cwd().resolve()
+    if _looks_like_repo_root(cwd):
+        return cwd
+
+    candidate = Path(__file__).resolve().parents[2]
+    if _looks_like_repo_root(candidate):
+        return candidate
+    return candidate
 
 
 def default_home() -> Path:
@@ -15,9 +37,10 @@ def default_home() -> Path:
 
 def ensure_home_layout(home: Path) -> dict[str, Path]:
     runtime = ensure_dir(home / "runtime")
-    ensure_dir(runtime / "venv")
     ensure_dir(runtime / "bundle")
     ensure_dir(runtime / "tools")
+    ensure_dir(runtime / "python")
+    ensure_dir(runtime / "uv-cache")
 
     config = ensure_dir(home / "config")
     ensure_dir(config / "baselines")

package/src/deepscientist/mcp/context.py

@@ -4,6 +4,8 @@ import os
 from dataclasses import dataclass
 from pathlib import Path
 
+from ..home import default_home
+
 
 @dataclass(frozen=True)
 class McpContext:
@@ -24,7 +26,7 @@ class McpContext:
             value = os.environ.get(name, "").strip()
             return Path(value).expanduser() if value else None
 
-        home = _path("DS_HOME") or (Path.home() / "DeepScientist")
+        home = _path("DEEPSCIENTIST_HOME") or _path("DS_HOME") or default_home()
         return cls(
             home=home,
             quest_id=os.environ.get("DS_QUEST_ID") or None,

package/src/deepscientist/mcp/server.py

@@ -307,6 +307,7 @@ def build_artifact_server(context: McpContext) -> FastMCP:
         status: str = "completed",
         baseline_id: str | None = None,
         baseline_variant_id: str | None = None,
+        evaluation_summary: dict[str, Any] | None = None,
         comment: str | dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         return service.record_main_experiment(
@@ -330,6 +331,7 @@ def build_artifact_server(context: McpContext) -> FastMCP:
             status=status,
             baseline_id=baseline_id,
             baseline_variant_id=baseline_variant_id,
+            evaluation_summary=evaluation_summary,
         )
 
     @server.tool(
@@ -462,6 +464,8 @@ def build_artifact_server(context: McpContext) -> FastMCP:
         next_recommendation: str | None = None,
         dataset_scope: str = "full",
         subset_approval_ref: str | None = None,
+        comparison_baselines: list[dict[str, Any]] | None = None,
+        evaluation_summary: dict[str, Any] | None = None,
         comment: str | dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         return service.record_analysis_slice(
@@ -481,6 +485,8 @@ def build_artifact_server(context: McpContext) -> FastMCP:
             next_recommendation=next_recommendation,
             dataset_scope=dataset_scope,
             subset_approval_ref=subset_approval_ref,
+            comparison_baselines=comparison_baselines,
+            evaluation_summary=evaluation_summary,
         )
 
     @server.tool(name="publish_baseline", description="Publish a quest baseline to the global baseline registry.")
@@ -655,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(
@@ -670,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,
@@ -717,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)
@@ -738,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,13 +746,30 @@ 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",
+            "- credential_wait_protocol: if that credential request remains unanswered, keep the quest waiting rather than self-resolving; if you are resumed without new credentials and no other work is possible, a long low-frequency park such as `bash_exec(command='sleep 3600', mode='await', timeout_seconds=3700)` is acceptable to avoid busy-looping",
             f"- standby_prefix_rule: when you intentionally leave one blocking standby interaction after task completion, prefix it with {'[等待决策]' if chinese_turn else '[Waiting for decision]'} and wait for a new user reply before continuing",
             "- 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",
@@ -913,6 +943,26 @@ class PromptBuilder:
                     "- active_baseline_metric_contract_rule: before planning or running `experiment` or `analysis-campaign`, read this JSON file and treat it as the canonical baseline comparison contract unless a newer confirmed baseline explicitly replaces it.",
                 ]
             )
+        analysis_baseline_inventory = read_json(quest_root / "artifacts" / "baselines" / "analysis_inventory.json", {})
+        analysis_baseline_inventory = analysis_baseline_inventory if isinstance(analysis_baseline_inventory, dict) else {}
+        analysis_inventory_entries = (
+            analysis_baseline_inventory.get("entries") if isinstance(analysis_baseline_inventory.get("entries"), list) else []
+        )
+        registered_count = sum(
+            1
+            for item in analysis_inventory_entries
+            if isinstance(item, dict) and str(item.get("status") or "").strip().lower() == "registered"
+        )
+        if analysis_inventory_entries:
+            lines.extend(
+                [
+                    f"- supplementary_baseline_inventory_status: artifacts/baselines/analysis_inventory.json [exists]",
+                    f"- supplementary_baseline_count: {len(analysis_inventory_entries)}",
+                    f"- supplementary_baseline_registered_count: {registered_count}",
+                ]
+            )
+        else:
+            lines.append("- supplementary_baseline_inventory_status: artifacts/baselines/analysis_inventory.json [missing]")
         lines.extend(["", "Active interactions:"])
         active_interactions = snapshot.get("active_interactions") or []
         if active_interactions:
@@ -1001,10 +1051,14 @@ class PromptBuilder:
         )
         bundle_manifest = read_json(paper_root / "paper_bundle_manifest.json", {})
         bundle_manifest = bundle_manifest if isinstance(bundle_manifest, dict) else {}
+        paper_baseline_inventory = read_json(paper_root / "baseline_inventory.json", {})
+        paper_baseline_inventory = paper_baseline_inventory if isinstance(paper_baseline_inventory, dict) else {}
         claim_evidence_map = read_json(paper_root / "claim_evidence_map.json", {})
         claim_evidence_map = claim_evidence_map if isinstance(claim_evidence_map, dict) else {}
         compile_report = read_json(paper_root / "build" / "compile_report.json", {})
         compile_report = compile_report if isinstance(compile_report, dict) else {}
+        open_source_manifest = read_json(quest_root / "release" / "open_source" / "manifest.json", {})
+        open_source_manifest = open_source_manifest if isinstance(open_source_manifest, dict) else {}
 
         selected_outline_ref = str(
             selected_outline.get("outline_id") or bundle_manifest.get("selected_outline_ref") or ""
@@ -1045,6 +1099,7 @@ class PromptBuilder:
                 f"- draft_status: {_path_status(bundle_manifest.get('draft_path'), fallback='paper/draft.md')}",
                 f"- references_status: {_path_status(bundle_manifest.get('references_path'), fallback='paper/references.bib')}",
                 f"- claim_evidence_map_status: {_path_status(bundle_manifest.get('claim_evidence_map_path'), fallback='paper/claim_evidence_map.json')}",
+                f"- baseline_inventory_status: {_path_status(bundle_manifest.get('baseline_inventory_path'), fallback='paper/baseline_inventory.json')}",
                 f"- review_status: {'paper/review/review.md [exists]' if (paper_root / 'review' / 'review.md').exists() else 'paper/review/review.md [missing]'}",
                 f"- proofing_report_status: {'paper/proofing/proofing_report.md [exists]' if (paper_root / 'proofing' / 'proofing_report.md').exists() else 'paper/proofing/proofing_report.md [missing]'}",
                 f"- page_images_manifest_status: {'paper/proofing/page_images_manifest.json [exists]' if (paper_root / 'proofing' / 'page_images_manifest.json').exists() else 'paper/proofing/page_images_manifest.json [missing]'}",
@@ -1061,6 +1116,8 @@ class PromptBuilder:
                     f"- bundle_pdf_status: {_path_status(pdf_rel_path, fallback='paper/paper.pdf')}",
                     f"- bundle_compile_report_status: {_path_status(compile_rel_path, fallback='paper/build/compile_report.json')}",
                     f"- bundle_latex_root: {latex_root_path or 'none'}",
+                    f"- open_source_manifest_status: {_path_status(bundle_manifest.get('open_source_manifest_path'), fallback='release/open_source/manifest.json')}",
+                    f"- open_source_cleanup_plan_status: {_path_status(bundle_manifest.get('open_source_cleanup_plan_path'), fallback='release/open_source/cleanup_plan.md')}",
                 ]
             )
         else:
@@ -1089,6 +1146,17 @@ class PromptBuilder:
 
         if compile_report:
             lines.append(f"- compile_report_ok: {compile_report.get('ok') if 'ok' in compile_report else 'unknown'}")
+        supplementary_baselines = (
+            paper_baseline_inventory.get("supplementary_baselines")
+            if isinstance(paper_baseline_inventory.get("supplementary_baselines"), list)
+            else []
+        )
+        if paper_baseline_inventory:
+            lines.append(f"- paper_supplementary_baseline_count: {len(supplementary_baselines)}")
+        if open_source_manifest:
+            lines.append(
+                f"- open_source_release_branch: {str(open_source_manifest.get('release_branch') or '').strip() or 'none'}"
+            )
 
         lines.extend(["", "Recent supporting runs:"])
         recent_runs = snapshot.get("recent_runs") or []