tsugite-cli 0.25.4__tar.gz → 0.26.0__tar.gz

{tsugite_cli-0.25.4 → tsugite_cli-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tsugite-cli
-Version: 0.25.4
+Version: 0.26.0
 Summary: Micro-agent runner for task automation using markdown definitions
 Author: Justyn Shull
 License: GNU AFFERO GENERAL PUBLIC LICENSE
@@ -339,7 +339,7 @@ pip install tsugite-cli                  # or plain pip
 | --- | --- |
 | `tsugite-cli[daemon]` | Daemon: HTTP API, web UI, scheduler, jobs, terminals (pty), sandbox, Discord |
 | `tsugite-cli[web]` | `web_search` + YouTube transcripts |
-| `tsugite-cli[sandbox]` | bwrap sandbox backend (also needs the `bwrap` binary) |
+| `tsugite-cli[sandbox]` | [Hozo](https://github.com/justyns/hozo) sandbox backend (needs `bwrap` on Linux; macOS uses the built-in `sandbox-exec`) |
 | `tsugite-cli[all]` | Everything above plus the optional tmux + provider plugins |
 
 ```bash
@@ -384,7 +384,7 @@ in nested tmux / non-Rich-friendly shells. Pick a richer or quieter mode when yo
 - **Sub-agents** that can spawn other agents for specific subtasks
 - **Skills** directory-based knowledge modules (mostly) following the [agentskills.io](https://agentskills.io/) SKILL.md format
 - **Hooks** that fire shell commands on lifecycle events (post-tool, pre-message, pre/post-compact)
-- **Sandbox** (linux only) via bubblewrap with filesystem and network isolation
+- **Sandbox** (Linux and macOS) via [Hozo](https://github.com/justyns/hozo) with filesystem and network isolation
 
 ## Agents in more detail
 
@@ -417,7 +417,7 @@ For a complete example, check the built-in [default agent](tsugite/builtin_agent
 
 ## Sandbox
 
-On Linux only (for now), agent code runs inside a [bubblewrap](https://github.com/containers/bubblewrap) sandbox when you pass `--sandbox`:
+Agent code runs inside a [Hozo](https://github.com/justyns/hozo) sandbox (bubblewrap on Linux, `sandbox-exec` on macOS) when you pass `--sandbox`:
 
 ```bash
 tsu run +default "task" --sandbox --allow-domain "github.com"

{tsugite_cli-0.25.4 → tsugite_cli-0.26.0}/README.md

@@ -55,7 +55,7 @@ pip install tsugite-cli                  # or plain pip
 | --- | --- |
 | `tsugite-cli[daemon]` | Daemon: HTTP API, web UI, scheduler, jobs, terminals (pty), sandbox, Discord |
 | `tsugite-cli[web]` | `web_search` + YouTube transcripts |
-| `tsugite-cli[sandbox]` | bwrap sandbox backend (also needs the `bwrap` binary) |
+| `tsugite-cli[sandbox]` | [Hozo](https://github.com/justyns/hozo) sandbox backend (needs `bwrap` on Linux; macOS uses the built-in `sandbox-exec`) |
 | `tsugite-cli[all]` | Everything above plus the optional tmux + provider plugins |
 
 ```bash
@@ -100,7 +100,7 @@ in nested tmux / non-Rich-friendly shells. Pick a richer or quieter mode when yo
 - **Sub-agents** that can spawn other agents for specific subtasks
 - **Skills** directory-based knowledge modules (mostly) following the [agentskills.io](https://agentskills.io/) SKILL.md format
 - **Hooks** that fire shell commands on lifecycle events (post-tool, pre-message, pre/post-compact)
-- **Sandbox** (linux only) via bubblewrap with filesystem and network isolation
+- **Sandbox** (Linux and macOS) via [Hozo](https://github.com/justyns/hozo) with filesystem and network isolation
 
 ## Agents in more detail
 
@@ -133,7 +133,7 @@ For a complete example, check the built-in [default agent](tsugite/builtin_agent
 
 ## Sandbox
 
-On Linux only (for now), agent code runs inside a [bubblewrap](https://github.com/containers/bubblewrap) sandbox when you pass `--sandbox`:
+Agent code runs inside a [Hozo](https://github.com/justyns/hozo) sandbox (bubblewrap on Linux, `sandbox-exec` on macOS) when you pass `--sandbox`:
 
 ```bash
 tsu run +default "task" --sandbox --allow-domain "github.com"

{tsugite_cli-0.25.4 → tsugite_cli-0.26.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.25.4"
+version = "0.26.0"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"
@@ -238,7 +238,7 @@ ignore_names = [
   "get_completions",   # prompt_toolkit Completer API, dispatched by the session
   "complete_event",    # mandatory prompt_toolkit get_completions() parameter
   "language",          # CodeExecutionEvent field, read by the web UI via serialized events
-  "BubblewrapSandbox", # plugin entry point (tsugite.sandbox: bwrap), loaded via get_sandbox_class
+  "HozoSandbox",       # plugin entry point (tsugite.sandbox: hozo), loaded via get_sandbox_class
   # Public API / test-infra reached only from tests (vulture excludes tests).
   "subscribe_filtered",         # imperative EventBus filtered-subscription API (docs/plugin-events.md)
   "unsubscribe_filtered",

{tsugite_cli-0.25.4 → tsugite_cli-0.26.0}/tsugite/agent_runner/exec_directives.py

@@ -41,8 +41,6 @@ def _success_note(directive: ExecDirective) -> str:
 def execute_exec_directives(
     content: str,
     existing_context: Optional[Dict[str, Any]] = None,
-    sandbox_config: Optional[Any] = None,
-    workspace_dir: Optional[str] = None,
     event_bus: Optional[Any] = None,
 ) -> Tuple[str, Dict[str, Any]]:
     """Execute exec directives in `content` and return (modified_content, exec_context).
@@ -52,8 +50,6 @@ def execute_exec_directives(
         existing_context: Vars from prior pipeline stages (prefetch, tool directives,
             caller). Made available to each exec block as Python locals. Vars assigned
             by an earlier exec block in the same content are also visible to later ones.
-        sandbox_config: Optional SandboxConfig; when set, blocks run inside bubblewrap.
-        workspace_dir: Optional workspace path for sandbox bind mounts.
         event_bus: Optional EventBus for emitting warnings on continue_on_error paths.
 
     Returns:
@@ -89,8 +85,6 @@ def execute_exec_directives(
                 locals_dict=block_locals,
                 timeout=directive.timeout,
                 continue_on_error=directive.continue_on_error,
-                sandbox_config=sandbox_config,
-                workspace_dir=workspace_dir,
             )
         except Exception as e:
             if not directive.continue_on_error:

{tsugite_cli-0.25.4 → tsugite_cli-0.26.0}/tsugite/agent_runner/exec_runner.py

@@ -4,15 +4,10 @@ This is a deliberate parallel path to `tsugite.core.subprocess_executor.Subproce
 Both run user Python in a subprocess, but they differ:
 
   - `SubprocessExecutor` is async, turn-stateful, blocks `open()`, forces tool usage,
-    and manages a network proxy when sandboxed. It's designed for the LLM agent loop
-    where each turn is a long-running session.
+    and runs inside the sandbox backend when sandboxed. It's designed for the LLM agent
+    loop where each turn is a long-running session.
   - `run_python_block` (this module) is synchronous, one-shot, allows plain Python
     (`open`, `os.listdir`, etc.), and is invoked at agent-prep time before the LLM runs.
-
-Sandbox plumbing is deferred: passing `sandbox_config` raises `NotImplementedError`.
-The async path's bubblewrap+proxy lifecycle does not translate cleanly to the
-synchronous one-shot model; a future shared `build_python_subprocess_command` helper
-would converge both paths. Any sandbox-related change must update both call sites.
 """
 
 import json
@@ -126,8 +121,6 @@ def run_python_block(
     locals_dict: Dict[str, Any],
     timeout: int = 30,
     continue_on_error: bool = False,
-    sandbox_config: Optional[Any] = None,
-    workspace_dir: Optional[str] = None,
 ) -> ExecBlockResult:
     """Run a Python block synchronously in a one-shot subprocess.
 
@@ -138,8 +131,6 @@ def run_python_block(
         timeout: Wall-clock timeout in seconds.
         continue_on_error: If True, exceptions are captured to result.error and
             return_value is None instead of re-raising.
-        sandbox_config: Optional SandboxConfig; when set, blocks run in bwrap.
-        workspace_dir: Optional workspace path for sandbox bind mounts.
 
     Raises:
         TimeoutError: On timeout.
@@ -158,7 +149,7 @@ def run_python_block(
         with open(payload_path, "w") as f:
             json.dump({"locals": safe_locals, "code": code}, f)
 
-        cmd = _build_command(harness_path, payload_path, result_path, sandbox_config, workspace_dir)
+        cmd = [sys.executable, "-u", harness_path, payload_path, result_path]
 
         try:
             proc = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
@@ -205,19 +196,3 @@ def _filter_json_safe(d: Dict[str, Any]) -> Dict[str, Any]:
         except (TypeError, ValueError, OverflowError):
             continue
     return safe
-
-
-def _build_command(
-    harness_path: str,
-    payload_path: str,
-    result_path: str,
-    sandbox_config: Optional[Any],
-    workspace_dir: Optional[str],
-) -> list[str]:
-    if sandbox_config is None:
-        return [sys.executable, "-u", harness_path, payload_path, result_path]
-    raise NotImplementedError(
-        "sandbox_config support for tsu:exec is not implemented yet - the existing async "
-        "SubprocessExecutor path manages a network proxy that doesn't translate cleanly to "
-        "this synchronous one-shot path. Track in a follow-up."
-    )

{tsugite_cli-0.25.4 → tsugite_cli-0.26.0}/tsugite/agent_runner/helpers.py

@@ -1,6 +1,7 @@
 """Shared helper functions for agent execution."""
 
 import contextvars
+import uuid
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, List, Optional
@@ -105,7 +106,7 @@ def build_sandbox_policy(
     `tsu exec` so the two never drift. Agent frontmatter (network/sandbox) can only
     tighten the CLI/daemon ceiling, never loosen it.
 
-    Raises RuntimeError if the sandbox is requested but bwrap is unavailable.
+    Raises RuntimeError if the sandbox is requested but no backend is available.
     """
     from tsugite.agent_runner.runner import resolve_effective_sandbox
     from tsugite.core.sandbox import SandboxConfig, sandbox_available
@@ -121,7 +122,9 @@ def build_sandbox_policy(
         return None, None
 
     if not sandbox_available():
-        raise RuntimeError("No sandbox backend available. Install tsugite-sandbox and bubblewrap, or use --no-sandbox.")
+        raise RuntimeError(
+            "No sandbox backend available. Install tsugite-sandbox (and bubblewrap on Linux), or use --no-sandbox."
+        )
 
     ctx = SandboxContext(
         allow_domains=allow_domains,
@@ -197,6 +200,30 @@ def get_allowed_secrets() -> Optional[List[str]]:
     return _allowed_secrets_var.get()
 
 
+_turn_id_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar("turn_id", default=None)
+
+
+def start_turn() -> contextvars.Token:
+    """Mint a fresh turn id for the history events recorded in this context. Returns a reset token."""
+    return _turn_id_var.set(uuid.uuid4().hex)
+
+
+def reset_turn(token: contextvars.Token) -> None:
+    """Restore whatever turn id was current before the matching start_turn."""
+    _turn_id_var.reset(token)
+
+
+def get_turn_id() -> Optional[str]:
+    """Return the current turn's id, or None outside a turn."""
+    return _turn_id_var.get()
+
+
+def turn_fields() -> dict:
+    """The turn_id field for an event recorded now, or nothing outside a turn."""
+    turn_id = _turn_id_var.get()
+    return {"turn_id": turn_id} if turn_id else {}
+
+
 def clear_current_agent() -> None:
     """Clear the currently executing agent (tests and top-level teardown)."""
     _current_agent_var.set(None)

{tsugite_cli-0.25.4 → tsugite_cli-0.26.0}/tsugite/agent_runner/history_integration.py

@@ -13,6 +13,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
+from tsugite.agent_runner.helpers import get_turn_id, turn_fields
 from tsugite.attachments.base import Attachment
 from tsugite.config import load_config
 from tsugite.history import (
@@ -88,6 +89,14 @@ def open_or_create_session(
     return backend.create(agent_name=agent_name, model=model, workspace=workspace)
 
 
+def _turn_has(storage: Session, event_type: str) -> Optional[bool]:
+    """Whether the current turn recorded an event_type; None outside a turn."""
+    turn_id = get_turn_id()
+    if turn_id is None:
+        return None
+    return any(e.data.get("turn_id") == turn_id for e in storage.iter_events(types=(event_type,)))
+
+
 def _current_turn_already_has_user_input(storage: Session) -> bool:
     """True if the in-progress turn already recorded a user_input.
 
@@ -98,7 +107,13 @@ def _current_turn_already_has_user_input(storage: Session) -> bool:
     A genuinely repeated message opens a new turn *after* the prior session_end,
     so this stays False for it. A final_result also ends a turn copied without
     its session_end (branches, older compacted sessions).
+
+    That event-order rule covers callers with no turn id. With one set, only a
+    user_input carrying it counts.
     """
+    has = _turn_has(storage, "user_input")
+    if has is not None:
+        return has
     events = list(storage.iter_events(types=("user_input", "session_end", "final_result")))
     return bool(events) and events[-1].type == "user_input"
 
@@ -122,7 +137,7 @@ def record_user_input(
     """
     if _current_turn_already_has_user_input(storage):
         return
-    data: Dict[str, Any] = {"text": text}
+    data: Dict[str, Any] = {"text": text, **turn_fields()}
     # Only files the user actually uploaded ride here: this field is display-only
     # (the web UI renders them as clickable `uploads/<name>` chips). The agent's
     # auto-included context (workspace memory files like USER.md, config
@@ -158,11 +173,15 @@ def record_final_result(
     the agent reaches its end-of-run recording). Skip in that case so the
     conversation view doesn't render the answer twice.
     """
-    for event in reversed(list(storage.iter_events(types=("user_input", "final_result")))):
-        if event.type == "user_input":
-            break
-        if event.type == "final_result":
-            return
+    has = _turn_has(storage, "final_result")
+    if has:
+        return
+    if has is None:
+        for event in reversed(list(storage.iter_events(types=("user_input", "final_result")))):
+            if event.type == "user_input":
+                break
+            if event.type == "final_result":
+                return
     storage.record(
         "final_result",
         result=result,
@@ -170,6 +189,7 @@ def record_final_result(
         turns=turns,
         tokens=tokens,
         cost=cost,
+        **turn_fields(),
     )
 
 
@@ -189,7 +209,7 @@ def record_session_end(
     liveness. The two stores tracking different things (last-turn outcome vs
     conversation open/closed) is expected, not a desync.
     """
-    storage.record("session_end", status=status, error_message=error_message)
+    storage.record("session_end", status=status, error_message=error_message, **turn_fields())
 
 
 def save_run_to_history(

{tsugite_cli-0.25.4 → tsugite_cli-0.26.0}/tsugite/agent_runner/runner.py

@@ -12,7 +12,6 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional  # noqa: E402
 
 from tsugite.core.agent import NO_ACTION_MESSAGE, AgentResult, TsugiteAgent  # noqa: E402
 from tsugite.core.executor_registry import get_executor_class  # noqa: E402
-from tsugite.core.proxy import _parse_pattern  # noqa: E402
 from tsugite.core.state import session_state_path  # noqa: E402
 from tsugite.exceptions import (  # noqa: E402
     AgentExecutionError,
@@ -29,13 +28,16 @@ from .helpers import (  # noqa: E402
     _stderr_console,
     build_sandbox_policy,
     get_display_console,
+    get_turn_id,
     get_ui_handler,
     reset_allowed_secrets,
     reset_current_agent,
     reset_sandbox_context,
+    reset_turn,
     set_allowed_secrets,
     set_current_agent,
     set_sandbox_context,
+    start_turn,
 )
 from .models import AgentExecutionResult, AgentSkippedError  # noqa: E402
 
@@ -497,7 +499,7 @@ async def _execute_agent_with_prompt(
     )
 
     if sandbox_config is not None:
-        # bwrap sandboxing is a subprocess feature, so a sandboxed run always uses
+        # Sandboxing is a subprocess feature, so a sandboxed run always uses
         # the subprocess executor regardless of the configured default backend.
         from tsugite.core.subprocess_executor import SubprocessExecutor
 
@@ -609,13 +611,14 @@ async def _execute_agent_with_prompt(
             )
 
         try:
+            from tsugite.models import resolve_usage_model
             from tsugite.usage import get_usage_store
 
             meta = channel_metadata or {}
             get_usage_store().record(
                 session_id=continue_conversation_id,
                 agent=prepared.agent_config.name,
-                model=model_string,
+                model=resolve_usage_model(model_string),
                 source=meta.get("source") or "cli",
                 schedule_name=meta.get("schedule_id"),
                 input_tokens=agent.prompt_tokens,
@@ -750,8 +753,8 @@ def resolve_effective_sandbox(
     desired = set(fm_network.get("domains") or []) | set(fm_sandbox.get("allow_domains") or [])
     base = list(daemon_domains or [])
     if desired:
-        # Keep each desired pattern only if the daemon ceiling permits it, using the
-        # proxy's glob semantics (so agent "api.github.com" is kept under daemon
+        # Keep each desired pattern only if the daemon ceiling permits it, using
+        # glob semantics (so agent "api.github.com" is kept under daemon
         # "*.github.com"). An empty ceiling permits everything.
         effective = sorted(d for d in desired if _domain_within_ceiling(d, base))
         if not effective:
@@ -764,10 +767,25 @@ def resolve_effective_sandbox(
     return enabled, allow_domains, no_network
 
 
+def _parse_pattern(pattern: str) -> tuple[str, set[int]]:
+    """No port means {80, 443} and `:*` means any port (empty set). IPv6 takes a port
+    only in brackets (`[fd00::/8]:443`), as Hozo's proxy does."""
+    if pattern.startswith("["):
+        domain, _, port_str = pattern[1:].partition("]")
+        port_str = port_str.removeprefix(":")
+    elif pattern.count(":") == 1:
+        domain, port_str = pattern.split(":")
+    else:
+        domain, port_str = pattern, ""
+    if not port_str:
+        return (domain, {80, 443})
+    return (domain, set() if port_str == "*" else {int(port_str)})
+
+
 def _domain_within_ceiling(desired_pattern: str, ceiling: list) -> bool:
     """True if a desired domain:port pattern is permitted by the daemon ceiling.
 
-    Uses the proxy's glob + port semantics so e.g. 'api.github.com' is within
+    Uses glob + port semantics so e.g. 'api.github.com' is within
     '*.github.com', but 'github.com:22' is NOT within 'github.com' (which only allows
     the default 80/443). The ceiling is a union: the desired ports must be covered by
     the union of port sets from ALL ceiling patterns whose domain glob matches (so
@@ -777,9 +795,6 @@ def _domain_within_ceiling(desired_pattern: str, ceiling: list) -> bool:
     if not ceiling:
         return True
     d_domain, d_ports = _parse_pattern(desired_pattern.lower())
-    # The proxy treats the allowlist as a union, so collect the ports from EVERY
-    # ceiling pattern whose domain glob matches and check the desired ports against
-    # their union (e.g. ["github.com:80","github.com:443"] together cover 80/443).
     matched = False
     allowed_ports: set = set()
     for c in ceiling:
@@ -1171,6 +1186,7 @@ async def run_agent_async(
     # inside this one and must restore what it found rather than clobber it.
     agent_token = set_current_agent(agent_config.name)
     secrets_token = set_allowed_secrets(agent_config.allowed_secrets)
+    turn_token = start_turn() if get_turn_id() is None else None
 
     setup = _RunSetup(
         exec_options=exec_options,
@@ -1205,6 +1221,8 @@ async def run_agent_async(
     finally:
         reset_current_agent(agent_token)
         reset_allowed_secrets(secrets_token)
+        if turn_token is not None:
+            reset_turn(turn_token)
 
 
 def preview_multistep_agent(

{tsugite_cli-0.25.4 → tsugite_cli-0.26.0}/tsugite/agent_runner/steps.py

@@ -17,7 +17,9 @@ from .helpers import (
     clear_multistep_ui_context,
     get_ui_handler,
     print_step_progress,
+    reset_turn,
     set_multistep_ui_context,
+    start_turn,
 )
 from .metrics import StepMetrics, display_step_metrics
 from .models import AgentExecutionResult, AgentSkippedError
@@ -29,22 +31,6 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-class ExecutionContext:
-    """Namespace for tsugite-provided execution context.
-
-    Provides access to runtime metadata via attribute access (ctx.user_prompt, ctx.tasks, etc.)
-    while keeping user-assigned step variables as top-level names in the execution namespace.
-    """
-
-    def __init__(self, **kwargs):
-        for k, v in kwargs.items():
-            setattr(self, k, v)
-
-    def __repr__(self):
-        attrs = ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items())
-        return f"ExecutionContext({attrs})"
-
-
 def _build_step_error_message(
     error_type: str,
     step_name: str,
@@ -92,7 +78,7 @@ def _build_step_error_message(
 def _build_injectable_vars(step_context: Dict[str, Any], assigned_vars: Optional[set] = None) -> Dict[str, Any]:
     """Build variables for injection into Python execution namespace.
 
-    Creates a `ctx` object containing everything. Only user-assigned step variables
+    Creates a `ctx` dict containing everything. Only user-assigned step variables
     (from `assign="varname"`) are exposed at top-level to avoid namespace pollution.
 
     Args:
@@ -101,9 +87,9 @@ def _build_injectable_vars(step_context: Dict[str, Any], assigned_vars: Optional
                        If None, no variables are exposed at top-level.
 
     Returns:
-        Dictionary with 'ctx' ExecutionContext and user-assigned variables at top-level
+        Dictionary with 'ctx' dict and user-assigned variables at top-level
     """
-    ctx = ExecutionContext(**step_context)
+    ctx = dict(step_context)
 
     # Only user-assigned step variables at top-level (not tsugite metadata)
     if assigned_vars:
@@ -576,6 +562,8 @@ async def run_steps(
         except Exception as e:
             logger.debug("Could not pre-create session for multi-step run: %s", e)
 
+    # The first step continues the run's turn. Each later step or iteration starts its own.
+    turn_token = None
     try:
         # Execute each step sequentially
         final_result = None
@@ -600,6 +588,9 @@ async def run_steps(
                 step_context["iteration"] = iteration
                 step_context["max_iterations"] = step.max_iterations
                 step_context["is_looping_step"] = step_is_looping
+                if i > 1 or iteration > 1:
+                    token = start_turn()
+                    turn_token = turn_token or token
 
                 # Show step progress (unless in debug mode which has its own output)
                 if step_is_looping:
@@ -714,4 +705,6 @@ async def run_steps(
             session_id=setup.conversation_id,
         )
     finally:
+        if turn_token is not None:
+            reset_turn(turn_token)
         clear_multistep_ui_context(custom_logger)

{tsugite_cli-0.25.4 → tsugite_cli-0.26.0}/tsugite/builtin_agents/default.md

@@ -179,6 +179,8 @@ spawn_job(
 
 **Notification cost**: `notify_when` defaults to `"never"`. Set it to `"stuck"` for a wake-up only when the Job needs user intervention, or `"terminal"` for any final state. Every notification adds a turn to this conversation - prefer polling `get_job` over `notify_when="terminal"` for routine tracking.
 
+**Long Jobs**: pass `notify_after_minutes=N` for one check-in message with the Job's state and last activity when N minutes pass and it has not finished. It does not stop the Job and does not interact with `timeout_minutes` or `notify_when`. Use it in place of polling `get_job`.
+
 **When a Job goes `stuck`** (max_attempts verifier rejections), the user can retry-with-hint or mark-done-anyway from the UI; you usually don't need to act. If asked to diagnose, `get_job(job_id)` returns the worker session id and each `ac_results[].reason` - read those, suggest a different approach, or open the worker session via `session_status` to inspect what went wrong.
 
 **A Job spawned by the user via `/job`** appears in your conversation's job list once it resolves. You don't create the Job in that case - the user did. Your role is to make use of its result when relevant.

{tsugite_cli-0.25.4 → tsugite_cli-0.26.0}/tsugite/cli/exec.py

@@ -40,7 +40,7 @@ def exec_cmd(
     workspace: Optional[str] = typer.Option(
         None, "--workspace", "-w", help="Working directory for the snippet and its tools"
     ),
-    sandbox: bool = typer.Option(False, "--sandbox", help="Run the snippet in a bubblewrap sandbox"),
+    sandbox: bool = typer.Option(False, "--sandbox", help="Run the snippet in a sandbox"),
     no_sandbox: bool = typer.Option(False, "--no-sandbox", help="Disable sandbox (overrides config)"),
     allow_domain: Optional[List[str]] = typer.Option(
         None, "--allow-domain", help="Domain(s) allowed in sandbox (implies --sandbox)"

{tsugite_cli-0.25.4 → tsugite_cli-0.26.0}/tsugite/cli/run.py

@@ -257,7 +257,7 @@ def run(
     ),
     no_workspace: bool = typer.Option(False, "--no-workspace", help="Disable workspace (ignore default workspace)"),
     new_session: bool = typer.Option(False, "--new-session", help="Start fresh session (ignore workspace session)"),
-    sandbox: bool = typer.Option(False, "--sandbox", help="Run agent code in bubblewrap sandbox"),
+    sandbox: bool = typer.Option(False, "--sandbox", help="Run agent code in a sandbox"),
     no_sandbox: bool = typer.Option(False, "--no-sandbox", help="Disable sandbox (overrides config)"),
     allow_domain: Optional[List[str]] = typer.Option(
         None,
@@ -283,6 +283,7 @@ def run(
         tsu run --continue --conversation-id CONV_ID "prompt"  # Continue specific conversation
     """
     from tsugite.agent_runner import get_agent_info, run_agent
+    from tsugite.agent_runner.helpers import reset_turn, start_turn
     from tsugite.console import get_stderr_console
     from tsugite.md_agents import validate_agent_execution
     from tsugite.secrets import init_cli as init_secrets
@@ -597,6 +598,8 @@ def run(
             except Exception:
                 pass
 
+        # One turn id for the run and the save_run_to_history after it.
+        turn_token = start_turn()
         try:
             executor_kwargs = _build_executor_kwargs(
                 agent_file,
@@ -653,3 +656,5 @@ def run(
             if not ui_opts.log_json:
                 stderr_console.print("\n[dim]Use --log-json for machine-readable output[/dim]")
             raise typer.Exit(1)
+        finally:
+            reset_turn(turn_token)