Self-hosted AI workspace.
Python
fix(runtime): replace tmux pane capture with explicit bounded output (ODY-150)
Alexandre Teixeira4efb85ee33c0
diff --git a/src/agent_tools/subprocess_tools.py b/src/agent_tools/subprocess_tools.pyindex 26a5c0270..8906db1d4 100644--- a/src/agent_tools/subprocess_tools.py+++ b/src/agent_tools/subprocess_tools.py@@ -9,16 +9,14 @@ import shutilimport subprocessimport sysimport time-import collectionsimport json-from typing import Optional, Callable, Awaitable, Tuple, Dict+from typing import Optionalfrom urllib.parse import urlparseimport httpxfrom src import containmentfrom src.constants import AGENT_ISOLATED_TMP_DIRNAME, MAX_OUTPUT_CHARS, WORKSPACE_MOUNT-from src.agent_runtime.journal import mark_operation_startedlogger = logging.getLogger(__name__)@@ -29,9 +27,6 @@ logger = logging.getLogger(__name__)DEFAULT_BASH_TIMEOUT = 120DEFAULT_PYTHON_TIMEOUT = 60 * 60-PROGRESS_INTERVAL_S = 2.0-PROGRESS_TAIL_LINES = 12-TMUX_CAPTURE_LINES = 2000_HOST_SHELL_BRIDGE_HOSTS = {"127.0.0.1", "localhost", "::1", "host.docker.internal"}IS_WINDOWS = sys.platform.startswith("win")_HOST_SHELL_CANCEL_TASKS: set[asyncio.Task] = set()@@ -221,11 +216,6 @@ def is_host_shell_bridge_url_allowed(url: str) -> bool:return True-def _tmux_session_name(session_id: Optional[str]) -> str:- raw = re.sub(r"[^A-Za-z0-9_.-]+", "-", str(session_id or "default")).strip("-")- return f"ody-agent-{raw[:80] or 'default'}"--def _replace_workspace_alias(content: str, cwd: str) -> str:"""Map virtual /workspace paths without corrupting absolute host paths."""return re.sub(@@ -361,7 +351,7 @@ def _filesystem_boundary_block(mechanism: str, mode: str, *, confined: bool) ->Reports the **filesystem dimension only**, deliberately. The probe knowsthis host could also give a process group and a real wall clock, but- BashTool and PythonTool still assemble their own ``create_subprocess_*``+ Compatibility namespace previews assemble their own ``create_subprocess_*``call and pass neither ``start_new_session`` nor a group-wide kill, solisting those dimensions here would be the false claim:mod:`src.containment` calls worse than an honest absence. They arrive when@@ -529,288 +519,6 @@ def _wrap_workspace_namespace(return shlex.join(args)-async def _run_exec(*args: str, timeout: float = 10) -> Tuple[str, str, int]:- proc = await asyncio.create_subprocess_exec(- *args,- stdout=asyncio.subprocess.PIPE,- stderr=asyncio.subprocess.PIPE,- )- try:- out_b, err_b = await asyncio.wait_for(proc.communicate(), timeout=timeout)- except asyncio.TimeoutError:- try:- proc.kill()- except Exception:- pass- return "", "timeout", 124- return (- out_b.decode("utf-8", errors="replace"),- err_b.decode("utf-8", errors="replace"),- proc.returncode or 0,- )---async def _tmux_has_session(name: str) -> bool:- _, _, rc = await _run_exec("tmux", "has-session", "-t", name, timeout=3)- return rc == 0---async def _tmux_capture(name: str) -> str:- out, _, _ = await _run_exec(- "tmux", "capture-pane", "-p", "-J", "-S", f"-{TMUX_CAPTURE_LINES}", "-t", name,- timeout=5,- )- return out---async def _tmux_send_line(name: str, line: str) -> None:- if line:- await _run_exec("tmux", "send-keys", "-t", name, "-l", line, timeout=5)- await _run_exec("tmux", "send-keys", "-t", name, "C-m", timeout=5)---async def _ensure_tmux_session(name: str, cwd: str, env: Optional[dict]) -> None:- # tmux creates child panes from the long-lived server environment, not- # necessarily from the app process that issued ``new-session``. On hosts- # where tmux predates the Odysseus virtualenv this silently resolves- # ``python`` to the system interpreter, losing plotting/PDF dependencies- # and prompting futile pip-install loops. Reassert the small execution- # environment on both new and reused panes.- forwarded_env = {- key: str(env[key])- for key in ("PATH", "VIRTUAL_ENV", "HOME", "TMPDIR")- if env and env.get(key)- }- if await _tmux_has_session(name):- if forwarded_env:- exports = " ".join(- f"{key}={shlex.quote(value)}" for key, value in forwarded_env.items()- )- await _tmux_send_line(name, f"export {exports}")- await _run_exec("tmux", "send-keys", "-t", name, "stty -echo", "C-m", timeout=5)- return- env_args = [f"{key}={value}" for key, value in forwarded_env.items()]- await _run_exec(- "tmux", "new-session", "-d", "-s", name, "-c", cwd,- "env",- *env_args,- f"TERM={env.get('TERM', 'xterm-256color') if env else 'xterm-256color'}",- f"COLUMNS={env.get('COLUMNS', '120') if env else '120'}",- f"LINES={env.get('LINES', '40') if env else '40'}",- "/bin/bash",- "--noprofile",- "--norc",- timeout=10,- )- if not await _tmux_has_session(name):- raise RuntimeError(f"failed to create tmux session {name}")- await _run_exec("tmux", "send-keys", "-t", name, "stty -echo", "C-m", timeout=5)---def _output_after_marker(capture: str, start_marker: str, end_marker: str) -> Tuple[str, bool]:- lines = capture.splitlines()- start_idx = -1- for idx, line in enumerate(lines):- if line.strip() == start_marker:- start_idx = idx- if start_idx < 0:- return capture, False- end_idx = -1- for idx in range(start_idx + 1, len(lines)):- if lines[idx].strip().startswith(end_marker):- end_idx = idx- if end_idx < 0:- return "\n".join(lines[start_idx + 1:]), False- return "\n".join(lines[start_idx + 1:end_idx]), True---def _extract_marker_rc(capture: str, end_marker: str) -> int:- for line in reversed(capture.splitlines()):- stripped = line.strip()- if stripped.startswith(end_marker):- suffix = stripped[len(end_marker):].strip()- if suffix.isdigit():- return int(suffix)- return 0---async def _run_tmux_bash(- content: str,- *,- session_id: str,- cwd: str,- env: Optional[dict],- timeout: float,- progress_cb: Optional[Callable[[Dict], Awaitable[None]]] = None,-) -> Tuple[str, str, Optional[int], bool]:- name = _tmux_session_name(session_id)- await _ensure_tmux_session(name, cwd, env)-- stamp = f"{int(time.time() * 1000)}-{abs(hash(content)) % 1000000}"- start_marker = f"__ODYSSEUS_CMD_START_{stamp}__"- end_prefix = f"__ODYSSEUS_CMD_END_{stamp}__:"- # Execute each tool call in a non-interactive child shell. The tmux pane- # is deliberately persistent, but handing its terminal stdin to commands- # lets programs such as ffmpeg block forever on overwrite prompts. EOF is- # the deterministic behavior expected from an agent tool invocation.- child_command = f"/bin/bash -lc {shlex.quote(content)} </dev/null"- wrapped = (- f"printf '\\n{start_marker}\\n'\n"- f"{child_command}\n"- f"__ody_rc=$?\n"- f"printf '\\n{end_prefix}%s\\n' \"$__ody_rc\"\n"- )- for line in wrapped.splitlines():- await _tmux_send_line(name, line)-- started = time.time()- last_tail = ""- while True:- capture = await _tmux_capture(name)- body, done = _output_after_marker(capture, start_marker, end_prefix)- tail = "\n".join(body.splitlines()[-PROGRESS_TAIL_LINES:])- if progress_cb and tail != last_tail:- last_tail = tail- try:- await progress_cb({- "elapsed_s": round(time.time() - started, 1),- "tail": tail,- "tmux_session": name,- })- except Exception:- pass- if done:- rc = _extract_marker_rc(capture, end_prefix)- cleaned = _clean_tmux_command_output(body, wrapped)- return cleaned, "", rc, False- if time.time() - started > timeout:- try:- await _run_exec("tmux", "send-keys", "-t", name, "C-c", timeout=3)- except Exception:- pass- # Ctrl-C targets the pane's foreground process group, but a child- # can outlive its wrapper shell and become an orphan. Destroy this- # task-scoped session as the timeout boundary; the next tool call- # recreates it through _ensure_tmux_session.- try:- await _run_exec("tmux", "kill-session", "-t", name, timeout=3)- except Exception:- pass- cleaned = _clean_tmux_command_output(body, wrapped)- return cleaned, "", 124, True- await asyncio.sleep(0.5)---def _clean_tmux_command_output(text: str, wrapped_command: str) -> str:- lines = text.splitlines()- wrapped_lines = {ln.rstrip() for ln in wrapped_command.splitlines() if ln.strip()}- cleaned = []- for line in lines:- raw = line.rstrip()- stripped = raw.strip()- if not stripped:- cleaned.append(raw)- continue- if stripped in wrapped_lines:- continue- if stripped.startswith("__ody_rc=") or stripped.startswith("printf "):- continue- if re.fullmatch(r"(?:bash|sh)-[\d.]+\$ ?", stripped):- continue- if re.fullmatch(r"[\w.@:/~+-]+[#$] ?", stripped):- continue- cleaned.append(raw)- return "\n".join(cleaned).strip()--async def _run_subprocess_streaming(- proc: asyncio.subprocess.Process,- *,- timeout: float,- progress_cb: Optional[Callable[[Dict], Awaitable[None]]] = None,-) -> Tuple[str, str, Optional[int], bool]:- started = time.time()- stdout_full: list[str] = []- stderr_full: list[str] = []- tail = collections.deque(maxlen=PROGRESS_TAIL_LINES)-- async def _reader(stream, full_buf, label: str):- if stream is None:- return- while True:- line = await stream.readline()- if not line:- break- decoded = line.decode("utf-8", errors="replace").rstrip("\n")- full_buf.append(decoded)- if label == "err":- tail.append(f"! {decoded}")- else:- tail.append(decoded)-- async def _progress_emitter():- await asyncio.sleep(PROGRESS_INTERVAL_S)- while True:- if progress_cb:- try:- await progress_cb({- "elapsed_s": round(time.time() - started, 1),- "tail": "\n".join(list(tail)),- })- except Exception:- pass- await asyncio.sleep(PROGRESS_INTERVAL_S)-- rd_out = asyncio.create_task(_reader(proc.stdout, stdout_full, "out"))- rd_err = asyncio.create_task(_reader(proc.stderr, stderr_full, "err"))- prog_task = asyncio.create_task(_progress_emitter()) if progress_cb else None-- timed_out = False- try:- await asyncio.wait_for(proc.wait(), timeout=timeout)- except asyncio.TimeoutError:- timed_out = True- try:- proc.kill()- except Exception:- pass- try:- await asyncio.wait_for(proc.wait(), timeout=2)- except Exception:- pass- except asyncio.CancelledError:- try:- proc.kill()- except Exception:- pass- try:- await asyncio.wait_for(proc.wait(), timeout=2)- except Exception:- pass- for t in (rd_out, rd_err):- t.cancel()- if prog_task is not None:- prog_task.cancel()- raise- finally:- if prog_task is not None and not prog_task.done():- prog_task.cancel()- try:- await prog_task- except (asyncio.CancelledError, Exception):- pass- for t in (rd_out, rd_err):- try:- await asyncio.wait_for(t, timeout=1)- except Exception:- pass-- return (- "\n".join(stdout_full),- "\n".join(stderr_full),- proc.returncode,- timed_out,- )-def _owned_spec(cwd: str, env: Optional[dict], timeout: int, readonly_extra: tuple = ()) -> containment.ContainmentSpec:"""Server-defined boundary shared by the native execution tools."""readonly = []@@ -853,14 +561,15 @@ async def _run_owned_command(command, ctx: dict, *, tool: str, timeout: int, argif result.stderr.rstrip():output = (output + "\nSTDERR: " + result.stderr.rstrip()).strip()truncated = result.output_truncated or len(output) > MAX_OUTPUT_CHARS+ capture_note = " Captured output was truncated." if truncated else ""common = {"containment": boundary, "teardown": teardown, "output_truncated": truncated}if not teardown["dead"]:- return {**common, "error": f"{tool}: process teardown could not verify death",+ return {**common, "error": f"{tool}: process teardown could not verify death.{capture_note}","failure_kind": "process_teardown_failed", "exit_code": 1,"stdout": _truncate(result.stdout, MAX_OUTPUT_CHARS),"stderr": _truncate(result.stderr, MAX_OUTPUT_CHARS)}if result.timed_out:- return {**common, "error": f"{tool}: timed out after {timeout}s; process tree terminated",+ return {**common, "error": f"{tool}: timed out after {timeout}s; process tree terminated.{capture_note}","exit_code": 124, "stdout": _truncate(result.stdout, MAX_OUTPUT_CHARS),"stderr": _truncate(result.stderr, MAX_OUTPUT_CHARS)}if tool == "python":@@ -868,6 +577,9 @@ async def _run_owned_command(command, ctx: dict, *, tool: str, timeout: int, argif child_failure:return {**common, "error": _truncate("python: a child operation failed despite a zero Python exit status:\n" + child_failure, MAX_OUTPUT_CHARS),"exit_code": 1, "stderr": _truncate(result.stderr, MAX_OUTPUT_CHARS)}+ if truncated:+ note = "\n…[output truncated by containment capture limit]…"+ output = output[:MAX_OUTPUT_CHARS - len(note)] + notereturn {**common, "output": _truncate(output, MAX_OUTPUT_CHARS) or "(no output)","exit_code": result.exit_code if result.exit_code is not None else 1}diff --git a/tests/test_agent_bash_tmux_env.py b/tests/test_agent_bash_tmux_env.pyindex 44fb9562e..d0e7cbdb2 100644--- a/tests/test_agent_bash_tmux_env.py+++ b/tests/test_agent_bash_tmux_env.py@@ -1,74 +1,4 @@import asyncio-from types import SimpleNamespace---def test_new_tmux_session_forwards_runtime_python_environment(monkeypatch):- from src.agent_tools import subprocess_tools-- calls = []-- checks = 0-- async def fake_has_session(_name):- nonlocal checks- checks += 1- return checks > 1-- async def fake_run_exec(*args, **kwargs):- calls.append(args)- if args[:2] == ("tmux", "has-session"):- return "", "", 0- return "", "", 0-- monkeypatch.setattr(subprocess_tools, "_tmux_has_session", fake_has_session)- monkeypatch.setattr(subprocess_tools, "_run_exec", fake_run_exec)- asyncio.run(subprocess_tools._ensure_tmux_session(- "ody-test",- "/workspace",- {- "PATH": "/opt/ody/bin:/usr/bin",- "VIRTUAL_ENV": "/opt/ody",- "HOME": "/workspace",- "TMPDIR": "/workspace/.tmp",- "SECRET": "must-not-forward",- },- ))-- new_session = next(call for call in calls if call[:2] == ("tmux", "new-session"))- assert "PATH=/opt/ody/bin:/usr/bin" in new_session- assert "VIRTUAL_ENV=/opt/ody" in new_session- assert "HOME=/workspace" in new_session- assert "TMPDIR=/workspace/.tmp" in new_session- assert not any("SECRET=" in arg for arg in new_session)---def test_reused_tmux_session_refreshes_runtime_python_environment(monkeypatch):- from src.agent_tools import subprocess_tools-- sent = []-- async def fake_has_session(_name):- return True-- async def fake_send_line(name, line):- sent.append((name, line))-- async def fake_run_exec(*_args, **_kwargs):- return "", "", 0-- monkeypatch.setattr(subprocess_tools, "_tmux_has_session", fake_has_session)- monkeypatch.setattr(subprocess_tools, "_tmux_send_line", fake_send_line)- monkeypatch.setattr(subprocess_tools, "_run_exec", fake_run_exec)- asyncio.run(subprocess_tools._ensure_tmux_session(- "ody-existing",- "/workspace",- {"PATH": "/path with spaces/bin:/usr/bin", "VIRTUAL_ENV": "/path with spaces"},- ))-- assert sent == [(- "ody-existing",- "export PATH='/path with spaces/bin:/usr/bin' VIRTUAL_ENV='/path with spaces'",- )]def test_workspace_alias_rewrite_does_not_duplicate_absolute_host_path():@@ -97,93 +27,6 @@ def test_workspace_namespace_preserves_literal_paths_inside_scripts(tmp_path):assert (Path(tmp_path) / "result.txt").read_text() == "ok"-def test_tmux_bash_runs_tool_command_with_closed_stdin(monkeypatch, tmp_path):- from src.agent_tools import subprocess_tools-- sent = []- async def fake_ensure(*_args, **_kwargs):- return None-- async def fake_send(_name, line):- sent.append(line)-- async def fake_capture(_name):- start = next(line for line in sent if "__ODYSSEUS_CMD_START_" in line)- start = start.split("\\n")[1]- end_line = next(line for line in sent if "__ODYSSEUS_CMD_END_" in line)- end = end_line.split("\\n")[1].split("%s")[0]- return f"{start}\ngot-eof\n{end}0\n"-- monkeypatch.setattr(subprocess_tools, "_ensure_tmux_session", fake_ensure)- monkeypatch.setattr(subprocess_tools, "_tmux_send_line", fake_send)- monkeypatch.setattr(subprocess_tools, "_tmux_capture", fake_capture)- monkeypatch.setattr(subprocess_tools.time, "time", lambda: 0.123456)-- output, _stderr, rc, timed_out = asyncio.run(- subprocess_tools._run_tmux_bash(- "if read answer; then echo unexpected; else echo got-eof; fi",- session_id="test",- cwd=str(tmp_path),- env={},- timeout=2,- )- )-- assert output == "got-eof"- assert rc == 0- assert timed_out is False- assert any("/bin/bash -lc" in line and "</dev/null" in line for line in sent)---def test_tmux_bash_timeout_destroys_session_process_tree(monkeypatch, tmp_path):- from src.agent_tools import subprocess_tools-- exec_calls = []- sent = []- clock = [-2.0]-- async def fake_ensure(*_args, **_kwargs):- return None-- async def fake_send(name, line):- sent.append((name, line))-- async def fake_capture(_name):- return "still running"-- async def fake_run_exec(*args, **kwargs):- exec_calls.append(args)- return "", "", 0-- async def fake_sleep(_seconds):- return None-- monkeypatch.setattr(subprocess_tools, "_ensure_tmux_session", fake_ensure)- monkeypatch.setattr(subprocess_tools, "_tmux_send_line", fake_send)- monkeypatch.setattr(subprocess_tools, "_tmux_capture", fake_capture)- monkeypatch.setattr(subprocess_tools, "_run_exec", fake_run_exec)- monkeypatch.setattr(subprocess_tools.asyncio, "sleep", fake_sleep)- def fake_time():- clock[0] += 2.0- return clock[0]-- monkeypatch.setattr(subprocess_tools.time, "time", fake_time)-- _output, _stderr, rc, timed_out = asyncio.run(- subprocess_tools._run_tmux_bash(- "grep -r needle /large/tree",- session_id="timeout-test",- cwd=str(tmp_path),- env={},- timeout=1,- )- )-- assert rc == 124 and timed_out is True- assert any(call[:3] == ("tmux", "send-keys", "-t") for call in exec_calls)- assert any(call[:3] == ("tmux", "kill-session", "-t") for call in exec_calls)--def test_direct_bash_subprocess_has_closed_stdin(monkeypatch, tmp_path):from src.agent_tools import subprocess_toolsfrom src import tool_executiondiff --git a/tests/test_agent_bash_windows.py b/tests/test_agent_bash_windows.pyindex 99ab918c1..b4555b440 100644--- a/tests/test_agent_bash_windows.py+++ b/tests/test_agent_bash_windows.py@@ -162,7 +162,7 @@ async def test_windows_bash_does_not_use_a_stray_tmux_executable(monkeypatch, tmasync def fail_tmux(*_args, **_kwargs):pytest.fail("native Windows must not enter the POSIX tmux path")- monkeypatch.setattr(subprocess_tools, "_run_tmux_bash", fail_tmux)+ monkeypatch.setattr(subprocess_tools.asyncio, "create_subprocess_shell", fail_tmux)result = await subprocess_tools.BashTool().execute("pwd",diff --git a/tests/test_agent_tmux_retirement.py b/tests/test_agent_tmux_retirement.pyindex 9f4989667..add2f72e8 100644--- a/tests/test_agent_tmux_retirement.py+++ b/tests/test_agent_tmux_retirement.py@@ -17,7 +17,7 @@ async def test_a_chat_session_always_uses_the_owned_runner(monkeypatch, tmp_pathmonkeypatch.setattr(subprocess_tools.shutil, "which", lambda name: "/fake/tmux" if name == "tmux" else original(name))async def forbidden(*args, **kwargs):pytest.fail("native Bash resurrected a persistent tmux shell")- monkeypatch.setattr(subprocess_tools, "_run_tmux_bash", forbidden)+ monkeypatch.setattr(subprocess_tools.asyncio, "create_subprocess_shell", forbidden)result = await subprocess_tools.BashTool().execute("printf ok", {"session_id": "same-chat"})assert result["output"] == "ok"assert result["teardown"]["dead"] is Truediff --git a/tests/test_native_execution_containment.py b/tests/test_native_execution_containment.pyindex 8303e5927..63751cf31 100644--- a/tests/test_native_execution_containment.py+++ b/tests/test_native_execution_containment.py@@ -151,3 +151,37 @@ async def test_capture_preserves_multibyte_text_across_chunks(native_boundary):[sys.executable, "-c", "import sys; sys.stdout.write('€' * 30000)"], argv=True)assert result.stdout == "€" * 30000assert result.output_truncated is False+++async def test_chat_bash_captures_more_than_2000_lines(native_boundary):+ result = await subprocess_tools.BashTool().execute(+ "printf 'START\\n'; for i in $(seq 1 3000); do printf 'x\\n'; done; printf 'END\\n'",+ {"session_id": "large-output-chat"},+ )+ assert result["output"].startswith("START\n")+ assert result["output"].endswith("\nEND")+ assert len(result["output"].splitlines()) == 3002+ assert result["output_truncated"] is False+ assert result["teardown"]["dead"] is True+++async def test_chat_bash_reports_capture_limit_as_incomplete(native_boundary):+ result = await subprocess_tools.BashTool().execute(+ "for i in $(seq 1 12000); do printf 'x\\n'; done", {"session_id": "capped-chat"},+ )+ assert result["exit_code"] == 0+ assert result["output_truncated"] is True+ assert "truncated" in result["output"]+ assert result["teardown"]["dead"] is True+++async def test_repeated_chat_calls_refresh_environment(native_boundary):+ first = await subprocess_tools.BashTool().execute('printf "%s" "$VALUE"', {+ "session_id": "same-chat", "subproc_env": {"PATH": "/usr/bin:/bin", "VALUE": "first"},+ })+ second = await subprocess_tools.BashTool().execute('printf "%s" "$VALUE"', {+ "session_id": "same-chat", "subproc_env": {"PATH": "/usr/bin:/bin", "VALUE": "second"},+ })+ assert first["output"] == "first"+ assert second["output"] == "second"+ assert first["containment"]["id"] != second["containment"]["id"]diff --git a/website/configuration-reference.md b/website/configuration-reference.mdindex efa45dd73..771816b3e 100644--- a/website/configuration-reference.md+++ b/website/configuration-reference.md@@ -75,7 +75,7 @@ The source tree reads **108** `ODYSSEUS_*` variables: 78 an operator may want to| `ODYSSEUS_MAX_VISUAL_EVIDENCE_FRAMES` | `'3'` | `src/agent_loop.py:15361` | How many video frames one tool result may contribute. Clamped to 1-8. || `ODYSSEUS_MAX_VISUAL_EVIDENCE_IMAGES` | `'1'` | `src/agent_loop.py:15329` | How many images one tool result may contribute to the model turn. Clamped to 1-8. || `ODYSSEUS_MCP_ALLOWED_COMMANDS` | `''` | `src/agent_tools/admin_tools.py:140` | Security-relevant. Comma-separated allowlist of MCP launcher basenames the agent may start. Empty by default, and the deny list still wins. |-| `ODYSSEUS_PYTHON_TOOL_SITE_PACKAGES` | `''` | `src/agent_tools/subprocess_tools.py:1145` (+1 more) | Security-relevant. Absolute package roots, separated by the platform path separator, exposed to the sandboxed Python tool. Empty exposes none. |+| `ODYSSEUS_PYTHON_TOOL_SITE_PACKAGES` | `''` | `src/agent_tools/subprocess_tools.py:857` (+1 more) | Security-relevant. Absolute package roots, separated by the platform path separator, exposed to the sandboxed Python tool. Empty exposes none. || `ODYSSEUS_SCRIPT_HOST` | `'localhost'` | `src/builtin_actions.py:919` | Default host for the run-script action. `localhost`, `127.0.0.1`, `local` and empty run locally; any other value runs over SSH. || `ODYSSEUS_TOOL_APPROVAL_GATE` | `'0'` | `src/tool_capabilities.py:645` | Security-relevant. Truthy makes tool calls pass through the approval gate. Off by default. |