@researai/deepscientist 1.5.16 → 1.6.0

package/src/deepscientist/runtime_storage.py

@@ -0,0 +1,303 @@
+from __future__ import annotations
+
+import gzip
+import hashlib
+import json
+import os
+import re
+from datetime import UTC, datetime
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+from typing import Any
+
+
+EVENT_ID_RE = re.compile(rb'"event_id"\s*:\s*"([^"]+)"')
+TYPE_RE = re.compile(rb'"(?:type|event_type)"\s*:\s*"([^"]+)"')
+RUN_ID_RE = re.compile(rb'"run_id"\s*:\s*"([^"]+)"')
+TOOL_NAME_RE = re.compile(rb'"tool_name"\s*:\s*"([^"]+)"')
+TIMESTAMP_RE = re.compile(rb'"timestamp"\s*:\s*"([^"]+)"')
+SEQ_RE = re.compile(rb'"seq"\s*:\s*(\d+)')
+STREAM_RE = re.compile(rb'"stream"\s*:\s*"([^"]+)"')
+
+
+def _extract(pattern: re.Pattern[bytes], raw: bytes) -> str | None:
+    match = pattern.search(raw)
+    if match is None:
+        return None
+    try:
+        return match.group(1).decode("utf-8", errors="ignore").strip() or None
+    except Exception:
+        return None
+
+
+def _replace_file(path: Path, lines: list[bytes]) -> None:
+    with NamedTemporaryFile("wb", delete=False, dir=path.parent, prefix=f"{path.name}.", suffix=".tmp") as handle:
+        temp_path = Path(handle.name)
+        for line in lines:
+            handle.write(line)
+    temp_path.replace(path)
+
+
+def _backup_raw_line(backup_root: Path, *, file_rel: str, line_no: int, raw: bytes) -> Path:
+    digest = hashlib.sha256(raw).hexdigest()[:16]
+    safe_rel = file_rel.replace("/", "__")
+    backup_name = f"{safe_rel}__line_{line_no:06d}__{digest}.jsonl.gz"
+    backup_path = backup_root / backup_name
+    backup_path.parent.mkdir(parents=True, exist_ok=True)
+    with gzip.open(backup_path, "wb") as handle:
+        handle.write(raw)
+    return backup_path
+
+
+def _event_placeholder(raw: bytes, *, original_bytes: int, backup_ref: str, line_no: int) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "event_id": _extract(EVENT_ID_RE, raw) or f"evt-slim-{line_no}",
+        "type": _extract(TYPE_RE, raw) or "runner.tool_result",
+        "run_id": _extract(RUN_ID_RE, raw),
+        "tool_name": _extract(TOOL_NAME_RE, raw),
+        "status": "compacted",
+        "summary": f"Oversized quest event payload ({original_bytes} bytes) was compacted into a quest-local backup.",
+        "oversized_event": True,
+        "original_bytes": original_bytes,
+        "backup_ref": backup_ref,
+        "created_at": datetime.now(UTC).isoformat(),
+    }
+    return {key: value for key, value in payload.items() if value is not None}
+
+
+def _bash_log_placeholder(raw: bytes, *, original_bytes: int, backup_ref: str) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "seq": int(_extract(SEQ_RE, raw) or 0),
+        "stream": _extract(STREAM_RE, raw) or "stdout",
+        "timestamp": _extract(TIMESTAMP_RE, raw),
+        "line": f"[compacted oversized bash log entry: {original_bytes} bytes -> {backup_ref}]",
+        "oversized_payload": True,
+        "original_bytes": original_bytes,
+        "backup_ref": backup_ref,
+    }
+    return {key: value for key, value in payload.items() if value is not None}
+
+
+def _stdout_placeholder(raw: bytes, *, original_bytes: int, backup_ref: str) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "timestamp": _extract(TIMESTAMP_RE, raw),
+        "line": f"[compacted oversized stdout entry: {original_bytes} bytes -> {backup_ref}]",
+        "oversized_payload": True,
+        "original_bytes": original_bytes,
+        "backup_ref": backup_ref,
+    }
+    return {key: value for key, value in payload.items() if value is not None}
+
+
+def _codex_history_placeholder(raw: bytes, *, original_bytes: int, backup_ref: str) -> dict[str, Any]:
+    return {
+        "timestamp": _extract(TIMESTAMP_RE, raw),
+        "event": {
+            "type": "oversized_payload",
+            "summary": f"Oversized codex history entry ({original_bytes} bytes) was compacted into a quest-local backup.",
+            "backup_ref": backup_ref,
+            "original_bytes": original_bytes,
+        },
+    }
+
+
+def _placeholder_for(
+    path: Path,
+    raw: bytes,
+    *,
+    original_bytes: int,
+    backup_ref: str,
+    file_rel: str,
+    line_no: int,
+) -> dict[str, Any]:
+    normalized = file_rel.replace("\\", "/")
+    if normalized == ".ds/events.jsonl":
+        return _event_placeholder(raw, original_bytes=original_bytes, backup_ref=backup_ref, line_no=line_no)
+    if normalized.startswith(".ds/bash_exec/") and normalized.endswith("/log.jsonl"):
+        return _bash_log_placeholder(raw, original_bytes=original_bytes, backup_ref=backup_ref)
+    if normalized.startswith(".ds/runs/") and normalized.endswith("/stdout.jsonl"):
+        return _stdout_placeholder(raw, original_bytes=original_bytes, backup_ref=backup_ref)
+    if normalized.startswith(".ds/codex_history/") and normalized.endswith("/events.jsonl"):
+        return _codex_history_placeholder(raw, original_bytes=original_bytes, backup_ref=backup_ref)
+    return {
+        "oversized_payload": True,
+        "original_bytes": original_bytes,
+        "backup_ref": backup_ref,
+    }
+
+
+def _iter_jsonl_slim_targets(ds_root: Path) -> list[Path]:
+    files: list[Path] = []
+    direct_events = ds_root / "events.jsonl"
+    if direct_events.exists():
+        files.append(direct_events)
+    files.extend(sorted((ds_root / "bash_exec").glob("**/log.jsonl")))
+    files.extend(sorted((ds_root / "codex_history").glob("**/events.jsonl")))
+    files.extend(sorted((ds_root / "runs").glob("**/stdout.jsonl")))
+    return [path for path in files if path.is_file()]
+
+
+def slim_quest_jsonl(quest_root: Path, *, threshold_bytes: int) -> dict[str, Any]:
+    resolved_root = Path(quest_root).expanduser().resolve()
+    ds_root = resolved_root / ".ds"
+    timestamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%SZ")
+    backup_root = ds_root / "slim_backups" / timestamp
+    manifest: dict[str, Any] = {
+        "quest_root": str(resolved_root),
+        "threshold_bytes": threshold_bytes,
+        "backup_root": str(backup_root),
+        "processed_at": datetime.now(UTC).isoformat(),
+        "files": [],
+        "compacted_line_count": 0,
+        "compacted_bytes_total": 0,
+    }
+    if threshold_bytes <= 0 or not ds_root.exists():
+        return manifest
+
+    for path in _iter_jsonl_slim_targets(ds_root):
+        rel = path.relative_to(resolved_root).as_posix()
+        line_no = 0
+        compacted_lines = 0
+        compacted_bytes = 0
+        rewritten: list[bytes] = []
+        with path.open("rb") as handle:
+            for raw in handle:
+                line_no += 1
+                line_bytes = len(raw)
+                if line_bytes <= threshold_bytes:
+                    rewritten.append(raw)
+                    continue
+                backup_path = _backup_raw_line(backup_root, file_rel=rel, line_no=line_no, raw=raw)
+                backup_ref = backup_path.relative_to(resolved_root).as_posix()
+                placeholder = _placeholder_for(
+                    path,
+                    raw,
+                    original_bytes=line_bytes,
+                    backup_ref=backup_ref,
+                    file_rel=rel,
+                    line_no=line_no,
+                )
+                rewritten.append((json.dumps(placeholder, ensure_ascii=False) + "\n").encode("utf-8"))
+                compacted_lines += 1
+                compacted_bytes += line_bytes
+        if compacted_lines:
+            _replace_file(path, rewritten)
+            manifest["files"].append(
+                {
+                    "path": rel,
+                    "compacted_lines": compacted_lines,
+                    "compacted_bytes": compacted_bytes,
+                }
+            )
+            manifest["compacted_line_count"] += compacted_lines
+            manifest["compacted_bytes_total"] += compacted_bytes
+
+    if manifest["compacted_line_count"]:
+        backup_root.mkdir(parents=True, exist_ok=True)
+        manifest_path = backup_root / "manifest.json"
+        manifest["manifest_path"] = str(manifest_path)
+        manifest_path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return manifest
+
+
+def _sha256(path: Path, *, chunk_size: int = 1024 * 1024) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        while True:
+            chunk = handle.read(chunk_size)
+            if not chunk:
+                break
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _iter_dedupe_targets(worktrees_root: Path, *, min_bytes: int) -> list[Path]:
+    patterns = [
+        "**/.codex/sessions/**/*.jsonl",
+        "**/experiments/**/*.json",
+    ]
+    files: list[Path] = []
+    for pattern in patterns:
+        for path in worktrees_root.glob(pattern):
+            if not path.is_file():
+                continue
+            try:
+                if path.stat().st_size < min_bytes:
+                    continue
+            except OSError:
+                continue
+            files.append(path)
+    return sorted(files)
+
+
+def _replace_with_hardlink(target: Path, source: Path) -> None:
+    with NamedTemporaryFile("wb", delete=False, dir=target.parent, prefix=f"{target.name}.", suffix=".linktmp") as handle:
+        temp_path = Path(handle.name)
+    try:
+        temp_path.unlink(missing_ok=True)
+        os.link(source, temp_path)
+        temp_path.replace(target)
+    finally:
+        temp_path.unlink(missing_ok=True)
+
+
+def dedupe_worktree_files(quest_root: Path, *, min_bytes: int) -> dict[str, Any]:
+    resolved_root = Path(quest_root).expanduser().resolve()
+    worktrees_root = resolved_root / ".ds" / "worktrees"
+    manifest: dict[str, Any] = {
+        "quest_root": str(resolved_root),
+        "worktrees_root": str(worktrees_root),
+        "min_bytes": min_bytes,
+        "groups_examined": 0,
+        "files_relinked": 0,
+        "bytes_deduped": 0,
+        "groups": [],
+    }
+    if min_bytes <= 0 or not worktrees_root.exists():
+        return manifest
+
+    size_buckets: dict[int, list[Path]] = {}
+    for path in _iter_dedupe_targets(worktrees_root, min_bytes=min_bytes):
+        try:
+            size_buckets.setdefault(path.stat().st_size, []).append(path)
+        except OSError:
+            continue
+
+    for size, paths in sorted(size_buckets.items(), key=lambda item: -item[0]):
+        if len(paths) < 2:
+            continue
+        manifest["groups_examined"] += 1
+        hash_buckets: dict[str, list[Path]] = {}
+        for path in paths:
+            try:
+                hash_buckets.setdefault(_sha256(path), []).append(path)
+            except OSError:
+                continue
+        for digest, dupes in hash_buckets.items():
+            if len(dupes) < 2:
+                continue
+            canonical = dupes[0]
+            relinked: list[str] = []
+            for duplicate in dupes[1:]:
+                try:
+                    if canonical.stat().st_ino == duplicate.stat().st_ino:
+                        continue
+                except OSError:
+                    continue
+                _replace_with_hardlink(duplicate, canonical)
+                manifest["files_relinked"] += 1
+                manifest["bytes_deduped"] += size
+                relinked.append(str(duplicate.relative_to(resolved_root)))
+            if relinked:
+                manifest["groups"].append(
+                    {
+                        "sha256": digest,
+                        "size_bytes": size,
+                        "canonical": str(canonical.relative_to(resolved_root)),
+                        "relinked": relinked,
+                    }
+                )
+    return manifest
+
+
+__all__ = ["dedupe_worktree_files", "slim_quest_jsonl"]

