tsugite-cli 0.19.1__tar.gz → 0.19.2__tar.gz

{tsugite_cli-0.19.1 → tsugite_cli-0.19.2}/AGENTS.md

@@ -20,8 +20,8 @@ uv run pytest tests/test_file.py::test_function
 # Run tests with coverage
 uv run pytest --cov=tsugite --cov-report=html
 
-# Lint and format
-uv run black .
+# Lint and format (CI gates on these, repo-wide)
+uv run ruff format .
 uv run ruff check .
 uv run pylint tsugite
 
@@ -504,7 +504,7 @@ Source lives at `plugins/tsugite-daemon/frontend/` (**Svelte 5 runes + TypeScrip
 
 - `mise run web-dev` - Vite dev server on :5173 with HMR, proxying `/api` to a local daemon on 127.0.0.1:8374 (`uv run tsu daemon`).
 - `mise run web-build` - production build into `tsugite_daemon/web/` (gitignored; never committed).
-- `mise run web-check` - svelte-check + vitest + prettier check.
+- `mise run web-check` - svelte-check + vitest unit project + prettier check. It does not run component tests (`*.svelte.test.ts`); those need `npm --prefix plugins/tsugite-daemon/frontend run test:browser`.
 
 ### Theme tokens
 
@@ -513,7 +513,7 @@ Source lives at `plugins/tsugite-daemon/frontend/` (**Svelte 5 runes + TypeScrip
 
 ### Testing
 
-- e2e selectors use `data-testid` values from `frontend/src/lib/testids.ts` (a frozen contract - extend, don't rename). App readiness marker: `[data-testid="app-ready"]`; test hooks hang off `window.__tsugite`.
+- e2e selectors use `data-testid` values from `frontend/src/lib/testids.ts` (a frozen contract - extend, don't rename). App readiness marker: `[data-testid="app-ready"]`. There are no window-global test hooks; drive the real DOM and seed over HTTP.
 - Frontend behavioral logic (stores, SSE replay, parsers/reducers) is vitest-tested (`frontend/src/**/*.test.ts`), failing-test-first.
 - Browser verification on UI changes is mandatory. Daemon spinup + Playwright wiring recipe: project memory `project_daemon_ui_smoketest.md` (its DOM selector list predates the Svelte rebuild - trust the testids contract instead).
 

{tsugite_cli-0.19.1 → tsugite_cli-0.19.2}/PKG-INFO

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

{tsugite_cli-0.19.1 → tsugite_cli-0.19.2}/pyproject.toml

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

{tsugite_cli-0.19.1 → tsugite_cli-0.19.2}/tsugite/agent_runner/runner.py

@@ -180,7 +180,7 @@ def get_default_instructions() -> str:
     return base + output + rules
 
 
-def _render_args(value: Any, renderer: AgentRenderer) -> Any:
+def _render_args(value: Any, renderer: AgentRenderer, context: Dict[str, Any]) -> Any:
     """Recursively render Jinja in string leaves of a tool args structure.
 
     Non-string values pass through unchanged. Strings without Jinja markers
@@ -189,13 +189,13 @@ def _render_args(value: Any, renderer: AgentRenderer) -> Any:
     if isinstance(value, str):
         if "{{" not in value and "{%" not in value:
             return value
-        return renderer.render_string(value, {})
+        return renderer.render_string(value, context)
     if isinstance(value, dict):
-        return {k: _render_args(v, renderer) for k, v in value.items()}
+        return {k: _render_args(v, renderer, context) for k, v in value.items()}
     if isinstance(value, list):
-        return [_render_args(v, renderer) for v in value]
+        return [_render_args(v, renderer, context) for v in value]
     if isinstance(value, tuple):
-        return tuple(_render_args(v, renderer) for v in value)
+        return tuple(_render_args(v, renderer, context) for v in value)
     return value
 
 
@@ -219,7 +219,7 @@ def execute_prefetch(prefetch_config: List[Dict[str, Any]], event_bus: Optional[
             continue
 
         try:
-            rendered_args = _render_args(args, renderer)
+            rendered_args = _render_args(args, renderer, context)
         except Exception as e:
             raise RuntimeError(f"Prefetch render failed for tool '{tool_name}': {e}") from e
 
@@ -245,7 +245,7 @@ def execute_tool_directives(
 
     Args:
         content: Markdown content with tool directives
-        existing_context: Current template context (for error messages, not used for execution)
+        existing_context: Current template context; directive args render against it
         event_bus: Optional event bus for emitting warnings
 
     Returns:
@@ -289,8 +289,11 @@ def execute_tool_directives(
     renderer = AgentRenderer()
 
     for directive in directives:
+        # Directives run in order, so each one renders against the caller's
+        # context (step assignments, prefetch results) plus whatever earlier
+        # directives in this same content have assigned.
         try:
-            rendered_args = _render_args(directive.args, renderer)
+            rendered_args = _render_args(directive.args, renderer, {**existing_context, **new_context})
         except Exception as e:
             raise RuntimeError(f"Tool directive render failed for '{directive.name}': {e}") from e
 

{tsugite_cli-0.19.1 → tsugite_cli-0.19.2}/tsugite/attachments/file.py

@@ -47,6 +47,39 @@ class FileHandler(AttachmentHandler):
         ),
     }
 
+    # `mimetypes` maps a number of plain-text formats into `application/*`
+    # (`.sh` -> `application/x-sh`, `.json` -> `application/json`), and which
+    # ones depends on the platform's mime.types. Reading those as documents
+    # base64-encodes source code the model was meant to read, so match them
+    # back to text. `+zip` and friends are deliberately absent from the
+    # structured suffixes: `application/epub+zip` is not text.
+    TEXT_MIME_TYPES = frozenset(
+        {
+            "application/ecmascript",
+            "application/javascript",
+            "application/json",
+            "application/sql",
+            "application/toml",
+            "application/x-csh",
+            "application/x-javascript",
+            "application/x-latex",
+            "application/x-perl",
+            "application/x-php",
+            "application/x-powershell",
+            "application/x-python",
+            "application/x-python-code",
+            "application/x-ruby",
+            "application/x-sh",
+            "application/x-shellscript",
+            "application/x-tcl",
+            "application/x-yaml",
+            "application/xml",
+            "application/yaml",
+        }
+    )
+
+    TEXT_MIME_SUFFIXES = ("+json", "+xml", "+yaml")
+
     def can_handle(self, source: str) -> bool:
         """Check if source is a file path.
 
@@ -92,12 +125,17 @@ class FileHandler(AttachmentHandler):
                 return (mime_type, AttachmentContentType.IMAGE)
             elif mime_type.startswith("audio/"):
                 return (mime_type, AttachmentContentType.AUDIO)
-            elif mime_type.startswith("application/"):
+            elif mime_type.startswith("application/") and not self._is_text_mime(mime_type):
                 return (mime_type, AttachmentContentType.DOCUMENT)
 
         # Default to text
         return ("text/plain", AttachmentContentType.TEXT)
 
+    @classmethod
+    def _is_text_mime(cls, mime_type: str) -> bool:
+        """Whether an `application/*` MIME type actually carries text."""
+        return mime_type in cls.TEXT_MIME_TYPES or mime_type.endswith(cls.TEXT_MIME_SUFFIXES)
+
     def fetch(self, source: str) -> Attachment:
         """Read file content.
 

{tsugite_cli-0.19.1 → tsugite_cli-0.19.2}/tsugite/cli/daemon.py

@@ -8,11 +8,17 @@ import typer
 from rich.console import Console
 from rich.panel import Panel
 
-from tsugite.config import get_xdg_data_path, get_xdg_write_path
+from tsugite.config import DEFAULT_DAEMON_HOST, DEFAULT_DAEMON_PORT, get_xdg_data_path, get_xdg_write_path
 
 daemon_app = typer.Typer(help="Daemon management commands")
 console = Console()
 
+# Connection flags shared by every daemon client command. Typer resolves
+# flag > env var > default natively, so there is nothing to hand-roll here.
+HOST_OPTION = typer.Option(DEFAULT_DAEMON_HOST, "--host", envvar="TSUGITE_DAEMON_HOST", help="Daemon HTTP host")
+PORT_OPTION = typer.Option(DEFAULT_DAEMON_PORT, "--port", "-p", envvar="TSUGITE_DAEMON_PORT", help="Daemon HTTP port")
+TOKEN_OPTION = typer.Option(None, "--token", "-t", envvar="TSUGITE_DAEMON_TOKEN", help="Auth token")
+
 
 def _get_questionary_style():
     """Lazy load questionary style."""
@@ -394,9 +400,9 @@ def _daemon_request(method: str, host: str, port: int, path: str, token: Optiona
 @daemon_app.command("sessions")
 def list_sessions(
     agent: str = typer.Argument(help="Agent name"),
-    host: str = typer.Option("127.0.0.1", "--host", help="Daemon HTTP host"),
-    port: int = typer.Option(8321, "--port", "-p", help="Daemon HTTP port"),
-    token: Optional[str] = typer.Option(None, "--token", "-t", help="Auth token"),
+    host: str = HOST_OPTION,
+    port: int = PORT_OPTION,
+    token: Optional[str] = TOKEN_OPTION,
 ):
     """List active sessions for a daemon agent."""
     data = _daemon_request("GET", host, port, f"/api/agents/{agent}/sessions", token)
@@ -421,9 +427,9 @@ def list_sessions(
 def compact_session(
     agent: str = typer.Argument(help="Agent name"),
     user_id: str = typer.Option("web-anonymous", "--user", "-u", help="User ID to compact"),
-    host: str = typer.Option("127.0.0.1", "--host", help="Daemon HTTP host"),
-    port: int = typer.Option(8321, "--port", "-p", help="Daemon HTTP port"),
-    token: Optional[str] = typer.Option(None, "--token", "-t", help="Auth token"),
+    host: str = HOST_OPTION,
+    port: int = PORT_OPTION,
+    token: Optional[str] = TOKEN_OPTION,
 ):
     """Force compact a daemon session."""
     data = _daemon_request(
@@ -451,9 +457,9 @@ daemon_app.add_typer(session_app, name="session")
 @session_app.command("set-primary")
 def session_set_primary(
     session_id: str = typer.Argument(help="Session ID to mark as primary"),
-    host: str = typer.Option("127.0.0.1", "--host", help="Daemon HTTP host"),
-    port: int = typer.Option(8321, "--port", "-p", help="Daemon HTTP port"),
-    token: Optional[str] = typer.Option(None, "--token", "-t", help="Auth token"),
+    host: str = HOST_OPTION,
+    port: int = PORT_OPTION,
+    token: Optional[str] = TOKEN_OPTION,
 ):
     """Mark a session as the user's primary for its agent."""
     _daemon_request("POST", host, port, f"/api/sessions/{session_id}/set-primary", token, json={})
@@ -464,9 +470,9 @@ def session_set_primary(
 def session_clear_primary(
     agent: str = typer.Option(..., "--agent", "-a", help="Agent name"),
     user_id: str = typer.Option("web-anonymous", "--user", "-u", help="User ID"),
-    host: str = typer.Option("127.0.0.1", "--host", help="Daemon HTTP host"),
-    port: int = typer.Option(8321, "--port", "-p", help="Daemon HTTP port"),
-    token: Optional[str] = typer.Option(None, "--token", "-t", help="Auth token"),
+    host: str = HOST_OPTION,
+    port: int = PORT_OPTION,
+    token: Optional[str] = TOKEN_OPTION,
 ):
     """Remove the primary flag from any session for (user, agent)."""
     from urllib.parse import urlencode
@@ -478,9 +484,9 @@ def session_clear_primary(
 
 @session_app.command("list")
 def session_list(
-    host: str = typer.Option("127.0.0.1", "--host", help="Daemon HTTP host"),
-    port: int = typer.Option(8321, "--port", "-p", help="Daemon HTTP port"),
-    token: Optional[str] = typer.Option(None, "--token", "-t", help="Auth token"),
+    host: str = HOST_OPTION,
+    port: int = PORT_OPTION,
+    token: Optional[str] = TOKEN_OPTION,
 ):
     """List all daemon sessions, indicating which one is primary."""
     from rich.table import Table
@@ -525,9 +531,9 @@ def _parse_every_to_cron(every: str) -> str:
 
 @schedule_app.command("list")
 def schedule_list(
-    host: str = typer.Option("127.0.0.1", "--host", help="Daemon HTTP host"),
-    port: int = typer.Option(8321, "--port", "-p", help="Daemon HTTP port"),
-    token: Optional[str] = typer.Option(None, "--token", "-t", help="Auth token"),
+    host: str = HOST_OPTION,
+    port: int = PORT_OPTION,
+    token: Optional[str] = TOKEN_OPTION,
 ):
     """List all schedules."""
     from rich.table import Table
@@ -579,9 +585,9 @@ def schedule_add(
         "--target-session",
         help="Where the inject_history turn lands: primary, originating, none, name:<n>, or <session_id>",
     ),
-    host: str = typer.Option("127.0.0.1", "--host", help="Daemon HTTP host"),
-    port: int = typer.Option(8321, "--port", help="Daemon HTTP port"),
-    token: Optional[str] = typer.Option(None, "--token", "-t", help="Auth token"),
+    host: str = HOST_OPTION,
+    port: int = PORT_OPTION,
+    token: Optional[str] = TOKEN_OPTION,
 ):
     """Add a new schedule."""
     spec_count = sum(1 for x in (cron, at, every) if x is not None)
@@ -617,9 +623,9 @@ def schedule_add(
 
 @schedule_app.command("cleanup")
 def schedule_cleanup(
-    host: str = typer.Option("127.0.0.1", "--host", help="Daemon HTTP host"),
-    port: int = typer.Option(8321, "--port", help="Daemon HTTP port"),
-    token: Optional[str] = typer.Option(None, "--token", "-t", help="Auth token"),
+    host: str = HOST_OPTION,
+    port: int = PORT_OPTION,
+    token: Optional[str] = TOKEN_OPTION,
 ):
     """Remove all orphaned one-off schedules (disabled, already fired)."""
     data = _daemon_request("POST", host, port, "/api/schedules/cleanup", token)
@@ -635,9 +641,9 @@ def schedule_cleanup(
 @schedule_app.command("remove")
 def schedule_remove(
     schedule_id: str = typer.Argument(help="Schedule ID to remove"),
-    host: str = typer.Option("127.0.0.1", "--host", help="Daemon HTTP host"),
-    port: int = typer.Option(8321, "--port", "-p", help="Daemon HTTP port"),
-    token: Optional[str] = typer.Option(None, "--token", "-t", help="Auth token"),
+    host: str = HOST_OPTION,
+    port: int = PORT_OPTION,
+    token: Optional[str] = TOKEN_OPTION,
 ):
     """Remove a schedule."""
     _daemon_request("DELETE", host, port, f"/api/schedules/{schedule_id}", token)
@@ -647,9 +653,9 @@ def schedule_remove(
 @schedule_app.command("enable")
 def schedule_enable(
     schedule_id: str = typer.Argument(help="Schedule ID"),
-    host: str = typer.Option("127.0.0.1", "--host", help="Daemon HTTP host"),
-    port: int = typer.Option(8321, "--port", "-p", help="Daemon HTTP port"),
-    token: Optional[str] = typer.Option(None, "--token", "-t", help="Auth token"),
+    host: str = HOST_OPTION,
+    port: int = PORT_OPTION,
+    token: Optional[str] = TOKEN_OPTION,
 ):
     """Enable a schedule."""
     _daemon_request("POST", host, port, f"/api/schedules/{schedule_id}/enable", token)
@@ -659,9 +665,9 @@ def schedule_enable(
 @schedule_app.command("disable")
 def schedule_disable(
     schedule_id: str = typer.Argument(help="Schedule ID"),
-    host: str = typer.Option("127.0.0.1", "--host", help="Daemon HTTP host"),
-    port: int = typer.Option(8321, "--port", "-p", help="Daemon HTTP port"),
-    token: Optional[str] = typer.Option(None, "--token", "-t", help="Auth token"),
+    host: str = HOST_OPTION,
+    port: int = PORT_OPTION,
+    token: Optional[str] = TOKEN_OPTION,
 ):
     """Disable a schedule."""
     _daemon_request("POST", host, port, f"/api/schedules/{schedule_id}/disable", token)
@@ -671,9 +677,9 @@ def schedule_disable(
 @schedule_app.command("run")
 def schedule_run(
     schedule_id: str = typer.Argument(help="Schedule ID to trigger now"),
-    host: str = typer.Option("127.0.0.1", "--host", help="Daemon HTTP host"),
-    port: int = typer.Option(8321, "--port", "-p", help="Daemon HTTP port"),
-    token: Optional[str] = typer.Option(None, "--token", "-t", help="Auth token"),
+    host: str = HOST_OPTION,
+    port: int = PORT_OPTION,
+    token: Optional[str] = TOKEN_OPTION,
 ):
     """Trigger a schedule immediately."""
     _daemon_request("POST", host, port, f"/api/schedules/{schedule_id}/run", token)
@@ -683,9 +689,9 @@ def schedule_run(
 @schedule_app.command("show")
 def schedule_show(
     schedule_id: str = typer.Argument(help="Schedule ID"),
-    host: str = typer.Option("127.0.0.1", "--host", help="Daemon HTTP host"),
-    port: int = typer.Option(8321, "--port", "-p", help="Daemon HTTP port"),
-    token: Optional[str] = typer.Option(None, "--token", "-t", help="Auth token"),
+    host: str = HOST_OPTION,
+    port: int = PORT_OPTION,
+    token: Optional[str] = TOKEN_OPTION,
 ):
     """Show schedule details."""
     data = _daemon_request("GET", host, port, f"/api/schedules/{schedule_id}", token)

{tsugite_cli-0.19.1 → tsugite_cli-0.19.2}/tsugite/config.py

@@ -7,6 +7,12 @@ from typing import Callable, Dict, List, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
+# The address the daemon serves on by default. Defined here rather than in the
+# daemon plugin so the server's bind default and the client's connect default
+# cannot drift apart; tsugite_daemon.config.HTTPConfig imports these.
+DEFAULT_DAEMON_HOST = "127.0.0.1"
+DEFAULT_DAEMON_PORT = 8374
+
 # XDG Base Directory utilities
 
 

{tsugite_cli-0.19.1 → tsugite_cli-0.19.2}/tsugite/core/agent.py

@@ -10,14 +10,9 @@ import time
 from dataclasses import asdict, dataclass, field, is_dataclass
 from typing import Any, Callable, Dict, List, Optional
 
-logger = logging.getLogger(__name__)
-
-# Cap the persisted return_value repr so a huge structured return doesn't bloat the event.
-RETURN_VALUE_REPR_MAX = 2048
-
-from tsugite.attachments.base import Attachment, AttachmentContentType, format_attachment_open_tag  # noqa: E402
-from tsugite.cancellation import is_cancelled  # noqa: E402
-from tsugite.events import (  # noqa: E402
+from tsugite.attachments.base import Attachment, AttachmentContentType, format_attachment_open_tag
+from tsugite.cancellation import is_cancelled
+from tsugite.events import (
     CodeExecutionEvent,
     ContentBlockEvent,
     CostSummaryEvent,
@@ -36,17 +31,21 @@ from tsugite.events import (  # noqa: E402
     TaskStartEvent,
     WarningEvent,
 )
-from tsugite.providers.base import CompletionResponse as ProviderResponse  # noqa: E402
-from tsugite.skill_discovery import Skill  # noqa: E402
+from tsugite.providers.base import CompletionResponse as ProviderResponse
+from tsugite.skill_discovery import Skill
 
-from .content_blocks import extract_content_blocks  # noqa: E402
-from .executor import Executor  # noqa: E402
-from .executor_registry import get_executor_class  # noqa: E402
-from .memory import AgentMemory, StepResult  # noqa: E402
-from .tools import Tool  # noqa: E402
+from .content_blocks import extract_content_blocks
+from .executor import Executor
+from .executor_registry import get_executor_class
+from .memory import AgentMemory, StepResult
+from .tools import Tool
 
-# Agent execution constants
-DEFAULT_MAX_TURNS = 10  # Default maximum reasoning iterations before timeout
+logger = logging.getLogger(__name__)
+
+# Cap the persisted return_value repr so a huge structured return doesn't bloat the event.
+RETURN_VALUE_REPR_MAX = 2048
+
+DEFAULT_MAX_TURNS = 10  # Maximum reasoning iterations before the run is cut off
 
 _LLM_WAIT_HEARTBEAT_INTERVAL = 10.0
 
@@ -108,7 +107,7 @@ def build_system_prompt(tools: List[Tool], instructions: str = "") -> str:
 _EXEC_FENCE = "```python-exec"
 _CLOSE_FENCE = "\n```"
 
-# Start-of-line ```python fence whose info string is exactly "python" (bare) — i.e.
+# Start-of-line ```python fence whose info string is exactly "python" (bare) - i.e.
 # NOT ```python-exec. Used to nudge the model toward the exec fence when it emits a
 # bare block. The negative lookahead keeps ```python-exec from matching.
 _BARE_PYTHON_FENCE = re.compile(r"(?:^|\n)```python(?!-exec)[ \t]*\r?\n")
@@ -450,7 +449,7 @@ class TsugiteAgent:
                     await self.executor.inject_content_blocks(turn.content_blocks)
 
                 # Multiple python blocks: the parser already took just the first
-                # one as `code`. Surface the drop on two channels — a UI warning
+                # one as `code`. Surface the drop on two channels - a UI warning
                 # for the human, and an in-conversation observation for the
                 # model. Without the latter the model sees its full N-block
                 # response in raw_content but only one execution result, and
@@ -621,7 +620,7 @@ class TsugiteAgent:
                 from tsugite.agent_runner.history_integration import record_final_result, record_session_end
 
                 # Durable answer record for run paths with no live SSE persist
-                # (scheduled, subprocess, CLI) — the conversation view renders
+                # (scheduled, subprocess, CLI) - the conversation view renders
                 # the answer bubble from this event.
                 record_final_result(
                     self.storage,
@@ -1187,46 +1186,30 @@ class TsugiteAgent:
     def _compute_token_breakdown(self, messages: List[Dict]) -> Dict:
         """Compute per-category token breakdown with individual item details."""
         est = estimate_content_tokens
-        categories = []
-
-        # Instructions (system prompt minus tools)
-        instructions_tokens = est(self.instructions) if self.instructions else 0
-        categories.append({"name": "instructions", "tokens": instructions_tokens, "items": []})
-
-        # Tools — per-tool breakdown
-        tool_items = []
-        for tool in self.tools:
-            tok = est(tool.to_code_prompt())
-            tool_items.append({"name": tool.name, "tokens": tok})
-        tool_items.sort(key=lambda x: x["tokens"], reverse=True)
-        tools_total = sum(t["tokens"] for t in tool_items)
-        categories.append({"name": "tools", "tokens": tools_total, "items": tool_items})
-
-        # Attachments — per-attachment breakdown
-        att_items = []
-        for att in self.attachments:
-            tok = est(att.content) if att.content else 0
-            att_items.append({"name": att.name, "tokens": tok})
-        att_total = sum(a["tokens"] for a in att_items)
-        categories.append({"name": "attachments", "tokens": att_total, "items": att_items})
-
-        # Skills — per-skill breakdown
-        skill_items = []
-        for skill in self.skills:
-            tok = est(skill.content) if skill.content else 0
-            skill_items.append({"name": skill.name, "tokens": tok})
-        skills_total = sum(s["tokens"] for s in skill_items)
-        categories.append({"name": "skills", "tokens": skills_total, "items": skill_items})
-
-        # Hooks (pre_message hook captured output like rag_context)
-        hook_items = []
-        for name, content in self.hook_vars.items():
-            tok = est(content) if content else 0
-            hook_items.append({"name": name, "tokens": tok})
-        hooks_total = sum(h["tokens"] for h in hook_items)
-        categories.append({"name": "hooks", "tokens": hooks_total, "items": hook_items})
-
-        # History — walk messages between context turn and task
+
+        def itemized(name: str, items: list) -> Dict:
+            return {"name": name, "tokens": sum(i["tokens"] for i in items), "items": items}
+
+        # Tools sort largest-first; the other item lists keep their natural order.
+        tool_items = sorted(
+            ({"name": t.name, "tokens": est(t.to_code_prompt())} for t in self.tools),
+            key=lambda i: i["tokens"],
+            reverse=True,
+        )
+        categories = [
+            # The system prompt minus tools; no per-item breakdown to give.
+            {"name": "instructions", "tokens": est(self.instructions) if self.instructions else 0, "items": []},
+            itemized("tools", tool_items),
+            itemized(
+                "attachments",
+                [{"name": a.name, "tokens": est(a.content) if a.content else 0} for a in self.attachments],
+            ),
+            itemized("skills", [{"name": s.name, "tokens": est(s.content) if s.content else 0} for s in self.skills]),
+            # Hooks carry pre_message captured output, e.g. rag_context.
+            itemized("hooks", [{"name": n, "tokens": est(c) if c else 0} for n, c in self.hook_vars.items()]),
+        ]
+
+        # History - walk messages between context turn and task
         history_tokens = 0
         i = 0
         n = len(messages)

{tsugite_cli-0.19.1 → tsugite_cli-0.19.2}/tsugite/core/executor.py

@@ -22,6 +22,7 @@ from typing import Any, Callable, Dict, Iterator, List, Optional, Protocol, runt
 
 from tsugite.core.state import load_state, save_state
 from tsugite.exceptions import StateSerializationError
+from tsugite.secrets.redaction import redact_sensitive_obj
 
 PPRINT_WIDTH = 100
 
@@ -114,15 +115,7 @@ class ExecutionResult:
     last_statement_type: Optional[str] = None  # "expr" | "statement" | None (unparsed) - history replay metadata
 
     def to_xml(self, duration_ms: int = 0, max_output_kb: int = MAX_EXECUTION_OUTPUT_KB) -> str:
-        """Convert execution result to structured XML format.
-
-        Args:
-            duration_ms: Execution duration in milliseconds
-            max_output_kb: Maximum output size in KB before truncation
-
-        Returns:
-            XML string with execution result
-        """
+        """Render the result as the XML observation replayed to the model."""
         from xml.sax.saxutils import escape
 
         from tsugite.secrets.registry import get_registry
@@ -148,7 +141,6 @@ class ExecutionResult:
 
         if self.error:
             parts.append(f"<error>{escape(_mask(self.error))}</error>")
-            # Include traceback from stderr (last 10 lines)
             if self.stderr:
                 tb_lines = _mask(self.stderr).strip().split("\n")[-10:]
                 parts.append(f"<traceback>{escape(chr(10).join(tb_lines))}</traceback>")
@@ -217,14 +209,7 @@ def _summarize_mapping(items) -> Dict[str, str]:
 
 
 def _summarize_variable(value: Any) -> str:
-    """Summarize a variable's type and size for display.
-
-    Args:
-        value: The variable value to summarize
-
-    Returns:
-        Summary string like "dict(3 keys)" or "list(5 items)"
-    """
+    """Summarize a variable's type and size for display, e.g. "dict(3 keys)"."""
     t = type(value).__name__
     if isinstance(value, dict):
         return f"{t}({len(value)} keys)"
@@ -421,23 +406,13 @@ class LocalExecutor:
         return ns
 
     def _split_code_for_last_expr(self, code: str) -> tuple[str, Optional[str]]:
-        """Split code into setup and last expression if applicable.
-
-        If the last statement is an expression, return (setup, last_expr).
-        Otherwise, return (code, None).
-
-        Args:
-            code: Python code to analyze
-
-        Returns:
-            Tuple of (setup_code, last_expression_or_none)
-        """
+        """Split code into (setup, last_expression) when the last statement is an
+        expression, so it can be eval'd for REPL-style display. Otherwise (code, None)."""
         try:
             tree = ast.parse(code)
             if not tree.body:
                 return (code, None)
 
-            # Check if last statement is an expression
             last_node = tree.body[-1]
             if not isinstance(last_node, ast.Expr):
                 return (code, None)
@@ -473,16 +448,7 @@ class LocalExecutor:
         return "expr" if isinstance(tree.body[-1], ast.Expr) else "statement"
 
     def _format_value(self, value: Any) -> str:
-        """Format a value for display.
-
-        Uses pprint for complex objects, repr for simple ones.
-
-        Args:
-            value: Value to format
-
-        Returns:
-            Formatted string representation
-        """
+        """Format a value for display: pprint for containers, repr for everything else."""
         if isinstance(value, (dict, list, tuple, set)):
             return pprint.pformat(value, width=PPRINT_WIDTH, compact=False)
         return repr(value)
@@ -505,12 +471,6 @@ class LocalExecutor:
         Automatically displays the value of the last expression (REPL-like behavior).
         When a workspace is bound, chdir to it under a process-wide lock so raw
         Python file APIs (os.getcwd, open, Path.cwd) resolve against the workspace.
-
-        Args:
-            code: Python code to execute
-
-        Returns:
-            ExecutionResult with output, error, stdout, stderr, return_value, tools_called, and variables_set
         """
         self._return_value = None
         self._tools_called = []
@@ -666,10 +626,14 @@ class LocalExecutor:
         def tool_wrapper(*args, **kwargs):
             self._tools_called.append(tool_obj.name)
             convert_positional_to_kwargs(tool_obj, args, kwargs)
-            record: Dict[str, Any] = {"tool": tool_obj.name, "arguments": _jsonable_call_args(kwargs)}
+            # Redact BEFORE _jsonable_call_args: it flattens nested values into
+            # capped repr() strings, and a token baked into one of those is no
+            # longer reachable by key or path.
+            audit_args = redact_sensitive_obj(kwargs, getattr(tool_obj, "sensitive_paths", ()))
+            record: Dict[str, Any] = {"tool": tool_obj.name, "arguments": _jsonable_call_args(audit_args)}
             self._tool_calls.append(record)
             if self.event_bus:
-                self.event_bus.emit(ToolCallEvent(tool_name=tool_obj.name, arguments=kwargs))
+                self.event_bus.emit(ToolCallEvent(tool_name=tool_obj.name, arguments=audit_args))
             t0 = time.perf_counter()
             try:
                 result = run_async_in_sync_context(tool_obj.execute(**kwargs))
@@ -718,14 +682,7 @@ class LocalExecutor:
         self.namespace.update(tools)
 
     def register_loaded_skill(self, name: str, content: str):
-        """Register a skill loaded during this execution turn.
-
-        Called by load_skill() tool to track skills for observation embedding.
-
-        Args:
-            name: Skill name
-            content: Rendered skill content
-        """
+        """Register a skill loaded during this turn. Called by the load_skill() tool."""
         self._loaded_skills_for_turn[name] = content
 
     def register_unloaded_skill(self, name: str):