@researai/deepscientist 1.5.14 → 1.5.16

package/src/deepscientist/bash_exec/service.py

@@ -3,9 +3,7 @@ from __future__ import annotations
 import json
 import os
 import re
-import shlex
 import shutil
-import signal
 import subprocess
 import sys
 import tempfile
@@ -17,7 +15,9 @@ from pathlib import Path
 from typing import Any
 
 from ..mcp.context import McpContext
+from ..process_control import is_process_alive, process_session_popen_kwargs, terminate_process_ids
 from ..shared import append_jsonl, ensure_dir, generate_id, iter_jsonl, read_json, read_jsonl, read_jsonl_tail, utc_now
+from .shells import build_exec_shell_launch, build_terminal_shell_launch
 from .runtime import TerminalRuntimeManager
 
 BASH_STATUS_MARKER_PREFIX = "__DS_BASH_STATUS__"
@@ -32,6 +32,8 @@ DEFAULT_POLL_INTERVAL_SECONDS = 0.35
 TERMINAL_STATUSES = {"completed", "failed", "terminated"}
 DEFAULT_TERMINAL_SESSION_ID = "terminal-main"
 BASH_WATCHDOG_AFTER_SECONDS = 1800
+SUMMARY_RECENT_SESSION_LIMIT = 256
+SUMMARY_RUNNING_SESSION_LIMIT = 64
 INPUT_ESCAPE_SEQUENCE_RE = re.compile(r"\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b[@-_]")
 
 
@@ -114,26 +116,6 @@ def _session_sort_key(session: dict[str, Any]) -> tuple[str, str]:
     )
 
 
-def _is_process_alive(pid: object) -> bool:
-    if not isinstance(pid, int) or pid <= 0:
-        return False
-    proc_stat_path = Path("/proc") / str(pid) / "stat"
-    if proc_stat_path.exists():
-        try:
-            parts = proc_stat_path.read_text(encoding="utf-8").split()
-        except OSError:
-            parts = []
-        if len(parts) >= 3 and parts[2] == "Z":
-            return False
-    try:
-        os.kill(pid, 0)
-    except ProcessLookupError:
-        return False
-    except PermissionError:
-        return True
-    return True
-
-
 def _parse_progress_marker(line: str) -> dict[str, Any] | None:
     if not line.startswith(BASH_PROGRESS_PREFIX):
         return None
@@ -393,6 +375,65 @@ class BashExecService:
             str(session.get("bash_id") or ""),
         )
 
+    @classmethod
+    def _normalize_summary_session_list(
+        cls,
+        sessions: Any,
+        *,
+        limit: int,
+    ) -> list[dict[str, Any]]:
+        max_items = max(0, int(limit or 0))
+        if max_items <= 0:
+            return []
+        normalized: dict[str, dict[str, Any]] = {}
+        for raw in sessions or []:
+            if not isinstance(raw, dict):
+                continue
+            compact = cls._summary_session_payload(raw)
+            bash_id = _normalize_string(compact.get("bash_id"))
+            if not bash_id:
+                continue
+            normalized[bash_id] = compact
+        ordered = sorted(normalized.values(), key=cls._summary_sort_key, reverse=True)
+        return ordered[:max_items]
+
+    @classmethod
+    def _merge_summary_session_list(
+        cls,
+        sessions: Any,
+        compact: dict[str, Any],
+        *,
+        limit: int,
+    ) -> list[dict[str, Any]]:
+        bash_id = _normalize_string(compact.get("bash_id"))
+        merged = cls._normalize_summary_session_list(sessions, limit=max(1, int(limit or 0)) + 1)
+        merged = [
+            item
+            for item in merged
+            if _normalize_string(item.get("bash_id")) != bash_id
+        ]
+        if bash_id:
+            merged.append(cls._summary_session_payload(compact))
+        merged.sort(key=cls._summary_sort_key, reverse=True)
+        return merged[: max(1, int(limit or 0))]
+
+    @classmethod
+    def _remove_summary_session(
+        cls,
+        sessions: Any,
+        bash_id: str,
+        *,
+        limit: int,
+    ) -> list[dict[str, Any]]:
+        normalized_bash_id = _normalize_string(bash_id)
+        if not normalized_bash_id:
+            return cls._normalize_summary_session_list(sessions, limit=limit)
+        return [
+            item
+            for item in cls._normalize_summary_session_list(sessions, limit=limit)
+            if _normalize_string(item.get("bash_id")) != normalized_bash_id
+        ][: max(1, int(limit or 0))]
+
     @staticmethod
     def _is_active_status(value: object) -> bool:
         return _coerce_session_status(value) in {"running", "terminating"}