package/src/deepscientist/shared.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
 from collections import deque
 import hashlib
 import json
@@ -13,6 +14,8 @@ from pathlib import Path
 from typing import Any, Iterator
 from uuid import uuid4
 
+from .process_control import process_session_popen_kwargs
+
 try:
     import yaml
 except ModuleNotFoundError as exc:  # pragma: no cover
@@ -33,6 +36,10 @@ def utc_now() -> str:
     return datetime.now(UTC).replace(microsecond=0).isoformat()
 
 
+_TEXT_SUBPROCESS_ENCODING = "utf-8"
+_TEXT_SUBPROCESS_ERRORS = "replace"
+
+
 def ensure_dir(path: Path) -> Path:
     path.mkdir(parents=True, exist_ok=True)
     return path
@@ -156,6 +163,28 @@ def resolve_within(root: Path, relative: str) -> Path:
     return candidate
 
 
+def utf8_text_subprocess_kwargs() -> dict[str, Any]:
+    return {
+        "text": True,
+        "encoding": _TEXT_SUBPROCESS_ENCODING,
+        "errors": _TEXT_SUBPROCESS_ERRORS,
+    }
+
+
+def ensure_utf8_subprocess_env(env: Mapping[str, object] | None = None) -> dict[str, str]:
+    resolved: dict[str, str] = {}
+    for key, value in (env or {}).items():
+        env_key = str(key or "").strip()
+        if not env_key or value is None:
+            continue
+        resolved[env_key] = str(value)
+    if not str(resolved.get("PYTHONIOENCODING") or "").strip():
+        resolved["PYTHONIOENCODING"] = _TEXT_SUBPROCESS_ENCODING
+    if not str(resolved.get("PYTHONUTF8") or "").strip():
+        resolved["PYTHONUTF8"] = "1"
+    return resolved
+
+
 def run_command(
     args: list[str],
     *,
@@ -166,8 +195,25 @@ def run_command(
         args,
         cwd=str(cwd) if cwd else None,
         check=check,
-        text=True,
         capture_output=True,
+        **utf8_text_subprocess_kwargs(),
+        **process_session_popen_kwargs(hide_window=True, new_process_group=False),
+    )
+
+
+def run_command_bytes(
+    args: list[str],
+    *,
+    cwd: Path | None = None,
+    check: bool = True,
+) -> subprocess.CompletedProcess[bytes]:
+    return subprocess.run(
+        args,
+        cwd=str(cwd) if cwd else None,
+        check=check,
+        text=False,
+        capture_output=True,
+        **process_session_popen_kwargs(hide_window=True, new_process_group=False),
     )
 
 
@@ -186,7 +232,7 @@ def _resolve_executable_reference(reference: str) -> str | None:
     return shutil.which(normalized)
 
 
-def _codex_repo_roots() -> list[Path]:
+def _runner_repo_roots() -> list[Path]:
     roots: list[Path] = []
     configured = str(os.environ.get("DEEPSCIENTIST_REPO_ROOT") or "").strip()
     if configured:
@@ -204,6 +250,32 @@ def _codex_repo_roots() -> list[Path]:
     return deduped
 
 
+def _runner_local_bin_names(runner_name: str) -> list[str]:
+    normalized = str(runner_name or "").strip().lower()
+    base_names = {
+        "codex": ["codex"],
+        "claude": ["claude"],
+        "kimi": ["kimi"],
+        "opencode": ["opencode"],
+    }.get(normalized, [normalized] if normalized else [])
+    if not sys.platform.startswith("win"):
+        return base_names
+    names: list[str] = []
+    for base_name in base_names:
+        names.extend([f"{base_name}.cmd", f"{base_name}.exe", base_name])
+    return names
+
+
+def _resolve_package_local_runner_binary(runner_name: str) -> str | None:
+    for root in _runner_repo_roots():
+        node_bin_root = root / "node_modules" / ".bin"
+        for name in _runner_local_bin_names(runner_name):
+            package_local = node_bin_root / name
+            if package_local.exists():
+                return str(package_local)
+    return None
+
+
 def resolve_runner_binary(binary: str, *, runner_name: str | None = None) -> str | None:
     normalized = str(binary or "").strip()
     if not normalized:
@@ -215,26 +287,18 @@ def resolve_runner_binary(binary: str, *, runner_name: str | None = None) -> str
         return resolved_reference
 
     normalized_runner = str(runner_name or candidate.name or normalized).strip().lower()
-    if normalized_runner != "codex":
-        return resolved_reference
-
-    for env_name in ("DEEPSCIENTIST_CODEX_BINARY", "DS_CODEX_BINARY"):
+    env_runner = normalized_runner.upper().replace("-", "_")
+    for env_name in (
+        f"DEEPSCIENTIST_{env_runner}_BINARY",
+        f"DS_{env_runner}_BINARY",
+    ):
         override = os.environ.get(env_name)
         if override:
             resolved_override = _resolve_executable_reference(override)
             if resolved_override:
                 return resolved_override
 
-    # Match the Codex installation the user already runs successfully in shell
-    # before falling back to the npm-bundled helper copy.
     if resolved_reference:
         return resolved_reference
 
-    names = ["codex.cmd", "codex.exe", "codex"] if sys.platform.startswith("win") else ["codex"]
-    for root in _codex_repo_roots():
-        node_bin_root = root / "node_modules" / ".bin"
-        for name in names:
-            package_local = node_bin_root / name
-            if package_local.exists():
-                return str(package_local)
-    return None
+    return _resolve_package_local_runner_binary(normalized_runner)

package/src/deepscientist/skills/installer.py

@@ -26,10 +26,16 @@ class SkillInstaller:
     def sync_global(self) -> dict:
         codex_root = ensure_dir(Path.home() / ".codex" / "skills")
         claude_root = ensure_dir(Path.home() / ".claude" / "agents")
+        kimi_root = ensure_dir(Path.home() / ".kimi" / "skills")
+        opencode_root = ensure_dir(Path.home() / ".config" / "opencode" / "skills")
         copied_codex: list[str] = []
         copied_claude: list[str] = []
+        copied_kimi: list[str] = []
+        copied_opencode: list[str] = []
         expected_codex: set[str] = set()
         expected_claude: set[str] = set()
+        expected_kimi: set[str] = set()
+        expected_opencode: set[str] = set()
         for bundle in self.discover():
             target = codex_root / f"deepscientist-{bundle.skill_id}"
             expected_codex.add(target.name)
@@ -38,11 +44,23 @@ class SkillInstaller:
             claude_target = self._sync_claude_projection(bundle, claude_root)
             expected_claude.add(claude_target.name)
             copied_claude.append(str(claude_target))
+            kimi_target = kimi_root / f"deepscientist-{bundle.skill_id}"
+            expected_kimi.add(kimi_target.name)
+            self._sync_bundle_tree(bundle.root, kimi_target)
+            copied_kimi.append(str(kimi_target))
+            opencode_target = opencode_root / f"deepscientist-{bundle.skill_id}"
+            expected_opencode.add(opencode_target.name)
+            self._sync_bundle_tree(bundle.root, opencode_target)
+            copied_opencode.append(str(opencode_target))
         self._prune_bundle_targets(codex_root, expected_codex)
         self._prune_bundle_targets(claude_root, expected_claude)
+        self._prune_bundle_targets(kimi_root, expected_kimi)
+        self._prune_bundle_targets(opencode_root, expected_opencode)
         return {
             "codex": copied_codex,
             "claude": copied_claude,
+            "kimi": copied_kimi,
+            "opencode": copied_opencode,
             "notes": [],
         }
 
@@ -51,10 +69,16 @@ class SkillInstaller:
         prompts_root = ensure_dir(quest_root / ".codex" / "prompts")
         codex_root = ensure_dir(quest_root / ".codex" / "skills")
         claude_root = ensure_dir(quest_root / ".claude" / "agents")
+        kimi_root = ensure_dir(quest_root / ".kimi" / "skills")
+        opencode_root = ensure_dir(quest_root / ".opencode" / "skills")
         copied_codex: list[str] = []
         copied_claude: list[str] = []
+        copied_kimi: list[str] = []
+        copied_opencode: list[str] = []
         expected_codex: set[str] = set()
         expected_claude: set[str] = set()
+        expected_kimi: set[str] = set()
+        expected_opencode: set[str] = set()
         for bundle in self.discover():
             target = codex_root / f"deepscientist-{bundle.skill_id}"
             expected_codex.add(target.name)
@@ -63,13 +87,25 @@ class SkillInstaller:
             claude_target = self._sync_claude_projection(bundle, claude_root)
             expected_claude.add(claude_target.name)
             copied_claude.append(str(claude_target))
+            kimi_target = kimi_root / f"deepscientist-{bundle.skill_id}"
+            expected_kimi.add(kimi_target.name)
+            self._sync_bundle_tree(bundle.root, kimi_target)
+            copied_kimi.append(str(kimi_target))
+            opencode_target = opencode_root / f"deepscientist-{bundle.skill_id}"
+            expected_opencode.add(opencode_target.name)
+            self._sync_bundle_tree(bundle.root, opencode_target)
+            copied_opencode.append(str(opencode_target))
         self._prune_bundle_targets(codex_root, expected_codex)
         self._prune_bundle_targets(claude_root, expected_claude)
+        self._prune_bundle_targets(kimi_root, expected_kimi)
+        self._prune_bundle_targets(opencode_root, expected_opencode)
         return {
             "prompts": [str(path) for path in sorted(prompts_root.rglob("*")) if path.is_file()],
             "prompt_sync": prompt_sync,
             "codex": copied_codex,
             "claude": copied_claude,
+            "kimi": copied_kimi,
+            "opencode": copied_opencode,
             "notes": [],
         }
 
@@ -93,6 +129,7 @@ class SkillInstaller:
                     "quest_root": str(quest_root),
                     "codex_count": len(result.get("codex") or []),
                     "claude_count": len(result.get("claude") or []),
+                    "kimi_count": len(result.get("kimi") or []),
                     "prompt_backup_id": (result.get("prompt_sync") or {}).get("backup_id"),
                     "prompt_fingerprint": (result.get("prompt_sync") or {}).get("prompt_fingerprint"),
                 }

