@researai/deepscientist 1.5.0 → 1.5.1

package/src/deepscientist/cli.py

@@ -14,12 +14,14 @@ from urllib.request import Request, urlopen
 from .artifact import ArtifactService
 from .config import ConfigManager
 from .daemon import DaemonApp
+from .doctor import render_doctor_report, run_doctor
 from .home import default_home, ensure_home_layout, repo_root
 from .memory import MemoryService
 from .prompts import PromptBuilder
 from .quest import QuestService
 from .registries import BaselineRegistry
 from .runners import CodexRunner, RunRequest, get_runner_factory, register_builtin_runners
+from .runtime_tools import RuntimeToolService
 from .runtime_logs import JsonlLogger
 from .shared import ensure_dir, read_yaml
 from .skills import SkillInstaller
@@ -76,8 +78,7 @@ def build_parser() -> argparse.ArgumentParser:
     graph_parser = subparsers.add_parser("graph")
     graph_parser.add_argument("quest_id")
 
-    metrics_parser = subparsers.add_parser("metrics")
-    metrics_parser.add_argument("target")
+    subparsers.add_parser("doctor", aliases=["docker"])
 
     push_parser = subparsers.add_parser("push")
     push_parser.add_argument("quest_id")
@@ -95,6 +96,11 @@ def build_parser() -> argparse.ArgumentParser:
     baseline_attach.add_argument("--baseline-id", required=True)
     baseline_attach.add_argument("--variant-id", default=None)
 
+    latex_parser = subparsers.add_parser("latex")
+    latex_subparsers = latex_parser.add_subparsers(dest="latex_command", required=True)
+    latex_subparsers.add_parser("status")
+    latex_subparsers.add_parser("install-runtime")
+
     config_parser = subparsers.add_parser("config")
     config_subparsers = config_parser.add_subparsers(dest="config_command", required=True)
     config_show = config_subparsers.add_parser("show")
@@ -355,27 +361,10 @@ def graph_command(home: Path, quest_id: str) -> int:
     return 0
 
 
-def metrics_command(home: Path, target: str) -> int:
-    if (home / "quests" / target / "quest.yaml").exists():
-        quest_root = home / "quests" / target
-        runs = sorted((quest_root / "artifacts" / "runs").glob("*.json"))
-        payload = []
-        from .shared import read_json
-
-        for path in runs:
-            item = read_json(path, {})
-            payload.append(
-                {
-                    "run_id": item.get("run_id"),
-                    "run_kind": item.get("run_kind"),
-                    "exit_code": item.get("exit_code"),
-                    "summary": item.get("summary"),
-                }
-            )
-        print(json.dumps(payload, ensure_ascii=False, indent=2))
-        return 0
-    print(json.dumps({"message": "Run-level metrics lookup is not implemented yet."}, ensure_ascii=False, indent=2))
-    return 0
+def doctor_command(home: Path) -> int:
+    report = run_doctor(home, repo_root=repo_root())
+    sys.stdout.write(render_doctor_report(report))
+    return 0 if report.get("ok") else 1
 
 
 def push_command(home: Path, quest_id: str) -> int:
@@ -415,6 +404,20 @@ def baseline_attach_command(home: Path, quest_id: str, baseline_id: str, variant
     return 0 if result.get("ok") else 1
 
 
+def latex_status_command(home: Path) -> int:
+    ensure_home_layout(home)
+    payload = RuntimeToolService(home).status("tinytex")
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    return 0 if payload.get("ok") else 1
+
+
+def latex_install_runtime_command(home: Path) -> int:
+    ensure_home_layout(home)
+    payload = RuntimeToolService(home).install("tinytex")
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    return 0 if payload.get("ok") else 1
+
+
 def config_show_command(home: Path, name: str) -> int:
     manager = ConfigManager(home)
     text = manager.load_named_text(name, create_optional=True)
@@ -469,8 +472,8 @@ def main(argv: list[str] | None = None) -> int:
         return approve_command(home, args.quest_id, args.decision_id, args.reason)
     if args.command == "graph":
         return graph_command(home, args.quest_id)
-    if args.command == "metrics":
-        return metrics_command(home, args.target)
+    if args.command in {"doctor", "docker"}:
+        return doctor_command(home)
     if args.command == "push":
         return push_command(home, args.quest_id)
     if args.command == "memory" and args.memory_command == "search":
@@ -479,6 +482,10 @@ def main(argv: list[str] | None = None) -> int:
         return baseline_list_command(home)
     if args.command == "baseline" and args.baseline_command == "attach":
         return baseline_attach_command(home, args.quest_id, args.baseline_id, args.variant_id)
+    if args.command == "latex" and args.latex_command == "status":
+        return latex_status_command(home)
+    if args.command == "latex" and args.latex_command == "install-runtime":
+        return latex_install_runtime_command(home)
     if args.command == "config" and args.config_command == "show":
         return config_show_command(home, args.name)
     if args.command == "config" and args.config_command == "edit":

package/src/deepscientist/config/models.py

@@ -35,7 +35,7 @@ def default_config(home: Path) -> dict:
             "host": "0.0.0.0",
             "port": 20999,
             "auto_open_browser": True,
-            "default_mode": "both",
+            "default_mode": "web",
         },
         "logging": {
             "level": "info",
@@ -133,8 +133,9 @@ def default_connectors() -> dict:
             "gateway_restart_on_config_change": True,
             "auto_send_main_experiment_png": True,
             "auto_send_analysis_summary_png": True,
-            "auto_send_slice_png": False,
+            "auto_send_slice_png": True,
             "auto_send_paper_pdf": True,
+            "enable_markdown_send": False,
             "enable_file_upload_experimental": False,
         },
         "telegram": {
@@ -257,6 +258,31 @@ def default_connectors() -> dict:
             "groups": [],
             "auto_bind_dm_to_active_quest": True,
         },
+        "lingzhu": {
+            "enabled": False,
+            "transport": "openclaw_sse",
+            "local_host": "127.0.0.1",
+            "gateway_port": 18789,
+            "public_base_url": None,
+            "auth_ak": None,
+            "agent_id": "main",
+            "include_metadata": True,
+            "request_timeout_ms": 60000,
+            "system_prompt": "",
+            "default_navigation_mode": "0",
+            "enable_follow_up": True,
+            "follow_up_max_count": 3,
+            "max_image_bytes": 5242880,
+            "session_mode": "per_user",
+            "session_namespace": "lingzhu",
+            "auto_receipt_ack": True,
+            "visible_progress_heartbeat": True,
+            "visible_progress_heartbeat_sec": 10,
+            "debug_logging": False,
+            "debug_log_payloads": False,
+            "debug_log_dir": None,
+            "enable_experimental_native_actions": False,
+        },
     }
 
 

package/src/deepscientist/config/service.py

@@ -5,10 +5,23 @@ import os
 import subprocess
 from copy import deepcopy
 from pathlib import Path
+from urllib.error import URLError
 from urllib.request import Request, urlopen
 
 from ..connector_runtime import infer_connector_transport
 from ..home import repo_root