@@ -402,9 +443,31 @@ class BashExecService:
             "session_count": 0,
             "running_count": 0,
             "latest_session": None,
+            "recent_sessions": [],
+            "running_sessions": [],
             "updated_at": utc_now(),
         }
 
+    def _normalize_summary_payload(self, summary: Any) -> dict[str, Any]:
+        merged = {**self._default_summary(), **(summary if isinstance(summary, dict) else {})}
+        latest_session = merged.get("latest_session")
+        if isinstance(latest_session, dict):
+            compact_latest = self._summary_session_payload(latest_session)
+            merged["latest_session"] = compact_latest if _normalize_string(compact_latest.get("bash_id")) else None
+        else:
+            merged["latest_session"] = None
+        merged["session_count"] = max(0, int(merged.get("session_count") or 0))
+        merged["running_count"] = max(0, int(merged.get("running_count") or 0))
+        merged["recent_sessions"] = self._normalize_summary_session_list(
+            merged.get("recent_sessions"),
+            limit=SUMMARY_RECENT_SESSION_LIMIT,
+        )
+        merged["running_sessions"] = self._normalize_summary_session_list(
+            merged.get("running_sessions"),
+            limit=SUMMARY_RUNNING_SESSION_LIMIT,
+        )
+        return merged
+
     def _refresh_summary_cache(self, quest_root: Path, summary: dict[str, Any]) -> dict[str, Any]:
         path = self.summary_path(quest_root)
         cache_key = str(path.resolve())
@@ -417,7 +480,7 @@ class BashExecService:
             )
         else:
             state = None
