tsugite-cli 0.15.0__tar.gz → 0.16.0__tar.gz

{tsugite_cli-0.15.0 → tsugite_cli-0.16.0}/AGENTS.md

@@ -44,6 +44,20 @@ uv run tsu render agent.md "task"
 uv run tsu validate agents/*.md
 ```
 
+### Reusing tsugite from external coding agents
+
+`tsu exec` runs a Python snippet in tsugite's tool namespace, so a tsugite skill's code
+(which calls `read_file`, `http_request`, `get_secret`, ...) runs without the full agent
+loop. Secrets are allowlisted + masked; `--no-network` / `--sandbox` isolate the run. See
+[docs/external-agent-integration.md](docs/external-agent-integration.md) for reusing skills
+and agents from Claude Code, Cursor, or any agent that runs shell commands.
+
+```bash
+echo 'read_file(path="README.md")' | tsu exec -
+tsu exec snippet.py --tools @fs,@http --allow-secret gh-token
+tsu run +<agent> "task"                                 # or reuse a whole agent
+```
+
 ### Schema Management
 ```bash
 # Regenerate JSON schema after modifying AgentConfig

{tsugite_cli-0.15.0 → tsugite_cli-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsugite-cli
-Version: 0.15.0
+Version: 0.16.0
 Summary: Micro-agent runner for task automation using markdown definitions
 Author: Justyn Shull
 License: GNU AFFERO GENERAL PUBLIC LICENSE
@@ -400,6 +400,8 @@ tsu run +default "task" --sandbox --no-network
 
 Filesystem access is limited to the workspace.  Network goes through a filtering proxy that only allows domains you specify.
 
+The daemon can also sandbox its agents (off by default, configured in `daemon.yaml`).  See [docs/sandbox.md](docs/sandbox.md).
+
 ## Config and Data Directories
 
 All paths follow [XDG Base Directory](https://specifications.freedesktop.org/basedir-spec/latest/) conventions and can be overridden with the standard environment variables.

{tsugite_cli-0.15.0 → tsugite_cli-0.16.0}/README.md

@@ -129,6 +129,8 @@ tsu run +default "task" --sandbox --no-network
 
 Filesystem access is limited to the workspace.  Network goes through a filtering proxy that only allows domains you specify.
 
+The daemon can also sandbox its agents (off by default, configured in `daemon.yaml`).  See [docs/sandbox.md](docs/sandbox.md).
+
 ## Config and Data Directories
 
 All paths follow [XDG Base Directory](https://specifications.freedesktop.org/basedir-spec/latest/) conventions and can be overridden with the standard environment variables.

{tsugite_cli-0.15.0 → tsugite_cli-0.16.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.15.0"
+version = "0.16.0"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"

{tsugite_cli-0.15.0 → tsugite_cli-0.16.0}/tsugite/agent_runner/__init__.py

@@ -3,16 +3,22 @@
 from tsugite.agent_runner.exec_directives import execute_exec_directives  # noqa: F401
 from tsugite.agent_runner.exec_runner import ExecBlockResult, run_python_block  # noqa: F401
 from tsugite.agent_runner.helpers import (  # noqa: F401
+    SandboxContext,
+    SandboxToolDeniedError,
     clear_allowed_agents,
     clear_current_agent,
+    clear_sandbox_context,
     get_allowed_agents,
     get_allowed_secrets,
     get_current_agent,
     get_display_console,
+    get_sandbox_context,
     get_ui_handler,
+    sandbox_context_to_override,
     set_allowed_agents,
     set_allowed_secrets,
     set_current_agent,
+    set_sandbox_context,
 )
 from tsugite.agent_runner.metrics import StepMetrics, display_step_metrics  # noqa: F401
 from tsugite.agent_runner.models import AgentExecutionResult  # noqa: F401
@@ -57,4 +63,10 @@ __all__ = [
     "set_allowed_secrets",
     "get_display_console",
     "get_ui_handler",
+    "SandboxContext",
+    "SandboxToolDeniedError",
+    "get_sandbox_context",
+    "set_sandbox_context",
+    "clear_sandbox_context",
+    "sandbox_context_to_override",
 ]

{tsugite_cli-0.15.0 → tsugite_cli-0.16.0}/tsugite/agent_runner/helpers.py

@@ -1,18 +1,133 @@
 """Shared helper functions for agent execution."""
 
 import threading
-from typing import Any, List, Optional
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, List, Optional
 
 from rich.console import Console
 
 from tsugite.console import get_stderr_console
 
+if TYPE_CHECKING:
+    from tsugite.options import ExecutionOptions
+
 # Console for warnings and debug output (stderr)
 _stderr_console = get_stderr_console()
 
 # Thread-local storage for tracking currently executing agent
 _current_agent_context = threading.local()
 
+# Thread-local storage for the active sandbox policy. Set per-run (in the same
+# thread as the agent loop and its parent-only tool dispatch) when an agent runs
+# sandboxed; read by host-exec/spawn tools to inherit the sandbox or be denied.
+# Thread-local (like _current_agent_context) so concurrent daemon sessions don't
+# clobber each other.
+_sandbox_context = threading.local()
+
+
+@dataclass
+class SandboxContext:
+    """Effective sandbox policy for the currently executing agent.
+
+    Presence of a SandboxContext means the agent is running sandboxed; tools read
+    it to propagate the same isolation to anything they spawn.
+    """
+
+    allow_domains: List[str] = field(default_factory=list)
+    no_network: bool = False
+    extra_ro_binds: List[Path] = field(default_factory=list)
+    extra_rw_binds: List[Path] = field(default_factory=list)
+    workspace_dir: Optional[Path] = None
+
+
+class SandboxToolDeniedError(RuntimeError):
+    """Raised when a host-exec tool is refused because the agent runs sandboxed
+    (see the deny_when_sandboxed decorator)."""
+
+
+def set_sandbox_context(ctx: Optional["SandboxContext"]) -> None:
+    """Set (or clear, with None) the active sandbox policy for this thread."""
+    _sandbox_context.value = ctx
+
+
+def get_sandbox_context() -> Optional["SandboxContext"]:
+    """Return the active sandbox policy, or None when not running sandboxed."""
+    return getattr(_sandbox_context, "value", None)
+
+
+def clear_sandbox_context() -> None:
+    """Clear the active sandbox policy from thread-local storage."""
+    if hasattr(_sandbox_context, "value"):
+        delattr(_sandbox_context, "value")
+
+
+def sandbox_context_to_override() -> Optional[dict]:
+    """Serialize the active sandbox policy as a metadata override dict, or None.
+
+    Spawn tools stamp this onto the records they create (sessions, jobs,
+    schedules) so the spawned daemon run inherits the same sandbox when it later
+    reaches the adapter chokepoint. The shape matches SandboxSettings so it can
+    be validated back there; paths are stringified to survive JSON metadata.
+    """
+    ctx = get_sandbox_context()
+    if ctx is None:
+        return None
+    return {
+        "enabled": True,
+        "no_network": ctx.no_network,
+        "allow_domains": list(ctx.allow_domains),
+        "extra_ro_binds": [str(p) for p in ctx.extra_ro_binds],
+        "extra_rw_binds": [str(p) for p in ctx.extra_rw_binds],
+    }
+
+
+def build_sandbox_policy(
+    exec_options: "ExecutionOptions",
+    *,
+    workspace_dir: Optional[Path] = None,
+    agent_config: Any = None,
+):
+    """Resolve the effective sandbox policy into (SandboxConfig, SandboxContext).
+
+    Returns (None, None) when the sandbox is off. Shared by the agent runner and
+    `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.
+    """
+    from tsugite.agent_runner.runner import resolve_effective_sandbox
+    from tsugite.core.sandbox import BubblewrapSandbox, SandboxConfig
+
+    sandbox_on, allow_domains, no_network = resolve_effective_sandbox(
+        daemon_enabled=exec_options.sandbox,
+        daemon_domains=list(exec_options.allow_domains),
+        daemon_no_network=exec_options.no_network,
+        fm_network=getattr(agent_config, "network", None),
+        fm_sandbox=getattr(agent_config, "sandbox", None),
+    )
+    if not sandbox_on:
+        return None, None
+
+    if not BubblewrapSandbox.check_available():
+        raise RuntimeError("bwrap not found. Install bubblewrap or use --no-sandbox.")
+
+    ctx = SandboxContext(
+        allow_domains=allow_domains,
+        no_network=no_network,
+        extra_ro_binds=list(exec_options.extra_ro_binds),
+        extra_rw_binds=list(exec_options.extra_rw_binds),
+        workspace_dir=workspace_dir,
+    )
+    config = SandboxConfig(
+        allowed_domains=ctx.allow_domains,
+        no_network=ctx.no_network,
+        extra_ro_binds=ctx.extra_ro_binds,
+        extra_rw_binds=ctx.extra_rw_binds,
+    )
+    return config, ctx
+
+
 # Module-level storage for allowed agents (single-threaded CLI execution)
 # Subagents run in separate processes, so this doesn't need to be thread-local
 _allowed_agents: Optional[List[str]] = None

{tsugite_cli-0.15.0 → tsugite_cli-0.16.0}/tsugite/agent_runner/runner.py

@@ -1,6 +1,7 @@
 """Agent execution engine using TsugiteAgent."""
 
 import asyncio
+import fnmatch
 import logging
 import time
 
@@ -12,6 +13,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional  # noqa: E402
 from tsugite.config import get_xdg_data_path  # noqa: E402
 from tsugite.core.agent import TsugiteAgent  # noqa: E402
 from tsugite.core.executor import LocalExecutor  # noqa: E402
+from tsugite.core.proxy import _parse_pattern  # noqa: E402
 from tsugite.exceptions import AgentExecutionError, is_prompt_too_long_error  # noqa: E402
 from tsugite.md_agents import AgentConfig, parse_agent_file  # noqa: E402
 from tsugite.models import resolve_effective_model, strip_reserved_model_kwargs  # noqa: E402
@@ -21,15 +23,18 @@ from tsugite.utils import is_interactive  # noqa: E402
 
 from .helpers import (  # noqa: E402
     _stderr_console,
+    build_sandbox_policy,
     clear_allowed_agents,
     clear_current_agent,
     clear_multistep_ui_context,
+    clear_sandbox_context,
     get_display_console,
     get_ui_handler,
     print_step_progress,
     set_allowed_secrets,
     set_current_agent,
     set_multistep_ui_context,
+    set_sandbox_context,
 )
 from .metrics import StepMetrics, display_step_metrics  # noqa: E402
 from .models import AgentExecutionResult  # noqa: E402
@@ -527,25 +532,21 @@ async def _execute_agent_with_prompt(
             final_model_kwargs["reasoning_effort"] = resolved_effort
 
     # Create executor with workspace directory and event bus
-    workspace_dir = workspace.path if workspace else None
+    workspace_dir = _resolve_workspace_dir(workspace, path_context)
 
     state_path = _resolve_state_path(continue_conversation_id)
 
-    if exec_options.sandbox:
-        from tsugite.core.sandbox import BubblewrapSandbox, SandboxConfig
-        from tsugite.core.subprocess_executor import SubprocessExecutor
-
-        if not BubblewrapSandbox.check_available():
-            raise RuntimeError("bwrap not found. Install bubblewrap or use --no-sandbox.")
+    # The daemon config (exec_options) is the ceiling; the agent's frontmatter may
+    # only tighten it (opt in, force no_network, narrow domains), never loosen.
+    # build_sandbox_policy returns (None, None) when the sandbox is off; the same
+    # helper backs `tsu exec` so the two paths never drift.
+    sandbox_config, sandbox_ctx = build_sandbox_policy(
+        exec_options, workspace_dir=workspace_dir, agent_config=agent_config
+    )
 
-        allowed_domains = list(exec_options.allow_domains)
-        if agent_config.network:
-            allowed_domains += agent_config.network.get("domains", [])
+    if sandbox_config is not None:
+        from tsugite.core.subprocess_executor import SubprocessExecutor
 
-        sandbox_config = SandboxConfig(
-            allowed_domains=allowed_domains,
-            no_network=exec_options.no_network,
-        )
         executor = SubprocessExecutor(
             workspace_dir=workspace_dir,
             event_bus=event_bus,
@@ -554,6 +555,8 @@ async def _execute_agent_with_prompt(
             state_path=state_path,
             session_id=continue_conversation_id,
         )
+        # Presence of the context == "this agent is sandboxed".
+        set_sandbox_context(sandbox_ctx)
     else:
         executor = LocalExecutor(
             workspace_dir=workspace_dir,
@@ -562,6 +565,7 @@ async def _execute_agent_with_prompt(
             state_path=state_path,
             session_id=continue_conversation_id,
         )
+        set_sandbox_context(None)
 
     # Inject variables into executor (for multi-step agents)
     if injectable_vars:
@@ -728,6 +732,11 @@ async def _execute_agent_with_prompt(
         else:
             raise RuntimeError(f"Agent execution failed: {e}")
     finally:
+        # Drop the sandbox policy from this thread so a later run on the same
+        # pooled thread (daemon asyncio.to_thread) can't read a stale context
+        # before it sets its own.
+        clear_sandbox_context()
+
         # Clean up subprocess executor temp files
         if hasattr(executor, "cleanup"):
             try:
@@ -755,6 +764,96 @@ async def _execute_agent_with_prompt(
                 await asyncio.gather(*pending_tasks, return_exceptions=True)
 
 
+def resolve_effective_sandbox(
+    *,
+    daemon_enabled: bool,
+    daemon_domains: list,
+    daemon_no_network: bool,
+    fm_network: Optional[dict],
+    fm_sandbox: Optional[dict],
+) -> tuple[bool, list, bool]:
+    """Combine the daemon sandbox policy with tighten-only frontmatter overrides.
+
+    The daemon config (or CLI flags) is the ceiling. An agent's frontmatter may make
+    itself MORE restricted - opt into the sandbox, force `no_network`, or narrow the
+    domain allowlist - but never less: it cannot disable the sandbox or reach a
+    domain the daemon didn't allow.
+
+    Returns (enabled, allow_domains, no_network).
+    """
+    fm_network = fm_network or {}
+    fm_sandbox = fm_sandbox or {}
+
+    enabled = bool(daemon_enabled) or bool(fm_sandbox.get("enabled"))
+    no_network = bool(daemon_no_network) or bool(fm_sandbox.get("no_network"))
+
+    # Domains the agent declares (network hints + an explicit cap list), capped to
+    # the daemon ceiling. An empty ceiling means "all", so the agent's declared set
+    # becomes the allowlist (narrowing from all to that set).
+    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
+        # "*.github.com"). An empty ceiling permits everything.
+        effective = sorted(d for d in desired if _domain_within_ceiling(d, base))
+        if not effective:
+            # The agent asked only for domains outside the ceiling -> grant none.
+            no_network = True
+        allow_domains = effective
+    else:
+        allow_domains = base
+
+    return enabled, allow_domains, no_network
+
+
+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
+    '*.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
+    ['github.com:80','github.com:443'] together cover the default 80/443). An empty
+    port set means "all ports" (from '*:*'); an empty ceiling list means "all allowed".
+    """
+    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:
+        c_domain, c_ports = _parse_pattern(c.lower())
+        if not fnmatch.fnmatch(d_domain, c_domain):
+            continue
+        matched = True
+        if not c_ports:  # this ceiling pattern allows all ports
+            return True
+        allowed_ports |= c_ports
+    if not matched:
+        return False
+    # Desired wanting all ports (empty set) needs an all-ports ceiling (handled above).
+    return bool(d_ports) and d_ports <= allowed_ports
+
+
+def _resolve_workspace_dir(workspace: Optional[Any], path_context: Optional[Any]) -> Optional[Path]:
+    """Resolve the executor's workspace directory.
+
+    Prefer an explicit Workspace object (CLI workspace runs); otherwise fall back
+    to the PathContext's workspace_dir. The daemon passes only a path_context (no
+    Workspace), so without this fallback the sandbox would bind/chdir the daemon's
+    CWD instead of the agent's workspace (or job worktree).
+    """
+    if workspace:
+        return workspace.path
+    if path_context and getattr(path_context, "workspace_dir", None):
+        return path_context.workspace_dir
+    return None
+
+
 def run_agent(
     agent_path: Path,
     prompt: str,

{tsugite_cli-0.15.0 → tsugite_cli-0.16.0}/tsugite/builtin_skills/codebase-exploration/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: codebase-exploration
 description: Strategies and patterns for exploring unfamiliar codebases efficiently, with adaptive approaches based on size and scope
+jinja: false
 ---
 
 # Codebase Exploration Strategies

tsugite_cli-0.16.0/tsugite/builtin_skills/external-agent-bridge/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: external-agent-bridge
+description: How an external coding agent (Claude Code, Cursor, Aider, etc.) reuses tsugite agents and skills. Read before using any tsugite skill; their code runs in tsugite's tool namespace (read_file, http_request, get_secret) and must be run via `tsu exec`, not directly in a shell.
+---
+
+# Reusing tsugite from an external coding agent
+
+tsugite agents and skills run Python in tsugite's tool namespace: functions like
+`read_file`, `http_request`, and `get_secret` are already in scope, no imports. To run that
+code, use `tsu exec` (not a plain shell or REPL).
+
+## Using a tsugite skill
+
+A skill is a directory with a `SKILL.md` (frontmatter + instructions) and optional
+`scripts/`. To use one:
+
+1. Read its `SKILL.md` to see what it does and which tsugite tools its code calls. The
+   frontmatter may list `allowed-tools`.
+2. Look up the exact signatures before writing code, so you pass the right keyword args:
+   ```bash
+   tsu tools list                # all tools, grouped by category
+   tsu tools show read_file      # params for one tool, e.g. read_file(path=...)
+   ```
+3. Run the code with the tools it needs:
+   ```bash
+   tsu exec snippet.py --tools @fs,@http
+   echo 'print(read_file(path="README.md")[:200])' | tsu exec -
+   ```
+   If the skill ships a script, run it directly:
+   `tsu exec .claude/skills/<name>/scripts/foo.py --tools @fs`.
+
+When writing the code:
+- Call tools with keyword args: `read_file(path="x")`, not `read_file("x")`. Get the
+  param names from `tsu tools show <name>`.
+- `open()` is blocked; use `read_file` / `write_file`.
+- A trailing expression is printed, like `python -c`.
+
+## Tools
+
+- `--tools` selects what is available: categories (`@fs`, `@http`, `@secrets`, `@shell`,
+  `@time`, ...) or bare names. Pass several by repeating the flag or comma-separating
+  (`--tools @fs,@http`). Default exposes `@fs`, `@http`, `@secrets`.
+- `--agent +name` inherits that agent's exact tools and secret allowlist.
+- `tsu tools list` / `tsu tools show <name>` are the source of truth for names and params.
+
+## Secrets
+
+`get_secret(name="...")` returns the value, masked as `***` in output. Allowlist it:
+
+```bash
+tsu exec snippet.py --allow-secret gh-token
+tsu exec snippet.py --agent +deploy           # use the agent's allowed_secrets
+```
+
+No allowlist means all secrets are allowed (still masked).
+
+## Sandbox
+
+```bash
+tsu exec snippet.py --no-network                  # no network (implies --sandbox)
+tsu exec snippet.py --sandbox --allow-domain api.github.com
+```
+
+## Whole agents
+
+If a task matches an existing agent, run it instead of rebuilding it:
+
+```bash
+tsu agents list
+tsu run +<agent> "task"
+```
+
+See `docs/external-agent-integration.md` in the tsugite repo for more.

{tsugite_cli-0.15.0 → tsugite_cli-0.16.0}/tsugite/builtin_skills/scheduling/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: scheduling
 description: How to create, manage, and monitor scheduled agent tasks using Tsugite's schedule tools
+jinja: false
 ---
 
 # Scheduling Agent Tasks

{tsugite_cli-0.15.0 → tsugite_cli-0.16.0}/tsugite/builtin_skills/skill-authoring/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: skill-authoring
 description: How to write effective skills, convert agentskills.io/Claude Code skills to tsugite format, and review skills for safety; load when authoring, converting, or auditing skills
+jinja: false
 ---
 
 # Skill Authoring Guide

{tsugite_cli-0.15.0 → tsugite_cli-0.16.0}/tsugite/builtin_skills/tsugite-agent-basics/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: tsugite-agent-basics
 description: Overview of how Tsugite agents are defined, resolved, and executed; load when inspecting, authoring, or troubleshooting agents
+jinja: false
 ---
 
 # Tsugite Agent Basics

{tsugite_cli-0.15.0 → tsugite_cli-0.16.0}/tsugite/builtin_skills/tsugite-jinja-reference/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: tsugite-jinja-reference
 description: Reference for Jinja templating in Tsugite agents, including helpers and context variables; load when editing templates or debugging rendering
+jinja: false
 ---
 
 # Tsugite Jinja Reference

{tsugite_cli-0.15.0 → tsugite_cli-0.16.0}/tsugite/builtin_skills/tsugite-skill-basics/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: tsugite-skill-basics
 description: How Tsugite skills are structured, discovered, and loaded at runtime; load when creating, auditing, or debugging skills
+jinja: false
 ---
 
 # Tsugite Skill Basics
@@ -27,7 +28,7 @@ skill-name/
     assets/             # optional: templates, data, or other static resources
 ```
 
-`SKILL.md` itself is a Jinja2-rendered Markdown file:
+`SKILL.md` itself is a Jinja2-rendered Markdown file (set `jinja: false` in frontmatter to opt out and show the body verbatim):
 
 ```yaml
 ---
@@ -54,6 +55,7 @@ Available in templates:
 **Tsugite extensions** (not part of the agentskills.io spec; safe to omit for cross-client portability):
 - `triggers: [keywords]` - when any listed keyword appears in the user prompt (word-boundary match, case-insensitive), the skill is auto-loaded.
 - `ttl: N` - sticky time-to-live (in user messages). Only applies in the daemon. A sticky skill that goes N turns without being referenced is auto-unloaded. `0` means never expire. Defaults to the global `skill_ttl_default` config value (currently 10).
+- `jinja: false` - skip Jinja rendering for this skill's body, showing it verbatim. Use for documentation/reference skills whose content contains literal `{{ }}` / `{% %}` examples that must not be executed. Default is `true`. (`<!-- tsu:ignore -->` blocks are still stripped either way.)
 
 ## Discovery Order
 
@@ -236,7 +238,7 @@ read_file(results[0])
 
 ### Undefined Variable in Template
 
-Skills only have `today()`, `now()`, `env`, and `user_prompt`. Remove references to other variables.
+Skills only have `today()`, `now()`, `env`, and `user_prompt`. Remove references to other variables, or set `jinja: false` in frontmatter if the `{{ }}` are literal documentation examples that should not be rendered at all.
 
 ### Name/Directory Mismatch Warning
 

{tsugite_cli-0.15.0 → tsugite_cli-0.16.0}/tsugite/cli/__init__.py

@@ -27,12 +27,14 @@ def version():
 
 # Register main commands from split modules
 from .chat import chat  # noqa: E402
+from .exec import exec_cmd  # noqa: E402
 from .render import render  # noqa: E402
 from .run import run  # noqa: E402
 
 app.command()(run)
 app.command()(render)
 app.command()(chat)
+app.command("exec")(exec_cmd)
 
 # Backward-compatible re-exports + subcommand registration
 from .agents import agents_app  # noqa: E402