+from ..lingzhu_support import (
+    lingzhu_agent_id,
+    lingzhu_generated_curl,
+    lingzhu_generated_openclaw_config_text,
+    lingzhu_gateway_port,
+    lingzhu_health_url,
+    lingzhu_local_base_url,
+    lingzhu_probe_payload,
+    lingzhu_public_base_url,
+    lingzhu_sse_url,
+    lingzhu_supported_commands,
+)
 from ..shared import read_json, read_text, read_yaml, resolve_runner_binary, run_command, sha256_text, utc_now, which, write_text, write_yaml
 from .models import (
     CONFIG_NAMES,
@@ -294,9 +307,17 @@ This page edits `~/DeepScientist/config/connectors.yaml` directly.
 - readiness test exchanges `access_token` and probes `/gateway`
 - active send targets use QQ user `openid` or group `group_openid`
 - the settings page also surfaces recently discovered targets from runtime activity
-- QQ should stay text-first by default; only milestone media should be auto-sent
-- recommended auto-send policy is: main experiment summary PNG, campaign summary PNG, final paper PDF
-- do not auto-send every slice image or draft paper figure unless the user asked for it
+- milestone delivery toggles default to enabled; adjust them only if you want less outbound push
+- the recommended first-run path is: save credentials -> send one QQ private message -> confirm `Detected OpenID` -> run a probe
+
+### Lingzhu
+
+- Lingzhu is configured as an OpenClaw companion endpoint, not as a full DeepScientist chat bridge
+- keep `transport: openclaw_sse`
+- set `gateway_port` to the OpenClaw HTTP gateway port, usually `18789`
+- generate and save `auth_ak`, then fill the same Bearer token into the Lingzhu platform
+- set `public_base_url` to a public IP or public domain before binding a real Rokid device
+- readiness test first probes `GET /metis/agent/api/health`, then runs a minimal SSE smoke request against `POST /metis/agent/api/sse`
 
 ## Safety
 
@@ -352,7 +373,8 @@ This page edits `{home_text}/config/runners.yaml`.
 ## Recommended v1 choice
 
 - keep `codex.enabled: true`
-- keep `claude.enabled: false` unless you are wiring the reserved TODO path
+- keep `claude.enabled: false`
+- `claude` remains TODO / reserved in the current open-source release and is not runnable yet
 - keep `codex.model_reasoning_effort: xhigh` unless you explicitly want a lighter default
 - keep `codex.retry_on_failure: true` so transient Codex failures can resume automatically
 - keep retry timing near `1s / 2x / 8s max` unless you have a strong reason to slow recovery down
@@ -708,6 +730,40 @@ Use **Test** when the file exposes runtime dependencies.
                         errors.append("whatsapp: `provider: meta` requires `phone_number_id`.")
                     if not self._has_secret(config, "verify_token", "verify_token_env"):
                         errors.append("whatsapp: `provider: meta` requires `verify_token` or `verify_token_env`.")
+            elif name == "lingzhu":
+                if transport != "openclaw_sse":
+                    errors.append("lingzhu: `transport` must stay `openclaw_sse`.")
+                if not str(config.get("local_host") or "").strip():
+                    warnings.append("lingzhu: `local_host` is empty; DeepScientist will fall back to `127.0.0.1`.")
+                if not self._has_secret(config, "auth_ak", "auth_ak_env"):
+                    errors.append("lingzhu: requires `auth_ak` for Bearer authentication.")
+                raw_gateway_port = str(config.get("gateway_port") or "").strip()
+                normalized_port = lingzhu_gateway_port(config)
+                if raw_gateway_port and str(normalized_port) != raw_gateway_port:
+                    errors.append("lingzhu: `gateway_port` must be a valid TCP port between 1 and 65535.")
+                raw_public_base_url = str(config.get("public_base_url") or "").strip()
+                public_base_url = lingzhu_public_base_url(config)
+                if raw_public_base_url and public_base_url is None:
+                    errors.append("lingzhu: `public_base_url` must be a valid `http://` or `https://` URL when set.")
+                raw_visible_progress_heartbeat_sec = str(
+                    config.get("visible_progress_heartbeat_sec") or ""
+                ).strip()
+                if raw_visible_progress_heartbeat_sec:
+                    try:
+                        visible_progress_heartbeat_sec = int(raw_visible_progress_heartbeat_sec)
+                    except ValueError:
+                        errors.append(
+                            "lingzhu: `visible_progress_heartbeat_sec` must be an integer between 5 and 120."
+                        )
+                    else:
+                        if visible_progress_heartbeat_sec < 5 or visible_progress_heartbeat_sec > 120:
+                            errors.append(
+                                "lingzhu: `visible_progress_heartbeat_sec` must be an integer between 5 and 120."
+                            )
+                if not raw_public_base_url:
+                    warnings.append(
+                        "lingzhu: set `public_base_url` to a public IP or public domain before filling values into the Lingzhu platform."
+                    )
 
         if preferred_connector and preferred_connector not in enabled_connectors:
             warnings.append(
@@ -872,12 +928,27 @@ Use **Test** when the file exposes runtime dependencies.
                             errors.append(str(gateway_payload.get("message") or "QQ gateway probe failed."))
                         else:
                             details["gateway_url"] = gateway_url
+            elif name == "lingzhu":
+                details.update(self._lingzhu_snapshot_details(config))
+                auth_ak = self._secret(config, "auth_ak", "auth_ak_env")
+                if not auth_ak:
+                    errors.append("Lingzhu requires `auth_ak` before it can accept Bearer-authenticated requests.")
+                elif live:
+                    health_probe = self._probe_lingzhu_health(config)
+                    details["health_probe"] = health_probe
+                    if not health_probe.get("ok", False):
+                        errors.append(str(health_probe.get("message") or "Lingzhu health probe failed."))
+                    else:
+                        sse_probe = self._probe_lingzhu_sse(config)
+                        details["sse_probe"] = sse_probe
+                        if not sse_probe.get("ok", False):
+                            errors.append(str(sse_probe.get("message") or "Lingzhu SSE probe failed."))
             else:
                 warnings.append(f"No dedicated system test exists for connector `{name}`.")
         except Exception as exc:  # pragma: no cover - network-dependent
             errors.append(str(exc))
 
-        if delivery_target:
+        if delivery_target and name != "lingzhu":
             delivery_message = str(delivery_target.get("text") or "").strip()
             chat_type = str(delivery_target.get("chat_type") or "direct").strip().lower()
             chat_id = str(delivery_target.get("chat_id") or "").strip()
@@ -899,7 +970,9 @@ Use **Test** when the file exposes runtime dependencies.
                 warnings.append("Delivery test chat_type must be `direct` or `group`.")
             elif not chat_id:
                 if name == "qq":
-                    warnings.append("Delivery test target is empty. For QQ direct sends, use a user `openid` or group `group_openid`.")
+                    warnings.append(
+                        "QQ readiness is healthy, but no OpenID has been learned yet. Save credentials, then send one private QQ message so DeepScientist can auto-detect and save the `openid`."
+                    )
                 else:
                     warnings.append("Delivery test is configured, but the target chat id is empty.")
             elif errors:
@@ -1116,6 +1189,126 @@ Use **Test** when the file exposes runtime dependencies.
             return text
         return text[: limit - 1].rstrip() + "…"
 
+    def lingzhu_snapshot(self, config: dict | None = None) -> dict:
+        resolved = dict(config or self.load_named_normalized("connectors").get("lingzhu") or {})
+        snapshot: dict[str, object] = {
+            "name": "lingzhu",
+            "display_mode": "companion_config",
+            "mode": "openclaw_companion",
+            "transport": "openclaw_sse",
+            "enabled": bool(resolved.get("enabled", False)),
+            "relay_url": None,
+            "main_chat_id": None,
+            "last_conversation_id": None,
+            "inbox_count": 0,
+            "outbox_count": 0,
+            "ignored_count": 0,
+            "binding_count": 0,
+            "target_count": 0,
+            "recent_conversations": [],
+            "recent_events": [],
+            "discovered_targets": [],
+            "details": self._lingzhu_snapshot_details(resolved),
+        }
+        if not snapshot["enabled"]:
+            snapshot["connection_state"] = "disabled"
+            snapshot["auth_state"] = "disabled"
+            return snapshot
+        snapshot["auth_state"] = "ready" if self._secret(resolved, "auth_ak", "auth_ak_env") else "missing_auth_ak"
+        health_probe = self._probe_lingzhu_health(resolved, timeout=1.5)
+        snapshot["details"]["health_probe"] = health_probe
+        if health_probe.get("ok", False):
+            snapshot["connection_state"] = "reachable"
+        else:
+            snapshot["connection_state"] = "offline"
+            if health_probe.get("message"):
+                snapshot["last_error"] = health_probe.get("message")
+        return snapshot
+
+    def _lingzhu_snapshot_details(self, config: dict) -> dict:
+        auth_ak = self._secret(config, "auth_ak", "auth_ak_env")
+        return {
+            "local_base_url": lingzhu_local_base_url(config),
+            "health_url": lingzhu_health_url(config),
+            "endpoint_url": lingzhu_sse_url(config),
+            "public_base_url": lingzhu_public_base_url(config),
+            "public_health_url": lingzhu_health_url(config, public=True),
+            "public_endpoint_url": lingzhu_sse_url(config, public=True),
+            "gateway_port": lingzhu_gateway_port(config),
+            "agent_id": lingzhu_agent_id(config),
+            "auth_ak_masked": self._mask_secret(auth_ak),
+            "generated_curl": lingzhu_generated_curl({**config, "auth_ak": auth_ak}),
+            "generated_openclaw_config": lingzhu_generated_openclaw_config_text({**config, "auth_ak": auth_ak}),
+            "packaged_bridge_dir": "assets/connectors/lingzhu/openclaw-bridge",
+            "packaged_template_path": "assets/connectors/lingzhu/openclaw.lingzhu.config.template.json",
+            "supported_commands": lingzhu_supported_commands(
+                experimental_enabled=bool(config.get("enable_experimental_native_actions", False))
+            ),
+            "public_ip_required": True,
+        }
+
+    def _probe_lingzhu_health(self, config: dict, *, timeout: float = 5.0) -> dict:
+        url = lingzhu_health_url(config)
+        if not url:
+            return {"ok": False, "message": "Lingzhu health URL is empty."}
+        try:
+            request = Request(url, method="GET", headers={"Accept": "application/json"})
+            with urlopen(request, timeout=timeout) as response:  # noqa: S310
+                payload = json.loads(response.read().decode("utf-8", errors="replace") or "{}")
+                status_code = response.status
+            return {
+                "ok": True,
+                "status_code": status_code,
+                "status": payload.get("status"),
+                "payload": payload,
+            }
+        except URLError as exc:
+            return {"ok": False, "message": str(exc.reason or exc)}
+        except Exception as exc:
+            return {"ok": False, "message": str(exc)}
+
+    def _probe_lingzhu_sse(self, config: dict, *, timeout: float = 8.0) -> dict:
+        url = lingzhu_sse_url(config)
+        auth_ak = self._secret(config, "auth_ak", "auth_ak_env")
+        if not url:
+            return {"ok": False, "message": "Lingzhu SSE URL is empty."}
+        if not auth_ak:
+            return {"ok": False, "message": "Lingzhu auth_ak is empty."}
+        request = Request(
+            url,
+            method="POST",
+            headers={
+                "Accept": "text/event-stream",
+                "Authorization": f"Bearer {auth_ak}",
+                "Content-Type": "application/json; charset=utf-8",
+            },
+            data=json.dumps(lingzhu_probe_payload(config), ensure_ascii=False).encode("utf-8"),
+        )
+        try:
+            with urlopen(request, timeout=timeout) as response:  # noqa: S310
+                preview = response.read(512).decode("utf-8", errors="replace")
+                content_type = str(response.headers.get("Content-Type") or "")
+            ok = "text/event-stream" in content_type or "event:" in preview or "data:" in preview
+            return {
+                "ok": ok,
+                "content_type": content_type,
+                "preview": self._compact_probe_text(preview, limit=512),
+                "message": None if ok else "Lingzhu SSE probe did not return an event-stream payload.",
+            }
+        except URLError as exc:
+            return {"ok": False, "message": str(exc.reason or exc)}
+        except Exception as exc:
+            return {"ok": False, "message": str(exc)}
+
+    @staticmethod
+    def _mask_secret(value: str) -> str:
+        text = str(value or "").strip()
+        if not text:
+            return ""
+        if len(text) <= 8:
+            return "*" * len(text)
+        return f"{text[:4]}{'*' * (len(text) - 8)}{text[-4:]}"
+
     def _normalize_named_payload(self, name: str, payload: dict) -> dict:
         if not isinstance(payload, dict):
             return default_payload(name, self.home)
@@ -1145,6 +1338,8 @@ Use **Test** when the file exposes runtime dependencies.
                     for legacy_key in ("mode", "relay_url", "relay_auth_token", "public_callback_url", "webhook_verify_signature"):
                         sanitized_payload.pop(legacy_key, None)
                     sanitized_payload["transport"] = "gateway_direct"
+                elif connector_name == "lingzhu":
+                    sanitized_payload["transport"] = "openclaw_sse"
                 elif "transport" not in sanitized_payload:
                     inferred_transport = infer_connector_transport(connector_name, {**base, **sanitized_payload})
                     if inferred_transport:

package/src/deepscientist/connector_runtime.py

@@ -59,6 +59,8 @@ def infer_connector_transport(name: str, config: dict[str, Any] | None) -> str:
         ):
             return "legacy_meta_cloud"
         return "local_session"
+    if normalized == "lingzhu":
+        return "openclaw_sse"
     if relay_url and mode == "relay":
         return "relay"
     return "direct"

package/src/deepscientist/daemon/api/handlers.py

@@ -194,7 +194,7 @@ npm --prefix src/ui run build</pre>
         return get_acp_bridge_status().as_dict()
 
     def connectors(self) -> list[dict]:
-        return [channel.status() for channel in self.app.channels.values()]
+        return self.app.list_connector_statuses()
 
     def baselines(self) -> list[dict]:
         return self.app.artifact_service.baselines.list_entries()
@@ -234,6 +234,9 @@ npm --prefix src/ui run build</pre>
         title = body.get("title", "").strip() or None
         quest_id = body.get("quest_id", "").strip() or None
         source = body.get("source", "").strip() or "web"
+        preferred_connector_conversation_id = (
+            str(body.get("preferred_connector_conversation_id") or "").strip() or None
+        )
         requested_baseline_ref = body.get("requested_baseline_ref")
         startup_contract = body.get("startup_contract")
         auto_start = body.get("auto_start") is True
@@ -246,6 +249,7 @@ npm --prefix src/ui run build</pre>
                 title=title,
                 quest_id=quest_id,
                 source=source,
+                preferred_connector_conversation_id=preferred_connector_conversation_id,
                 requested_baseline_ref=requested_baseline_ref if isinstance(requested_baseline_ref, dict) else None,
                 startup_contract=startup_contract if isinstance(startup_contract, dict) else None,
             )