-        payload = dict(summary)
+        payload = self._normalize_summary_payload(summary)
         with self._summary_cache_lock:
             self._summary_cache[cache_key] = {
                 "state": state,
@@ -443,38 +506,109 @@ class BashExecService:
         summary = read_json(path, None)
         if not isinstance(summary, dict):
             return None
-        merged = {**self._default_summary(), **summary}
+        merged = self._normalize_summary_payload(summary)
         return self._refresh_summary_cache(quest_root, merged)
 
     def _write_summary(self, quest_root: Path, summary: dict[str, Any]) -> dict[str, Any]:
-        normalized = {**self._default_summary(), **summary, "updated_at": utc_now()}
+        normalized = self._normalize_summary_payload(summary)
+        normalized["updated_at"] = utc_now()
         _atomic_write_json(self.summary_path(quest_root), normalized)
         return self._refresh_summary_cache(quest_root, normalized)
 
+    def _hydrate_summary_from_index(
+        self,
+        quest_root: Path,
+        summary: dict[str, Any],
+    ) -> dict[str, Any]:
+        needs_recent_sessions = not bool(summary.get("recent_sessions"))
+        needs_running_sessions = int(summary.get("running_count") or 0) > 0 and not bool(summary.get("running_sessions"))
+        if not needs_recent_sessions and not needs_running_sessions:
+            return summary
+
+        index_path = self.index_path(quest_root)
+        if not index_path.exists():
+            return summary
+
+        candidate_ids: list[str] = []
+        seen_ids: set[str] = set()
+        max_candidates = max(SUMMARY_RECENT_SESSION_LIMIT, SUMMARY_RUNNING_SESSION_LIMIT * 4)
+        for entry in reversed(read_jsonl(index_path)):
+            bash_id = _normalize_string((entry or {}).get("bash_id") if isinstance(entry, dict) else "")
+            if not bash_id or bash_id in seen_ids:
+                continue
+            seen_ids.add(bash_id)
+            candidate_ids.append(bash_id)
+            if len(candidate_ids) >= max_candidates:
+                break
+
+        if not candidate_ids:
+            return summary
+
+        recent_sessions: list[dict[str, Any]] = []
+        running_sessions: list[dict[str, Any]] = []
+        for bash_id in candidate_ids:
+            meta = read_json(self.meta_path(quest_root, bash_id), {})
+            if not isinstance(meta, dict) or not meta:
+                continue
+            compact = self._summary_session_payload(meta)
+            recent_sessions.append(compact)
+            if self._is_active_status(meta.get("status")):
+                running_sessions.append(compact)
+
+        if not recent_sessions and not running_sessions:
+            return summary
+
+        updated_summary = dict(summary)
+        if needs_recent_sessions and recent_sessions:
+            updated_summary["recent_sessions"] = self._normalize_summary_session_list(
+                recent_sessions,
+                limit=SUMMARY_RECENT_SESSION_LIMIT,
+            )
+            if updated_summary["recent_sessions"] and not isinstance(updated_summary.get("latest_session"), dict):
+                updated_summary["latest_session"] = updated_summary["recent_sessions"][0]
+        if needs_running_sessions:
+            updated_summary["running_sessions"] = self._normalize_summary_session_list(
+                running_sessions,
+                limit=SUMMARY_RUNNING_SESSION_LIMIT,
+            )
+        return self._write_summary(quest_root, updated_summary)
+
     def _rebuild_summary(self, quest_root: Path) -> dict[str, Any]:
         summary = self._default_summary()
         latest_session: dict[str, Any] | None = None
         session_count = 0
         running_count = 0
+        recent_sessions: list[dict[str, Any]] = []
+        running_sessions: list[dict[str, Any]] = []
         for meta_path in self.sessions_root(quest_root).glob("*/meta.json"):
             meta = read_json(meta_path, {})
             if not isinstance(meta, dict) or not meta:
                 continue
             session_count += 1
+            compact = self._summary_session_payload(meta)
+            recent_sessions.append(compact)
             if self._is_active_status(meta.get("status")):
                 running_count += 1
-            compact = self._summary_session_payload(meta)
+                running_sessions.append(compact)
             if latest_session is None or self._summary_sort_key(compact) >= self._summary_sort_key(latest_session):
                 latest_session = compact
         summary["session_count"] = session_count
         summary["running_count"] = running_count
         summary["latest_session"] = latest_session
+        summary["recent_sessions"] = self._normalize_summary_session_list(
+            recent_sessions,
+            limit=SUMMARY_RECENT_SESSION_LIMIT,
+        )
+        summary["running_sessions"] = self._normalize_summary_session_list(
+            running_sessions,
+            limit=SUMMARY_RUNNING_SESSION_LIMIT,
+        )
         return self._write_summary(quest_root, summary)
 
     def summary(self, quest_root: Path) -> dict[str, Any]:
         loaded = self._load_summary_from_disk(quest_root)
         if loaded is not None:
-            return loaded
+            return self._hydrate_summary_from_index(quest_root, loaded)
         return self._rebuild_summary(quest_root)
 
     def _write_meta(self, quest_root: Path, bash_id: str, meta: dict[str, Any]) -> dict[str, Any]:
@@ -501,6 +635,23 @@ class BashExecService:
             or self._summary_sort_key(compact) >= self._summary_sort_key(latest_session)
         ):
             summary["latest_session"] = compact
+        summary["recent_sessions"] = self._merge_summary_session_list(
+            summary.get("recent_sessions"),
+            compact,
+            limit=SUMMARY_RECENT_SESSION_LIMIT,
+        )
+        if new_running:
+            summary["running_sessions"] = self._merge_summary_session_list(
+                summary.get("running_sessions"),
+                compact,
+                limit=SUMMARY_RUNNING_SESSION_LIMIT,
+            )
+        else:
+            summary["running_sessions"] = self._remove_summary_session(
+                summary.get("running_sessions"),
+                str(compact.get("bash_id") or ""),
+                limit=SUMMARY_RUNNING_SESSION_LIMIT,
+            )
         return self._write_summary(quest_root, summary)
 
     def reconcile_session(self, quest_root: Path, bash_id: str) -> dict[str, Any]:
@@ -518,20 +669,14 @@ class BashExecService:
                 return self._session_payload(quest_root, read_json(meta_path, meta) or meta)
         monitor_pid = meta.get("monitor_pid")
         process_pid = meta.get("process_pid")
-        if kind == "terminal" and _is_process_alive(process_pid):
-            process_group_id = meta.get("process_group_id")
-            if isinstance(process_group_id, int) and process_group_id > 0:
-                try:
-                    os.killpg(process_group_id, signal.SIGTERM)
-                except ProcessLookupError:
-                    pass
-            elif isinstance(process_pid, int) and process_pid > 0:
-                try:
-                    os.kill(process_pid, signal.SIGTERM)
-                except ProcessLookupError:
-                    pass
+        if kind == "terminal" and is_process_alive(process_pid):
+            terminate_process_ids(
+                process_pid=process_pid if isinstance(process_pid, int) else None,
+                process_group_id=meta.get("process_group_id") if isinstance(meta.get("process_group_id"), int) else None,
+                force=False,
+            )
             time.sleep(0.05)
-        if kind != "terminal" and (_is_process_alive(process_pid) or _is_process_alive(monitor_pid)):
+        if kind != "terminal" and (is_process_alive(process_pid) or is_process_alive(monitor_pid)):
             return self._session_payload(quest_root, meta)
         stop_reason = _normalize_string(meta.get("stop_reason"))
         meta["status"] = "terminated" if stop_reason else "failed"
@@ -566,6 +711,59 @@ class BashExecService:
         normalized_agent_instance_ids = {item for item in (agent_instance_ids or []) if item}
         normalized_agent_ids = {item for item in (agent_ids or []) if item}
         normalized_chat_session = _normalize_string(chat_session_id)
+        summary = self.summary(quest_root)
+        if normalized_status in {"running", "terminating"} and int(summary.get("running_count") or 0) <= 0:
+            return []
+        can_use_summary_fast_path = (
+            not normalized_agent_instance_ids
+            and not normalized_agent_ids
+            and not normalized_chat_session
+        )
+        if can_use_summary_fast_path:
+            candidate_compacts: list[dict[str, Any]] | None = None
+            if normalized_status in {"running", "terminating"}:
+                running_sessions = self._normalize_summary_session_list(
+                    summary.get("running_sessions"),
+                    limit=SUMMARY_RUNNING_SESSION_LIMIT,
+                )
+                filtered_running = [
+                    item
+                    for item in running_sessions
+                    if (not normalized_kind or _normalize_string(item.get("kind")).lower() == normalized_kind)
+                    and (not normalized_status or _normalize_string(item.get("status")).lower() == normalized_status)
+                ]
+                running_count = int(summary.get("running_count") or 0)
+                if len(filtered_running) >= max(1, limit) or running_count <= len(running_sessions):
+                    candidate_compacts = filtered_running
+            elif not normalized_status:
+                recent_sessions = self._normalize_summary_session_list(
+                    summary.get("recent_sessions"),
+                    limit=SUMMARY_RECENT_SESSION_LIMIT,
+                )
+                if not normalized_kind:
+                    if len(recent_sessions) >= max(1, limit) or int(summary.get("session_count") or 0) <= len(recent_sessions):
+                        candidate_compacts = recent_sessions
+                else:
+                    filtered_recent = [
+                        item
+                        for item in recent_sessions
+                        if _normalize_string(item.get("kind")).lower() == normalized_kind
+                    ]
+                    if len(filtered_recent) >= max(1, limit) or int(summary.get("session_count") or 0) <= len(recent_sessions):
+                        candidate_compacts = filtered_recent
+            if candidate_compacts is not None:
+                resolved_sessions: list[dict[str, Any]] = []
+                for compact in candidate_compacts:
+                    bash_id = _normalize_string(compact.get("bash_id"))
+                    if not bash_id:
+                        continue
+                    try:
+                        resolved_sessions.append(self.reconcile_session(quest_root, bash_id))
+                    except FileNotFoundError:
+                        continue
+                    if len(resolved_sessions) >= max(1, limit):
+                        break
+                return resolved_sessions[: max(1, limit)]
         sessions: list[dict[str, Any]] = []
         for bash_id in self._list_session_ids(quest_root):
             try:
@@ -593,6 +791,11 @@ class BashExecService:
             if self.meta_path(quest_root, normalized).exists():
                 return normalized
             raise FileNotFoundError(f"Unknown bash session `{normalized}`.")
+        summary = self.summary(quest_root)
+        latest_session = summary.get("latest_session")
+        latest_bash_id = _normalize_string((latest_session or {}).get("bash_id") if isinstance(latest_session, dict) else "")
+        if latest_bash_id and self.meta_path(quest_root, latest_bash_id).exists():
+            return latest_bash_id
         sessions = self.list_sessions(quest_root, limit=1)
         if not sessions:
             raise FileNotFoundError("No bash session found.")
@@ -717,18 +920,11 @@ class BashExecService:
         if runtime is not None:
             runtime.stop(reason=request_payload["reason"], force=bool(force))
         else:
-            process_group_id = meta.get("process_group_id")
-            process_pid = meta.get("process_pid")
-            if isinstance(process_group_id, int) and process_group_id > 0:
-                try:
-                    os.killpg(process_group_id, signal.SIGKILL if force else signal.SIGTERM)
-                except ProcessLookupError:
-                    pass
-            elif isinstance(process_pid, int) and process_pid > 0:
-                try:
-                    os.kill(process_pid, signal.SIGKILL if force else signal.SIGTERM)
-                except ProcessLookupError:
-                    pass
+            terminate_process_ids(
+                process_pid=meta.get("process_pid") if isinstance(meta.get("process_pid"), int) else None,
+                process_group_id=meta.get("process_group_id") if isinstance(meta.get("process_group_id"), int) else None,
+                force=bool(force),
+            )
         return self._session_payload(quest_root, meta)
 
     def _build_initial_meta(
@@ -737,6 +933,7 @@ class BashExecService:
         context: McpContext,
         bash_id: str,
         command: str,
+        launch_argv: list[str] | None,
         mode: str,
         cwd: Path,
         workdir_display: str,
@@ -744,6 +941,8 @@ class BashExecService:
         env_keys: list[str],
         comment: str | dict[str, Any] | None = None,
         kind: str = "exec",
+        shell_family: str | None = None,
+        shell_name: str | None = None,
     ) -> dict[str, Any]:
         quest_root = context.require_quest_root().resolve()
         session_id = _normalize_string(context.conversation_id) or f"quest:{context.quest_id or quest_root.name}"
@@ -766,6 +965,9 @@ class BashExecService:
             "stopped_by_user_id": None,
             "comment": comment,
             "command": command,
+            "launch_argv": list(launch_argv or []),
+            "shell_family": shell_family,
+            "shell_name": shell_name,
             "workdir": workdir_display,
             "cwd": str(cwd),
             "kind": kind,
@@ -808,7 +1010,7 @@ class BashExecService:
                 stderr=monitor_log_handle,
                 cwd=str(quest_root),
                 env=monitor_env,
-                start_new_session=True,
+                **process_session_popen_kwargs(hide_window=True),
             )
         finally:
             monitor_log_handle.close()
@@ -833,10 +1035,12 @@ class BashExecService:
         session_dir = self.session_dir(quest_root, bash_id)
         ensure_dir(session_dir)
         env_payload = {str(key): str(value) for key, value in (env or {}).items() if value is not None}
+        launch = build_exec_shell_launch(command)
         meta = self._build_initial_meta(
             context=context,
             bash_id=bash_id,
             command=command,
+            launch_argv=launch.argv,
             mode=mode,
             cwd=cwd,
             workdir_display=workdir_display,
@@ -844,6 +1048,8 @@ class BashExecService:
             env_keys=sorted(env_payload),
             comment=comment,
             kind="exec",
+            shell_family=launch.family,
+            shell_name=launch.shell_name,
         )
         self.terminal_log_path(quest_root, bash_id).touch()
         self.log_path(quest_root, bash_id).touch()
