tsugite-cli 0.22.0__tar.gz → 0.23.0__tar.gz

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/.gitignore

@@ -193,4 +193,6 @@ plugins/tsugite-daemon/tsugite_daemon/web/
 # Re-include frontend source that generic lib/ rules (incl. contributors' global
 # gitignores with Python-style `lib/`) would otherwise silently exclude.
 !plugins/tsugite-daemon/frontend/src/lib/
-!plugins/tsugite-daemon/frontend/src/lib/**
+!plugins/tsugite-daemon/frontend/src/lib/**
+# Per-job git worktrees provisioned by the daemon.
+.tsugite-jobs/

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/AGENTS.md

@@ -289,7 +289,7 @@ Tsugite supports vision (images), audio, and document understanding through the
 **How It Works:**
 
 1. **URL Attachments** (Images/Documents):
-   - The provider fetches the URL directly (no download overhead — support varies by provider and content type; see `tsugite/attachments/url.py`)
+   - The provider fetches the URL directly (no download overhead, though support varies by provider and content type; see `tsugite/attachments/url.py`)
    - Example: `tsu run -f https://example.com/chart.png "Describe this chart"`
    - Automatically detected via HTTP HEAD request
 
@@ -425,7 +425,7 @@ See `examples/attachment_assign_demo.md` and `examples/attachment_index_demo.md`
 
 ### Swappable batteries
 
-Subsystems are pluggable behind a uniform seam: (1) a Protocol, (2) a `tsugite.<area>`
+Subsystems are pluggable behind a uniform interface: (1) a Protocol, (2) a `tsugite.<area>`
 entry-point group, (3) a `config.<area>.backend` selector resolved via
 `load_backend_entry_point` (`plugins.py`), with a built-in default. Areas: tools, providers,
 adapters, secrets, hooks, event_subscribers, history, attachments, sandbox, executors.
@@ -448,12 +448,12 @@ For any non-trivial bug fix or feature, write a failing test **first**. Exceptio
 
 The workflow:
 
-1. **Reproduce before fixing.** Write the smallest test that demonstrates the symptom as reported. Run it. If it passes on master, the hypothesis is wrong — do not write a fix. Investigate further, ask the user for more detail, or add logging.
+1. **Reproduce before fixing.** Write the smallest test that demonstrates the symptom as reported. Run it. If it passes on master, the hypothesis is wrong. Do not write a fix. Investigate further, ask the user for more detail, or add logging.
 2. **Implement the fix.** Keep the change minimal. Do not refactor or add adjacent cleanup in the same diff.
-3. **Verify the test is load-bearing.** Temp-revert the production change and re-run. The test must go red again. If it still passes, the test isn't actually exercising the fix — rework it.
+3. **Verify the test is load-bearing.** Temp-revert the production change and re-run. The test must go red again. If it still passes, the test isn't exercising the fix. Rework it.
 4. **Cover adjacent cases before declaring done.** When touching a parser, protocol boundary, or state machine, enumerate at least two adjacent input shapes and add tests for them. Narrow tests let bugs sneak in through the cases you didn't think about.
 5. **Run the local regression suite.** At minimum, the test files next to the modules you changed. Faster than running everything, catches silent breakage of existing tests.
-6. **Honest uncertainty.** If a hypothesis doesn't reproduce, say so. Don't ship a "probably-this" fix with no failing test to anchor it — that's how placebo fixes get merged.
+6. **Honest uncertainty.** If a hypothesis doesn't reproduce, say so. Don't ship a "probably-this" fix with no failing test to anchor it. That's how placebo fixes get merged.
 
 Reproducing tests don't need to be elaborate. A 10-line test that flips red→green is worth more than a 100-line one that nobody understands.
 
@@ -461,7 +461,7 @@ Reproducing tests don't need to be elaborate. A 10-line test that flips red→gr
 
 - **Unit tests**: Individual functions and classes
 - **Pipeline tests**: Mock only `TsugiteAgent` / the provider's `acompletion` but exercise the full pipeline (parsing → rendering → preparation → tool expansion → execution). Most tests in the suite are this style.
-- **Integration tests**: Live under `tests/integration/` (not collected by default — see `pyproject.toml` `norecursedirs`). Run explicitly with `uv run pytest tests/integration/`. Good for concurrency, cwd, and daemon-wiring tests that need real threading or a real workspace.
+- **Integration tests**: Live under `tests/integration/` (not collected by default; see `pyproject.toml` `norecursedirs`). Run explicitly with `uv run pytest tests/integration/`. Good for concurrency, cwd, and daemon-wiring tests that need real threading or a real workspace.
 - **Smoke tests**: `tests/smoke_test.sh` hits a real LLM API (requires `OPENAI_API_KEY`, not run in CI)
 - **Fixtures**: `conftest.py` provides shared test data
 - **Mocking**: Use `@pytest.fixture` for LLM responses
@@ -471,9 +471,16 @@ Reproducing tests don't need to be elaborate. A 10-line test that flips red→gr
 ## Code Style
 
 - Python 3.11+ (type hints on public APIs)
-- Line length: 120 characters (Black)
+- Line length: 120 characters (ruff)
 - Import order: stdlib → third-party → local (blank lines between groups)
-- Errors: `ValueError` for input validation, `RuntimeError` for execution failures
+- Errors, by condition:
+  - `ValueError` - input validation
+  - `RuntimeError` - execution failures
+  - `TimeoutError` - timeouts
+  - `PermissionError` - policy denials
+  - `ToolUnavailableError` - the tool cannot run in this context
+  - `FileNotFoundError` / `IsADirectoryError` / `NotADirectoryError` - paths
+- Never wrap a tool body in a blanket `except Exception`
 - Docstrings: Google style with `Args:` and `Returns:` sections
 - Pydantic models: Use `extra="forbid"` to catch typos in YAML frontmatter
 
@@ -485,7 +492,7 @@ Reproducing tests don't need to be elaborate. A 10-line test that flips red→gr
 4. **Don't hardcode paths**: Use XDG utilities (`get_xdg_config_path()`, etc.)
 5. **Don't use blocking IO in async**: Use `asyncio.to_thread()` for sync tools
 6. **Test both sync and async paths**: Many tools support both execution modes
-7. **Don't embed prompts in adapters/code**: Use context variables + conditional blocks in `default.md` instead. Add new context vars in `_build_agent_context()` (base adapter) and default them in `agent_preparation.py`, then use `{% if var %}` in the agent template. This keeps all prompt content in one place and leverages the existing rendering pipeline.
+7. **Don't embed prompts in adapters/code**: Use context variables + conditional blocks in `default.md` instead. Add new context vars in `_build_agent_context()` (base adapter) and default them in `agent_preparation.py`, then use `{% if var %}` in the agent template. This keeps all prompt content in one place and uses the existing rendering pipeline.
 
 ## Web UI
 

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/CONTRIBUTING.md

@@ -10,8 +10,8 @@ Use [Conventional Commits](https://www.conventionalcommits.org/). Format:
 <type>(<scope>): <subject>
 ```
 
-Keep the subject on one line, lowercase, no trailing period. Prefer no body. When the subject alone
-does not say what changed for someone using tsugite, add a `Release-Note:` trailer (below).
+Keep the subject on one line, lowercase, no trailing period, and write it as the line a user would
+read in the release notes. No body, no trailers.
 
 ### Allowed types
 
@@ -46,21 +46,14 @@ Scopes are optional, but should be limited to one of these:
 
 ### Release notes
 
-git-cliff (`cliff.toml`) generates the release notes from the commits. A subject that already reads
-as the change is the release line; when it reads as the patch instead, add a `Release-Note:` trailer:
+git-cliff (`cliff.toml`) generates the release notes from the commit subjects, so the subject is the
+release line. Write it as what the software does now for the person using it, and it needs nothing
+else. `chore`, `docs`, `test` and `ci` commits never appear.
 
-```
-fix(webui): scope agent artifact panes by session
-
-Release-Note: Opening an artifact from one chat keeps every other chat's pane as it was.
-```
-
-One line, present tense, stating what the software does now. No "instead of", no because-clause. A
-commit with nothing to tell a user (a test fix, an internal rename) carries no trailer and prints its
-subject instead. `chore`, `docs`, `test` and `ci` commits never appear.
-
-The trailer has to be the last paragraph of the message. When squashing, keep one `Release-Note:`
-line at the end of the squashed message; a trailer buried mid-body is not parsed.
+`cliff.toml` also prints a `Release-Note:` trailer in place of the subject when one is present. That
+is an escape hatch for the rare commit whose subject cannot say what a user sees, not something to
+add by default; almost every commit should have none. When one is needed it has to be the last
+paragraph of the message, and a squash keeps at most one.
 
 ### Examples
 

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tsugite-cli
-Version: 0.22.0
+Version: 0.23.0
 Summary: Micro-agent runner for task automation using markdown definitions
 Author: Justyn Shull
 License: GNU AFFERO GENERAL PUBLIC LICENSE

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/pyproject.toml

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

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/tsugite/agent_preparation.py

@@ -89,7 +89,7 @@ class AgentPreparer:
         _resolve_attachments     caller + frontmatter attachments, removals, dedupe
         _install_skill_manager   workspace-aware SkillManager, made active
         _run_prefetch            frontmatter prefetch tools + agent-list injection
-        _resolve_paths           cwd / invoked_from / workspace_dir
+        _resolve_paths           CWD / INVOKED_FROM / WORKSPACE_DIR
         _build_template_context  the Jinja context and its framework defaults
         _expand_tools            tool specs + capability-based auto-injection
         _load_skills             auto-load, sticky TTL, trigger matching
@@ -119,8 +119,9 @@ class AgentPreparer:
         placeholders: Dict[str, str] = {}
         modified = content
         for d in directives:
-            if d.assign_var:
-                placeholders[d.assign_var] = f"[{kind} directive: {d.name}(...) - not executed in render mode]"
+            for var in (d.assign_var, getattr(d, "stdout_assign", None)):
+                if var:
+                    placeholders[var] = f"[{kind} directive: {d.name}(...) - not executed in render mode]"
             if rewrite_to is not None:
                 modified = modified.replace(d.raw_match, rewrite_to(d))
         return modified, placeholders
@@ -142,14 +143,16 @@ class AgentPreparer:
         )
 
     def _resolve_attachments(
-        self, agent_config: AgentConfig, attachments: Optional[List[Attachment]]
+        self,
+        agent_config: AgentConfig,
+        attachments: Optional[List[Attachment]],
+        paths: Dict[str, Optional[str]],
     ) -> Tuple[List[Attachment], Dict[str, Any]]:
         """Merge caller attachments with the agent's own, honoring removals.
 
-        Front-matter attachments carry the cache tiers and are the intended
-        source, so they dedupe ahead of any same-named attachment the caller
-        passed in. Legacy `-filename` string entries drop a same-named entry.
-        Front-matter paths resolve via cwd (workspace_path is None in production).
+        A front-matter attachment defines its cache tier and replaces a same-named
+        caller attachment. Legacy `-filename` string entries drop a same-named
+        entry. Front-matter paths render with `paths` and resolve against its CWD.
         """
         all_attachments = list(attachments or [])
 
@@ -157,7 +160,7 @@ class AgentPreparer:
         if removals:
             all_attachments = [a for a in all_attachments if a.name not in removals]
 
-        loaded, bindings = resolve_agent_config_attachments(keep_items, None)
+        loaded, bindings = resolve_agent_config_attachments(keep_items, Path(paths["CWD"]), paths)
         all_attachments = loaded + all_attachments
 
         seen_names: set[str] = set()
@@ -201,8 +204,7 @@ class AgentPreparer:
             except Exception:
                 prefetch_context = {}
 
-        # Default agents call list_available_agents() on demand instead of
-        # carrying the full list, so this stays opt-in.
+        # The agent list is opt-in. Default agents call list_available_agents() on demand.
         if "available_agents" not in prefetch_context and (
             agent_config.auto_load_agent_list or agent_config.auto_load_agents
         ):
@@ -254,7 +256,7 @@ class AgentPreparer:
                 continue
             meta = registry.get(name)
             if meta is None:
-                # Skill vanished (renamed/removed) between turns — drop it.
+                # The skill vanished (renamed or removed) between turns.
                 expired_sticky.append(name)
                 continue
             effective_ttl = meta.ttl if meta.ttl is not None else ttl_default
@@ -298,9 +300,8 @@ class AgentPreparer:
     ) -> List[Tool]:
         """Expand the agent's tool specs and apply the capability-based auto-injections.
 
-        Interactive tools are added only when something can actually answer, and
-        stripped otherwise, so a scheduled run cannot offer the model a prompt
-        nobody will see.
+        Interactive tools are added only when something can answer, and stripped
+        otherwise.
         """
         from tsugite.core.tools import create_tool_from_tsugite
         from tsugite.interaction import get_interaction_backend
@@ -332,8 +333,8 @@ class AgentPreparer:
             raise RuntimeError(f"Failed to create tools: {e}") from e
 
     @staticmethod
-    def _resolve_paths(path_context: Optional["PathContext"]) -> Tuple[str, Optional[str], Optional[str]]:
-        """Return (cwd, invoked_from, workspace_dir) as strings for the template context.
+    def _resolve_paths(path_context: Optional["PathContext"]) -> Dict[str, Optional[str]]:
+        """CWD, INVOKED_FROM and WORKSPACE_DIR for the template context.
 
         The daemon supplies an effective_cwd that differs from the process cwd.
         """
@@ -341,9 +342,11 @@ class AgentPreparer:
             cwd = str(path_context.effective_cwd)
         else:
             cwd = str(Path.cwd())
-        invoked_from = str(path_context.invoked_from) if path_context else None
-        workspace_dir = str(path_context.workspace_dir) if path_context and path_context.workspace_dir else None
-        return cwd, invoked_from, workspace_dir
+        return {
+            "CWD": cwd,
+            "INVOKED_FROM": str(path_context.invoked_from) if path_context else None,
+            "WORKSPACE_DIR": str(path_context.workspace_dir) if path_context and path_context.workspace_dir else None,
+        }
 
     def _build_template_context(
         self,
@@ -354,9 +357,7 @@ class AgentPreparer:
         directive_context: Dict[str, Any],
         attachment_bindings: Dict[str, Any],
         interactive_mode: bool,
-        cwd: str,
-        invoked_from: Optional[str],
-        workspace_dir: Optional[str],
+        paths: Dict[str, Optional[str]],
     ) -> Dict[str, Any]:
         """Assemble the Jinja context every agent template renders against.
 
@@ -386,9 +387,7 @@ class AgentPreparer:
             "is_subagent": context.get("is_subagent", False),
             "parent_agent": context.get("parent_agent", None),
             "chat_history": context.get("chat_history", []),
-            "CWD": cwd,
-            "INVOKED_FROM": invoked_from,
-            "WORKSPACE_DIR": workspace_dir,
+            **paths,
         }
 
         # User-specified attachment `assign:` bindings win over built-in or
@@ -444,7 +443,8 @@ class AgentPreparer:
 
         agent_config = agent.config
 
-        all_attachments, attachment_bindings = self._resolve_attachments(agent_config, attachments)
+        paths = self._resolve_paths(path_context)
+        all_attachments, attachment_bindings = self._resolve_attachments(agent_config, attachments, paths)
 
         _skill_manager = self._install_skill_manager(agent_config, path_context)
 
@@ -469,7 +469,6 @@ class AgentPreparer:
             )
 
         interactive_mode = is_interactive()
-        cwd, invoked_from, workspace_dir = self._resolve_paths(path_context)
         full_context = self._build_template_context(
             agent_config=agent_config,
             prompt=prompt,
@@ -477,9 +476,7 @@ class AgentPreparer:
             directive_context={**prefetch_context, **tool_context, **exec_context},
             attachment_bindings=attachment_bindings,
             interactive_mode=interactive_mode,
-            cwd=cwd,
-            invoked_from=invoked_from,
-            workspace_dir=workspace_dir,
+            paths=paths,
         )
 
         renderer = AgentRenderer()
@@ -535,7 +532,7 @@ class AgentPreparer:
 
         system_message = build_system_prompt(tools, combined_instructions)
 
-        # Add environment context when invoked_from differs from CWD
+        cwd, invoked_from = paths["CWD"], paths["INVOKED_FROM"]
         if invoked_from and invoked_from != cwd:
             env_block = f"""
 ## Environment

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/tsugite/agent_runner/exec_runner.py

@@ -142,8 +142,9 @@ def run_python_block(
         workspace_dir: Optional workspace path for sandbox bind mounts.
 
     Raises:
-        RuntimeError: On timeout, on hard execution failure when not continuing,
-            or on non-coercible return-value types.
+        TimeoutError: On timeout.
+        RuntimeError: On hard execution failure when not continuing, or on
+            non-coercible return-value types.
     """
     safe_locals = _filter_json_safe(locals_dict)
 
@@ -162,7 +163,7 @@ def run_python_block(
         try:
             proc = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
         except subprocess.TimeoutExpired as e:
-            raise RuntimeError(f"tsu:exec block timed out after {timeout}s") from e
+            raise TimeoutError(f"tsu:exec block timed out after {timeout}s") from e
 
         result_data: Dict[str, Any] = {}
         if os.path.exists(result_path):

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/tsugite/agent_runner/helpers.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING, Any, List, Optional
 from rich.console import Console
 
 from tsugite.console import get_stderr_console
+from tsugite.exceptions import SandboxToolDeniedError  # noqa: F401
 
 if TYPE_CHECKING:
     from tsugite.options import ExecutionOptions
@@ -24,8 +25,8 @@ _stderr_console = get_stderr_console()
 _current_agent_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar("current_agent", default=None)
 
 # Active sandbox policy. Presence means "this agent is running sandboxed"; tools
-# read it to propagate the same isolation or to refuse. A nested run leaking its
-# teardown here would fail OPEN, so the reset is load-bearing.
+# read it to propagate the same isolation or to refuse. A nested run that leaks
+# its teardown here fails OPEN.
 _sandbox_context_var: contextvars.ContextVar[Optional["SandboxContext"]] = contextvars.ContextVar(
     "sandbox_context", default=None
 )
@@ -47,11 +48,6 @@ class SandboxContext:
     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"]) -> contextvars.Token:
     """Set (or clear, with None) the active sandbox policy. Returns a reset token."""
     return _sandbox_context_var.set(ctx)

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/tsugite/agent_runner/history_integration.py

@@ -231,11 +231,14 @@ def save_run_to_history(
     # agent ran to completion against this storage.
     existing = list(storage.iter_events())
     last_session_start = -1
+    last_user_input = -1
     last_model_response = -1
     last_session_end = -1
     for i, e in enumerate(existing):
         if e.type == "session_start":
             last_session_start = i
+        elif e.type == "user_input":
+            last_user_input = i
         elif e.type == "model_response":
             last_model_response = i
         elif e.type == "session_end":
@@ -244,7 +247,10 @@ def save_run_to_history(
     agent_already_recorded = last_model_response > last_session_start
 
     if agent_already_recorded:
-        if last_session_end <= last_session_start:
+        # A continued conversation pins session_start at index 0, so the current
+        # turn starts at its own user_input.
+        turn_start = max(last_session_start, last_user_input)
+        if last_session_end < turn_start:
             record_session_end(storage, status=status, error_message=error_message)
         return storage.session_id
 

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/tsugite/agent_runner/runner.py

@@ -646,10 +646,15 @@ async def _execute_agent_with_prompt(
         try:
             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,
-                source="cli",
+                source=meta.get("source") or "cli",
+                schedule_name=meta.get("schedule_id"),
+                input_tokens=agent.prompt_tokens,
+                output_tokens=agent.completion_tokens,
                 total_tokens=agent.total_tokens,
                 cost_usd=agent.reported_cost,
                 cache_creation_tokens=agent.cache_creation_tokens,

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/tsugite/agent_runner/steps.py

@@ -355,8 +355,8 @@ async def _execute_step_with_retries(
             step_duration = time.time() - step_start_time
             return step_result, step_duration
 
-        except asyncio.TimeoutError:
-            error_msg = f"Step timed out after {step.timeout} seconds"
+        except asyncio.TimeoutError as e:
+            error_msg = str(e) or f"Step timed out after {step.timeout} seconds"
             errors.append(error_msg)
             code_executed_this_attempt = False
         except AgentSkippedError:

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/tsugite/attachments/agent_config.py

@@ -17,12 +17,12 @@ from tsugite.utils import has_glob_chars
 logger = logging.getLogger(__name__)
 
 
-def _render_path(template: str) -> Optional[str]:
+def _render_path(template: str, template_vars: Dict[str, Any]) -> Optional[str]:
     """Render a Jinja path template; return None on render failure."""
     from tsugite.renderer import AgentRenderer
 
     try:
-        return AgentRenderer().render_string(template)
+        return AgentRenderer().render_string(template, template_vars)
     except Exception as e:
         logger.debug("Failed to render attachment path %r: %s", template, e)
         return None
@@ -67,6 +67,7 @@ def _expand_glob(pattern: str, workspace_path: Optional[Path]) -> List[Path]:
 def resolve_agent_config_attachments(
     items: List[Union[str, AttachmentSpec]],
     workspace_path: Optional[Path] = None,
+    template_vars: Optional[Dict[str, Any]] = None,
 ) -> Tuple[List[Attachment], Dict[str, Any]]:
     """Resolve agent config attachment items to Attachment objects and Jinja bindings.
 
@@ -76,6 +77,7 @@ def resolve_agent_config_attachments(
     Args:
         items: List of strings or AttachmentSpec objects from agent_config.attachments
         workspace_path: Optional workspace path for resolving relative paths
+        template_vars: Jinja variables for path templates (CWD, INVOKED_FROM, WORKSPACE_DIR)
 
     Returns:
         Tuple of (attachments to inject, dict of {assign_name: bound_value}).
@@ -90,13 +92,14 @@ def resolve_agent_config_attachments(
     file_handler = FileHandler()
     attachments: List[Attachment] = []
     bindings: Dict[str, Any] = {}
+    template_vars = template_vars or {}
 
     for item in items:
         before = len(attachments)
         if isinstance(item, str):
-            _resolve_string_item(item, workspace_path, file_handler, attachments)
+            _resolve_string_item(item, workspace_path, file_handler, attachments, template_vars)
         else:
-            _resolve_spec(item, workspace_path, file_handler, attachments, bindings)
+            _resolve_spec(item, workspace_path, file_handler, attachments, bindings, template_vars)
         # Tag everything this item produced with its cache tier (a spec's tier;
         # plain strings are always tier 0). The context turn renders one cache
         # block per tier so a volatile file only invalidates its own block.
@@ -113,9 +116,10 @@ def _resolve_string_item(
     workspace_path: Optional[Path],
     file_handler: "FileHandler",
     attachments: List[Attachment],
+    template_vars: Dict[str, Any],
 ) -> None:
-    """Legacy string handling: render Jinja, resolve path, fetch single file."""
-    rendered = _render_path(template)
+    """Render the Jinja path, resolve it, fetch the single file."""
+    rendered = _render_path(template, template_vars)
     if rendered is None:
         return
     resolved = _resolve_path(rendered, workspace_path)
@@ -134,9 +138,10 @@ def _resolve_spec(
     file_handler: "FileHandler",
     attachments: List[Attachment],
     bindings: Dict[str, Any],
+    template_vars: Dict[str, Any],
 ) -> None:
     """Resolve a single AttachmentSpec, populating attachments and bindings."""
-    rendered = _render_path(spec.path)
+    rendered = _render_path(spec.path, template_vars)
     if rendered is None:
         if spec.assign:
             bindings[spec.assign] = None

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/tsugite/attachments/auto_context.py

@@ -170,31 +170,22 @@ class AutoContextHandler(AttachmentHandler):
         return dirs
 
     def _discover_files(self, search_dirs: List[Path], context_files: List[str]) -> List[tuple[Path, str]]:
-        """Discover context files in search directories.
+        """Return every context file on the walk, outermost directory first.
 
-        Deduplicates by filename to prefer closer (more specific) directories.
-
-        Args:
-            search_dirs: Directories to search
-            context_files: List of filenames to search for
-
-        Returns:
-            List of (file_path, relative_name) tuples for found files
+        Names are relative to the outermost directory that has one. A nested
+        copy reads as `repos/app/AGENTS.md` next to the outer `AGENTS.md`.
         """
-        found = []
-        seen = set()
+        found: List[tuple[Path, str]] = []
+        outermost_dir: Optional[Path] = None
 
-        # Search in order (most specific directory first)
-        for directory in search_dirs:
+        for directory in reversed(search_dirs):
             for filename in context_files:
-                # Skip if we've already found a file with this name
-                if filename in seen:
-                    continue
-
                 file_path = directory / filename
-                if file_path.exists() and file_path.is_file():
-                    found.append((file_path, filename))
-                    seen.add(filename)
+                if not file_path.is_file():
+                    continue
+                if outermost_dir is None:
+                    outermost_dir = directory
+                found.append((file_path, file_path.relative_to(outermost_dir).as_posix()))
 
         return found
 

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/tsugite/attachments/base.py

@@ -68,8 +68,7 @@ class Attachment:
 
         ``key`` is the stable id used for dedupe and the UI chip; ``label`` is the
         human name the model and UI show; ``value`` is the text. Fills the text
-        content-type so context producers don't repeat it. This is the shape the
-        old ``ContextItem`` carried, now just an Attachment.
+        content-type so context producers don't repeat it.
         """
         return cls(
             name=label,
@@ -88,8 +87,7 @@ class Attachment:
 
     @property
     def value(self) -> str:
-        """The text content (an alias of ``content`` when it is text, else "").
-        Lets context code read ``.value`` the way the old ``ContextItem`` did."""
+        """The text content (an alias of ``content`` when it is text, else "")."""
         return self.content if isinstance(self.content, str) else ""
 
     def to_metadata(self) -> dict:

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/tsugite/builtin_agents/default.md

@@ -157,12 +157,12 @@ You are managing a shared channel. When a user asks for something that would ben
 - **Inline** - single edit, one-shot read, small calculation. Don't spawn anything.
 - **`spawn_job`** - background work: long-running tasks, parallel work, or delegating to a different agent/model. Fire-and-forget by default; add `acceptance_criteria=[...]` when "done" has a checkable shape (tests pass, copy satisfies criteria, refactor preserves behavior) and the verification loop becomes the value.
 
-**Acceptance criteria**: pass each criterion as a plain string. The verifier reads them verbatim and returns per-criterion pass/fail in `result.ac_results`:
+**Acceptance criteria**: pass each criterion as a plain string. A criterion starting with `cmd:<command>` (passes on exit 0), `exit_code:<command>:<n>` (passes on exit code `n`, default 0) or `file_exists:<path>` is checked in the Job's working directory with no verifier model. Write one whenever the check is mechanical. The verifier reads the rest verbatim and returns per-criterion pass/fail in `result.ac_results`:
 ```python-exec
 spawn_job(
     prompt="Refactor the agent loop to handle nested tool calls",
     acceptance_criteria=[
-        "All existing tests still pass",
+        "cmd:uv run pytest -q",
         "Adds at least 2 new tests for nested calls",
         "No new dependencies",
     ],

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/tsugite/cli/run.py

@@ -1,6 +1,7 @@
 """CLI run command - execute agents."""
 
 from pathlib import Path
+from types import SimpleNamespace
 from typing import Any, Dict, List, Optional, Tuple
 
 import typer
@@ -137,11 +138,18 @@ def _execute_agent_with_ui(
     """Execute agent with appropriate UI mode.
 
     Dispatch order:
-      1. --headless / --final-only -> custom_agent_ui with silent progress
-      2. fall-through default -> plain logger (covers no flags, --plain, piped/NO_COLOR)
+      1. --log-json -> JSONL event stream on stdout
+      2. --headless / --final-only -> custom_agent_ui with silent progress
+      3. fall-through default -> plain logger (covers no flags, --plain, piped/NO_COLOR)
     """
     from tsugite.ui import create_plain_logger, custom_agent_ui
 
+    if ui_opts.log_json:
+        from tsugite.ui.jsonl import JSONLUIHandler
+
+        executor_kwargs["custom_logger"] = SimpleNamespace(ui_handler=JSONLUIHandler())
+        return executor(**executor_kwargs)
+
     if ui_opts.headless or ui_opts.final_only:
         stderr_console = get_error_console(True, console)
         show_progress_items = ui_opts.verbose and not ui_opts.final_only
@@ -188,6 +196,9 @@ def _display_result(result_str: str, ui_opts: UIOptions, stderr_console: Console
 
     from tsugite.console import get_stdout_console
 
+    if ui_opts.log_json:
+        return
+
     if not (ui_opts.headless or ui_opts.final_only):
         stderr_console.print()
         stderr_console.rule("[bold green]Agent Execution Complete[/bold green]")
@@ -358,6 +369,10 @@ def run(
 
     if history_opts.storage_dir:
         history_opts.storage_dir.mkdir(parents=True, exist_ok=True)
+        from tsugite.history import set_history_backend
+        from tsugite.history.sqlite_backend import SqliteHistoryBackend
+
+        set_history_backend(SqliteHistoryBackend(history_opts.storage_dir / "history.db"))
 
     if ui_opts.no_color:
         console.no_color = True

{tsugite_cli-0.22.0 → tsugite_cli-0.23.0}/tsugite/core/agent.py

@@ -394,6 +394,8 @@ class TsugiteAgent:
         # cost data at all" (interrupted turn) - only the latter records NULL.
         self.cost_reported = False
         self.total_tokens = 0
+        self.prompt_tokens = 0
+        self.completion_tokens = 0
         self.last_input_tokens = 0
         self.cache_creation_tokens = 0
         self.cache_read_tokens = 0
@@ -1333,6 +1335,8 @@ class TsugiteAgent:
             return cost or 0.0
 
         self.total_tokens += usage.total_tokens
+        self.prompt_tokens += usage.prompt_tokens
+        self.completion_tokens += usage.completion_tokens
         self.last_input_tokens = (
             usage.prompt_tokens + (usage.cache_creation_input_tokens or 0) + (usage.cache_read_input_tokens or 0)
         )