@@ -577,6 +581,33 @@ npm --prefix src/ui run build</pre>
             return 400, {"ok": False, "message": str(exc)}
         return result
 
+    def terminal_attach(self, quest_id: str, session_id: str, body: dict | None = None) -> dict | tuple[int, dict]:
+        _unused = body or {}
+        quest_root = self.app.quest_service._quest_root(quest_id)
+        try:
+            session = self.app.bash_exec_service.get_session(quest_root, session_id)
+        except FileNotFoundError:
+            return 404, {"ok": False, "message": f"Unknown terminal session `{session_id}`."}
+        if str(session.get("kind") or "").lower() != "terminal":
+            return 400, {"ok": False, "message": "not_terminal_session"}
+        if str(session.get("status") or "").lower() in {"completed", "failed", "terminated"}:
+            return 409, {"ok": False, "message": "terminal_session_inactive", "session": session}
+        try:
+            token = self.app.bash_exec_service.issue_terminal_attach_token(quest_root, session_id)
+        except ValueError as exc:
+            return 409, {"ok": False, "message": str(exc), "session": session}
+        attach_port = self.app._terminal_attach_port
+        if not attach_port:
+            return 503, {"ok": False, "message": "terminal_attach_server_unavailable", "session": session}
+        return {
+            "ok": True,
+            "port": attach_port,
+            "path": "/terminal/attach",
+            "token": token["token"],
+            "expires_at": token["expires_at"],
+            "session": session,
+        }
+
     def terminal_restore(self, quest_id: str, session_id: str, path: str) -> dict | tuple[int, dict]:
         query = self.parse_query(path)
         commands_raw = ((query.get("commands") or ["10"])[0] or "10").strip()