@@ -880,10 +1086,14 @@ class BashExecService:
         cwd: Path,
         workdir_display: str,
         command: str,
+        launch_argv: list[str] | None,
         source: str,
         conversation_id: str | None,
         user_id: str | None,
         env_keys: list[str],
+        shell_family: str | None = None,
+        shell_name: str | None = None,
+        transport_preference: str | None = None,
     ) -> dict[str, Any]:
         timestamp = utc_now()
         session_id = _normalize_string(conversation_id) or f"quest:{quest_id}:terminal"
@@ -903,6 +1113,10 @@ class BashExecService:
             "stopped_by_user_id": None,
             "label": label,
             "command": command,
+            "launch_argv": list(launch_argv or []),
+            "shell_family": shell_family,
+            "shell_name": shell_name,
+            "transport_preference": transport_preference,
             "workdir": workdir_display,
             "cwd": str(cwd),
             "kind": "terminal",
@@ -984,29 +1198,49 @@ class BashExecService:
             self.line_buffer_path(resolved_quest_root, bash_id),
             {"buffer": "", "updated_at": utc_now()},
         )
-        terminal_rc_path = self.terminal_rc_path(resolved_quest_root, bash_id)
-        terminal_rc_path.write_text(
-            "\n".join(
-                [
-                    "PS1='\\w$ '",
-                    "PS2='> '",
-                    'PROMPT_COMMAND=\'printf "__DS_TERMINAL_PROMPT__ cwd=%q ts=%s\\n" "$PWD" "$(date -u +%FT%TZ)" >> "${DS_TERMINAL_PROMPT_PATH}"\'',
-                    "bind 'set enable-bracketed-paste off' >/dev/null 2>&1 || true",
-                    "",
-                ]
-            ),
-            encoding="utf-8",
-        )
+        terminal_script_path = session_dir / ("terminal.ps1" if os.name == "nt" else "terminal.rc")
         stop_request = self.stop_request_path(resolved_quest_root, bash_id)
         if stop_request.exists():
             stop_request.unlink()
 
         env_payload = {
-            "TERM": "xterm-256color",
-            "COLORTERM": "truecolor",
             "DS_TERMINAL_PROMPT_PATH": str(self.prompt_events_path(resolved_quest_root, bash_id)),
         }
-        command = f"exec bash --noprofile --rcfile {shlex.quote(str(terminal_rc_path))} -i"
+        if os.name != "nt":
+            terminal_script_path.write_text(
+                "\n".join(
+                    [
+                        "PS1='\\w$ '",
+                        "PS2='> '",
+                        'PROMPT_COMMAND=\'printf "__DS_TERMINAL_PROMPT__ cwd_b64=%s ts=%s\\n" "$(printf "%s" "$PWD" | base64 | tr -d "\\n")" "$(date -u +%FT%TZ)" >> "${DS_TERMINAL_PROMPT_PATH}"\'',
+                        "bind 'set enable-bracketed-paste off' >/dev/null 2>&1 || true",
+                        "",
+                    ]
+                ),
+                encoding="utf-8",
+            )
+            env_payload["TERM"] = "xterm-256color"
+            env_payload["COLORTERM"] = "truecolor"
+        else:
+            terminal_script_path.write_text(
+                "\n".join(
+                    [
+                        "$global:__dsPromptPath = $env:DS_TERMINAL_PROMPT_PATH",
+                        "function global:prompt {",
+                        "    $cwdBytes = [System.Text.Encoding]::UTF8.GetBytes((Get-Location).Path)",
+                        "    $cwdB64 = [Convert]::ToBase64String($cwdBytes)",
+                        '    $ts = [DateTime]::UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ")',
+                        '    Add-Content -LiteralPath $global:__dsPromptPath -Value "__DS_TERMINAL_PROMPT__ cwd_b64=$cwdB64 ts=$ts"',
+                        '    return "PS $((Get-Location).Path)> "',
+                        "}",
+                        "try { Set-PSReadLineOption -BellStyle None | Out-Null } catch {}",
+                        "",
+                    ]
+                ),
+                encoding="utf-8",
+            )
+        launch = build_terminal_shell_launch(terminal_script_path)
+        command = " ".join(launch.argv)
         resolved_label = _normalize_string(label) or previous_label
         meta = self._build_terminal_meta(
             quest_root=resolved_quest_root,
@@ -1016,10 +1250,14 @@ class BashExecService:
             cwd=target_cwd,
             workdir_display=workdir_display,
             command=command,
+            launch_argv=launch.argv,
             source=source,
             conversation_id=conversation_id,
             user_id=user_id,
             env_keys=sorted(env_payload),
+            shell_family=launch.family,
+            shell_name=launch.shell_name,
+            transport_preference="pipe" if os.name == "nt" else "pty",
         )
         self._write_meta(resolved_quest_root, bash_id, meta)
         append_jsonl(
@@ -1042,7 +1280,9 @@ class BashExecService:
             prompt_events_path=self.prompt_events_path(resolved_quest_root, bash_id),
             env_payload=env_payload,
             command=command,
+            launch_argv=launch.argv,
             cwd=target_cwd,
+            transport_preference="pipe" if os.name == "nt" else "pty",
         )
         meta["updated_at"] = utc_now()
         self._write_meta(resolved_quest_root, bash_id, meta)