package/src/deepscientist/skills/registry.py

@@ -19,6 +19,8 @@ _DEFAULT_STAGE_SKILLS = (
 )
 
 _DEFAULT_COMPANION_SKILLS = (
+    "paper-outline",
+    "paper-plot",
     "figure-polish",
     "intake-audit",
     "review",

package/src/deepscientist/tinytex.py

@@ -9,7 +9,7 @@ from typing import Any
 from urllib.error import URLError
 from urllib.request import Request, urlopen
 
-from .shared import which
+from .shared import utf8_text_subprocess_kwargs, which
 
 _TINYTEX_DOC_URL = "https://yihui.org/tinytex/"
 _TINYTEX_CHINESE_DOC_URL = "https://yihui.org/tinytex/cn/"
@@ -228,7 +228,7 @@ def install_tinytex(home: Path | None = None) -> dict[str, Any]:
 
     installer_path = Path(installer_path_or_error)
     try:
-        result = subprocess.run(command, capture_output=True, text=True, check=False)
+        result = subprocess.run(command, capture_output=True, check=False, **utf8_text_subprocess_kwargs())
     finally:
         installer_path.unlink(missing_ok=True)
     refreshed = inspect_latex_runtime(home)

package/src/deepscientist/tui.py

@@ -4,6 +4,8 @@ import json
 import time
 from urllib.request import urlopen
 
+_RECENT_EVENT_LIMIT = 12
+
 
 def _get_json(url: str):
     with urlopen(url) as response:  # noqa: S310
@@ -93,9 +95,14 @@ def render_tui(base_url: str, *, quest_id: str | None = None, cursor: int = 0) -
     feed_payload = {"cursor": cursor, "acp_updates": []}
     if active_quest_id:
         session_payload = _get_json(f"{base_url}/api/quests/{active_quest_id}/session")
-        feed_payload = _get_json(
-            f"{base_url}/api/quests/{active_quest_id}/events?after={cursor}&format=acp&session_id=quest:{active_quest_id}"
-        )
+        if cursor > 0:
+            feed_payload = _get_json(
+                f"{base_url}/api/quests/{active_quest_id}/events?after={cursor}&format=acp&session_id=quest:{active_quest_id}"
+            )
+        else:
+            feed_payload = _get_json(
+                f"{base_url}/api/quests/{active_quest_id}/events?format=acp&session_id=quest:{active_quest_id}&tail=1&limit={_RECENT_EVENT_LIMIT}"
+            )
 
     lines = [
         "DeepScientist TUI",

package/src/prompts/benchstore/system.md

@@ -0,0 +1,77 @@
+# BenchStore Setup Agent
+
+你是 DeepScientist 里的 `BenchStore Setup Agent`。
+
+你的工作不是直接开始完整科研流程。
+你的工作是先帮用户判断 benchmark 是否合适，并把 autonomous 启动前需要的信息整理好。
+
+## 先做什么
+
+优先基于现有上下文判断，不要一上来追问：
+
+1. 看 benchmark 信息
+2. 看当前设备
+3. 看本地安装状态
+4. 看已经生成的启动草案
+
+如果需要横向比较 benchmark，优先读取 BenchStore catalog。
+
+## 你要给出的核心判断
+
+用户最需要听懂的是这几件事：
+
+1. 这个 benchmark 适不适合当前机器
+2. 能不能直接启动
+3. 如果能启动，是建议保守一点还是可以直接正常跑
+4. 如果不适合，应该换哪一类 benchmark
+
+## 自动整理时优先填这些
+
+- 项目标题
+- 任务目标
+- 论文或参考链接
+- 运行限制
+- 近期目标
+- 本地 benchmark 路径
+
+缺失字段可以留空，但不要编造。
+
+## 说话方式
+
+- 默认跟随当前界面语言
+- 先说结论
+- 句子尽量短
+- 少黑话，少内部词
+- 像在帮用户整理启动事项，不像系统日志
+
+## 不要这样说
+
+不要对普通用户使用这些词：
+
+- route
+- taxonomy
+- claim boundary
+- stage
+- slice
+- trace
+- checkpoint
+- launch contract
+- startup packet
+
+## 更好的表达方式
+
+可以这样说：
+
+- “我已经先帮你整理出一版启动草案。”
+- “这个 benchmark 适合你当前这台机器，可以直接走全自动。”
+- “这台机器能跑，但我建议第一轮先保守一点。”
+- “如果你更想省资源，我建议换更轻一点的 benchmark。”
+
+## 完成标准
+
+你的目标不是多说，而是把用户带到一个清楚状态：
+
+- 适合不适合，一眼能看懂
+- 现在能不能启动，说清楚
+- 启动表单已经尽量补齐
+- 用户可以直接点 Start，或者明确知道还差什么