@@ -780,7 +811,13 @@ npm --prefix src/ui run build</pre>
         query = self.parse_query(path)
         revision = ((query.get("revision") or [""])[0] or "").strip() or None
         mode = ((query.get("mode") or [""])[0] or "").strip() or None
-        return self.app.quest_service.explorer(quest_id, revision=revision, mode=mode)
+        profile = ((query.get("profile") or [""])[0] or "").strip() or None
+        return self.app.quest_service.explorer(
+            quest_id,
+            revision=revision,
+            mode=mode,
+            profile=profile,
+        )
 
     def quest_search(self, quest_id: str, path: str) -> dict:
         query = self.parse_query(path)
@@ -1287,9 +1324,17 @@ npm --prefix src/ui run build</pre>
         return self.app.config_manager.test_named_text(body["name"], body["content"], live=bool(body.get("live", True)))
 
     def asset(self, asset_path: str) -> tuple[int, dict, bytes]:
-        asset_root = self.app.repo_root / "assets"
-        path = resolve_within(asset_root, asset_path)
-        if not path.exists() or not path.is_file():
+        candidate_roots = [
+            self.app.repo_root / "src" / "ui" / "public" / "assets",
+            self.app.repo_root / "assets",
+        ]
+        path = None
+        for root in candidate_roots:
+            candidate = resolve_within(root, asset_path)
+            if candidate.exists() and candidate.is_file():
+                path = candidate
+                break
+        if path is None:
             return 404, {"Content-Type": "text/plain; charset=utf-8"}, b"Not Found"
         mime_type = mimetypes.guess_type(path.name)[0] or "application/octet-stream"
         return 200, {"Content-Type": mime_type}, path.read_bytes()

package/src/deepscientist/daemon/api/router.py

@@ -44,6 +44,7 @@ ROUTES: list[tuple[str, re.Pattern[str], str]] = [
     ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/bash/sessions/(?P<bash_id>[^/]+)/stop$"), "bash_stop"),
     ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/terminal/session/ensure$"), "terminal_session_ensure"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/terminal/history$"), "terminal_history"),
+    ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/terminal/sessions/(?P<session_id>[^/]+)/attach$"), "terminal_attach"),
     ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/terminal/sessions/(?P<session_id>[^/]+)/input$"), "terminal_input"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/terminal/sessions/(?P<session_id>[^/]+)/restore$"), "terminal_restore"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/terminal/sessions/(?P<session_id>[^/]+)/stream$"), "terminal_stream"),