package/src/deepscientist/bash_exec/shells.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import os
+from pathlib import Path
+import shutil
+
+
+@dataclass(frozen=True)
+class ShellLaunchSpec:
+    argv: list[str]
+    family: str
+    shell_name: str
+
+
+def _resolve_windows_shell(*, interactive: bool) -> tuple[str, str]:
+    candidates: list[tuple[str, str]] = []
+    if not interactive:
+        candidates.extend(
+            [
+                ("bash.exe", "bash"),
+                ("bash", "bash"),
+            ]
+        )
+    candidates.extend(
+        [
+            ("pwsh", "powershell"),
+            ("powershell.exe", "powershell"),
+        ]
+    )
+    if not interactive:
+        candidates.append(("cmd.exe", "cmd"))
+    for binary, family in candidates:
+        resolved = shutil.which(binary)
+        if resolved:
+            return resolved, family
+    fallback = "cmd.exe" if not interactive else "powershell.exe"
+    return fallback, "cmd" if fallback == "cmd.exe" else "powershell"
+
+
+def build_exec_shell_launch(command: str) -> ShellLaunchSpec:
+    normalized = str(command or "").strip()
+    if os.name != "nt":
+        return ShellLaunchSpec(
+            argv=["bash", "-lc", normalized],
+            family="bash",
+            shell_name="bash",
+        )
+    binary, family = _resolve_windows_shell(interactive=False)
+    if family == "bash":
+        return ShellLaunchSpec(
+            argv=[binary, "-lc", normalized],
+            family=family,
+            shell_name=Path(binary).name,
+        )
+    if family == "cmd":
+        return ShellLaunchSpec(
+            argv=[binary, "/d", "/s", "/c", normalized],
+            family=family,
+            shell_name=Path(binary).name,
+        )
+    return ShellLaunchSpec(
+        argv=[binary, "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", normalized],
+        family=family,
+        shell_name=Path(binary).name,
+    )
+
+
+def build_terminal_shell_launch(script_path: Path) -> ShellLaunchSpec:
+    if os.name != "nt":
+        return ShellLaunchSpec(
+            argv=["bash", "--noprofile", "--rcfile", str(script_path), "-i"],
+            family="bash",
+            shell_name="bash",
+        )
+    binary, family = _resolve_windows_shell(interactive=True)
+    if family == "powershell":
+        return ShellLaunchSpec(
+            argv=[binary, "-NoLogo", "-NoProfile", "-NoExit", "-ExecutionPolicy", "Bypass", "-File", str(script_path)],
+            family=family,
+            shell_name=Path(binary).name,
+        )
+    return ShellLaunchSpec(
+        argv=[binary, "/q", "/k", str(script_path)],
+        family=family,
+        shell_name=Path(binary).name,
+    )