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

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

@@ -83,7 +83,7 @@ Tsugite is an agentic CLI that executes AI agents defined as markdown files with
      - `./{name}.md` (current directory)
      - `builtin_agents/{name}.md` (package-provided)
      - Global directories (`~/.config/tsugite/agents/`)
-   - Merges agent inheritance chains (scalars override, lists merge, dicts deep merge)
+   - Merges agent inheritance chains (scalars and dicts override, lists merge)
 
 3. **Agent Parsing** (`tsugite/md_agents.py`)
    - Parses YAML frontmatter → `AgentConfig` (Pydantic model)

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.19.2"
+version = "0.20.0"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"
@@ -93,6 +93,7 @@ tsugite-pty = { workspace = true }
 tsugite-daemon = { workspace = true }
 tsugite-discord = { workspace = true }
 tsugite-cc-driver = { workspace = true }
+tsugite-onlyoffice = { workspace = true }
 
 [tool.ruff]
 target-version = "py311"
@@ -170,6 +171,7 @@ paths = [
   "plugins/tsugite-codex-cli/tsugite_codex_cli",
   "plugins/tsugite-daemon/tsugite_daemon",
   "plugins/tsugite-discord/tsugite_discord",
+  "plugins/tsugite-onlyoffice/tsugite_onlyoffice",
   "plugins/tsugite-pty/tsugite_pty",
   "plugins/tsugite-sandbox/tsugite_sandbox",
   "plugins/tsugite-tmux/tsugite_tmux",
@@ -268,4 +270,5 @@ dev = [
   "tsugite-daemon",
   "tsugite-discord",
   "tsugite-cc-driver",
+  "tsugite-onlyoffice",
 ]

{tsugite_cli-0.19.2 → tsugite_cli-0.20.0}/tsugite/agent_inheritance.py

@@ -293,18 +293,16 @@ def merge_agent_configs(parent, child):
     Returns:
         Merged AgentConfig with child taking precedence
 
-    Merge rules:
-    - Scalars (model, max_turns, reasoning_effort, etc.): child overwrites parent
-    - Lists (tools, attachments): merge and deduplicate
+    Merge rules, applied in order so the later ones win:
+    - Every field: child overwrites parent, dicts included (model_kwargs, network, sandbox)
+    - Lists (tools, attachments, skill_paths): merge and deduplicate
     - Lists (prefetch): concatenate (parent first, no deduplication)
     - Lists of dicts (custom_tools): merge and deduplicate by "name" field
     - Strings (instructions): concatenate with newline
     """
     from .md_agents import AgentConfig
 
-    # Merge all field types
-    merged_data = {}
-    merged_data.update(merge_scalar_fields(parent, child))
+    merged_data = merge_all_fields(parent, child)
     merged_data.update(merge_list_fields(parent, child))
     merged_data["instructions"] = merge_instructions(parent, child)
 
@@ -389,33 +387,29 @@ def _get_default_base_agent_name() -> Optional[str]:
         return "default"
 
 
-def merge_scalar_fields(parent, child) -> Dict[str, Any]:
-    """Merge scalar fields from parent and child configs.
+def merge_all_fields(parent, child) -> Dict[str, Any]:
+    """Merge every AgentConfig field, so a newly added one is never dropped.
 
-    Child values take precedence when explicitly set.
-
-    Args:
-        parent: Parent AgentConfig
-        child: Child AgentConfig
-
-    Returns:
-        Dict of merged scalar fields
+    A child takes precedence when it set the field to something other than `None`
+    or `""`, both of which read as "leave this to the parent". `merge_agent_configs`
+    then overwrites the fields that have their own strategy.
     """
-    return {
-        "name": child.name if child.name else parent.name,
-        "description": child.description if child.description else parent.description,
-        "model": child.model if child.model else parent.model,
-        "max_turns": child.max_turns if child.max_turns != 5 else parent.max_turns,
-        "reasoning_effort": child.reasoning_effort if child.reasoning_effort else parent.reasoning_effort,
-        "auto_load_agent_list": child.auto_load_agent_list or parent.auto_load_agent_list,
-    }
+    merged = {}
+    for field_name in type(child).model_fields:
+        value = getattr(child, field_name)
+        child_wins = field_name in child.model_fields_set and value not in (None, "")
+        merged[field_name] = value if child_wins else getattr(parent, field_name)
+
+    # `extends` names this agent's own parent, so it describes the child alone.
+    merged["extends"] = child.extends
+    return merged
 
 
 def merge_list_fields(parent, child) -> Dict[str, List]:
     """Merge list fields from parent and child configs.
 
     Different list types have different merge strategies:
-    - tools, attachments: merge and deduplicate
+    - tools, attachments, skill_paths: merge and deduplicate
     - prefetch: concatenate (parent first)
     - custom_tools: deduplicate by "name" field
 
@@ -449,6 +443,7 @@ def merge_list_fields(parent, child) -> Dict[str, List]:
     merged_attachments = _merge_attachments(parent.attachments, child.attachments)
     merged_skills = _merge_dedup(parent.auto_load_skills, child.auto_load_skills)
     merged_auto_load_agents = _merge_dedup(parent.auto_load_agents, child.auto_load_agents)
+    merged_skill_paths = _merge_dedup(parent.skill_paths, child.skill_paths)
 
     # Custom tools - deduplicate by "name" field (child overrides parent)
     custom_tool_dict = {}
@@ -462,6 +457,7 @@ def merge_list_fields(parent, child) -> Dict[str, List]:
         "custom_tools": list(custom_tool_dict.values()),
         "auto_load_skills": merged_skills,
         "auto_load_agents": merged_auto_load_agents,
+        "skill_paths": merged_skill_paths,
     }
 
 

{tsugite_cli-0.19.2 → tsugite_cli-0.20.0}/tsugite/agent_runner/helpers.py

@@ -302,15 +302,18 @@ def get_ui_handler(custom_logger: Optional[Any]) -> Optional[Any]:
 def set_multistep_ui_context(custom_logger: Optional[Any], step_number: int, step_name: str, total_steps: int) -> None:
     """Set multistep context in UI handler if available.
 
+    Only a handler that renders a live progress display tracks this, and the handler
+    contract is `handle_event` alone - a plugin may ship one subclassing nothing.
+
     Args:
         custom_logger: Custom logger instance (may be None)
         step_number: Current step number
         step_name: Name of current step
         total_steps: Total number of steps
     """
-    ui_handler = get_ui_handler(custom_logger)
-    if ui_handler:
-        ui_handler.set_multistep_context(step_number, step_name, total_steps)
+    setter = getattr(get_ui_handler(custom_logger), "set_multistep_context", None)
+    if setter:
+        setter(step_number, step_name, total_steps)
 
 
 def clear_multistep_ui_context(custom_logger: Optional[Any]) -> None:
@@ -319,9 +322,9 @@ def clear_multistep_ui_context(custom_logger: Optional[Any]) -> None:
     Args:
         custom_logger: Custom logger instance (may be None)
     """
-    ui_handler = get_ui_handler(custom_logger)
-    if ui_handler:
-        ui_handler.clear_multistep_context()
+    clearer = getattr(get_ui_handler(custom_logger), "clear_multistep_context", None)
+    if clearer:
+        clearer()
 
 
 def print_step_progress(

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

@@ -461,19 +461,17 @@ async def _execute_agent_with_prompt(
     # Register per-agent custom shell tools (if any)
     if agent_config.custom_tools:
         from tsugite.shell_tool_config import parse_tool_definition_from_dict
-        from tsugite.tools.shell_tools import register_shell_tools
+        from tsugite.tools.shell_tools import bind_custom_tools
 
         try:
             custom_tool_definitions = [
                 parse_tool_definition_from_dict(tool_dict) for tool_dict in agent_config.custom_tools
             ]
-            register_shell_tools(custom_tool_definitions)
-
-            # Add custom tool names to the tool list
-            for tool_def in custom_tool_definitions:
-                from tsugite.core.tools import create_tool_from_tsugite
-
-                tools.append(create_tool_from_tsugite(tool_def.name))
+            # This run's own definitions win over anything the registry resolved
+            # under the same name for an earlier agent.
+            for custom in bind_custom_tools(custom_tool_definitions):
+                tools = [t for t in tools if t.name != custom.name]
+                tools.append(custom)
         except Exception as e:
             event_bus.emit(WarningEvent(message=f"Failed to register custom tools: {e}"))
 

{tsugite_cli-0.19.2 → tsugite_cli-0.20.0}/tsugite/cli/__init__.py

@@ -17,6 +17,29 @@ app = typer.Typer(
 console = Console()
 
 
+def _print_version(value: bool) -> None:
+    if not value:
+        return
+    from tsugite import __version__
+
+    console.print(f"Tsugite version {__version__}")
+    raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        callback=_print_version,
+        is_eager=True,
+        help="Show version information.",
+    ),
+) -> None:
+    pass
+
+
 @app.command()
 def version():
     """Show version information."""

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

@@ -1,6 +1,9 @@
 """Daemon management CLI commands."""
 
+import logging
+import os
 import re
+import sys
 from pathlib import Path
 from typing import Optional
 
@@ -792,6 +795,14 @@ def token_revoke(
         raise typer.Exit(1)
 
 
+def _reexec(start_cwd: str) -> None:
+    """Replace this process with a fresh daemon; exec discards buffered log records, so flush first."""
+    console.print("[cyan]Restarting daemon...[/cyan]")
+    os.chdir(start_cwd)
+    logging.shutdown()
+    os.execv(sys.executable, [sys.executable, *sys.argv])
+
+
 @daemon_app.callback(invoke_without_command=True)
 def daemon_main(
     ctx: typer.Context,
@@ -827,12 +838,20 @@ def daemon_main(
     if log_to_console is not None:
         overrides["log_to_console"] = log_to_console
 
+    restarting = False
+    # Agent code execution chdirs the whole process around, so the cwd at exec
+    # time is not necessarily the one the daemon was started from.
+    start_cwd = os.getcwd()
+
     try:
-        asyncio.run(run_daemon(config, config_overrides=overrides or None))
+        restarting = asyncio.run(run_daemon(config, config_overrides=overrides or None))
     except (KeyboardInterrupt, SystemExit, RuntimeError):
         pass
     finally:
         console.print("\n[yellow]Daemon stopped[/yellow]")
 
+    if restarting:
+        _reexec(start_cwd)
+
 
 __all__ = ["daemon_app"]

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

@@ -3,7 +3,7 @@
 import json
 import os
 from pathlib import Path
-from typing import Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -149,6 +149,7 @@ class Config(BaseModel):
     skill_paths: List[str] = Field(default_factory=list)
     agent_paths: List[str] = Field(default_factory=list)
     skill_ttl_default: int = 10
+    plugins: Dict[str, Dict[str, Any]] = Field(default_factory=dict)
     secrets: Optional[SecretsConfig] = None
     history: Optional[HistoryConfig] = None
     sandbox: Optional[SandboxSettings] = None

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

@@ -152,6 +152,25 @@ def _has_bare_python_fence(cleaned: str) -> bool:
     return _BARE_PYTHON_FENCE.search(cleaned) is not None
 
 
+# Tool-call envelopes a model may emit as text instead of a ```python-exec
+# block. Nothing here executes them, so such a reply did no work. An envelope
+# carries structure (`<invoke name="...">`, or an opening tag closed by its own
+# counterpart); prose naming the tags is not one.
+_TOOL_CALL_MARKUP = re.compile(
+    r"<(?:[a-z]+:)?invoke\s+name\s*="
+    r"|<(?:[a-z]+:)?(function_calls|tool_call|tool_use)\b[^>]*>.*?</(?:[a-z]+:)?\1\s*>",
+    re.IGNORECASE | re.DOTALL,
+)
+
+# Fenced blocks and inline spans - markup quoted as code is shown, not issued.
+_CODE_MARKUP = re.compile(r"^```.*?^```|`[^`\n]+`", re.MULTILINE | re.DOTALL)
+
+
+def _has_tool_call_markup(content: str) -> bool:
+    """True if the text contains a native tool-call envelope outside of code."""
+    return bool(content) and _TOOL_CALL_MARKUP.search(_CODE_MARKUP.sub("", content)) is not None
+
+
 # Tags the runtime injects into the model's NEXT user message after executing
 # its code (the execution result, multi-block warning, and budget hints). A
 # well-behaved model never writes these itself; one that does is impersonating
@@ -198,6 +217,20 @@ def _build_spoofed_runtime_tag_warning() -> str:
     )
 
 
+def _build_unexecuted_tool_call_notice_xml() -> str:
+    """Model-visible correction when a no-code response was built out of native
+    tool-call markup. Nothing in it ran, so its completion summary describes work
+    that never happened; this hands the turn back pointing at the fence that
+    actually executes."""
+    return (
+        "\n<tsugite_unexecuted_tool_call_notice>"
+        "Your response contained native tool-call markup. This runtime does not execute it - "
+        "nothing ran, and any result or count your response reported is not real. "
+        "Call the tools from Python instead: re-emit the work as exactly one ```python-exec block."
+        "</tsugite_unexecuted_tool_call_notice>"
+    )
+
+
 def _build_multi_block_warning_xml(count: int) -> str:
     """Model-visible note appended to a turn's observation when the agent
     received N>1 ```python blocks in one response.
@@ -409,6 +442,8 @@ class TsugiteAgent:
         last_response_text: str = ""
         turn_num = 0
         cancelled = False
+        corrected_tool_call_markup = False
+        unexecuted_tool_call_run = False
 
         try:
             for turn_num in range(self.max_turns):
@@ -467,9 +502,21 @@ class TsugiteAgent:
                         )
                     )
 
+                # Neutralizing the tag is silent otherwise, so a model impersonating
+                # the runtime leaves no trace for an operator reading logs or events.
+                if turn.spoofed_runtime_tag:
+                    logger.warning("Response wrote runtime-only tags; neutralized them (step %d)", turn_num + 1)
+                    if self.event_bus:
+                        self.event_bus.emit(
+                            WarningEvent(
+                                message="Response wrote runtime-only tags; they were neutralized.",
+                                category="spoofed_runtime_tag",
+                                step=turn_num + 1,
+                            )
+                        )
+
                 # No code = the model is done. Its raw text is the answer.
                 if not code or not code.strip():
-                    final_value = last_response_text
                     trailing_notice = ""
                     if multi_block_count:
                         trailing_notice += _build_multi_block_warning_xml(multi_block_count)
@@ -479,6 +526,10 @@ class TsugiteAgent:
                     # it wasn't executed. Nudge it toward the exec fence for next turn.
                     if turn.has_bare_python:
                         trailing_notice += _build_bare_python_notice_xml()
+                    # Correct the model once rather than accept a fabricated summary.
+                    unexecuted_tool_call = _has_tool_call_markup(last_response_text)
+                    if unexecuted_tool_call:
+                        trailing_notice += _build_unexecuted_tool_call_notice_xml()
                     self.memory.add_step(
                         thought=thought,
                         code="",
@@ -488,6 +539,22 @@ class TsugiteAgent:
                         raw_content=last_response_text,
                         xml_observation=trailing_notice or None,
                     )
+                    if unexecuted_tool_call and not corrected_tool_call_markup:
+                        corrected_tool_call_markup = True
+                        if self.event_bus:
+                            self.event_bus.emit(
+                                WarningEvent(
+                                    message=(
+                                        "Response used tool-call markup, which is not executed; "
+                                        "asking the model to re-emit it as a python-exec block."
+                                    ),
+                                    category="unexecuted_tool_call",
+                                    step=turn_num + 1,
+                                )
+                            )
+                        continue
+                    unexecuted_tool_call_run = unexecuted_tool_call
+                    final_value = last_response_text
                     break
 
                 # Cooperative cancel checkpoint (before running a tool/code block):
@@ -575,6 +642,13 @@ class TsugiteAgent:
                 error_message = f"max_turns ({self.max_turns}) reached"
                 if self.event_bus:
                     self.event_bus.emit(WarningEvent(message=error_message, step=turn_num + 1))
+            # The model answered with tool-call markup again after being corrected,
+            # so the run finished having executed nothing it claimed to do.
+            elif unexecuted_tool_call_run:
+                status = "error"
+                error_message = "model answered with unexecuted tool-call markup; no code ran"
+                if self.event_bus:
+                    self.event_bus.emit(WarningEvent(message=error_message, step=turn_num + 1))
             else:
                 status = "success"
                 error_message = None
@@ -685,6 +759,7 @@ class TsugiteAgent:
             duration_ms=duration_ms,
             tools_called=list(exec_result.tools_called) if exec_result.tools_called else None,
             tool_calls=tool_calls,
+            groups=[{k: _mask_str(v) for k, v in g.items()} for g in exec_result.groups] or None,
             last_statement_type=exec_result.last_statement_type,
             return_value_repr=return_value_repr,
             return_value_type=return_value_type,
@@ -1438,6 +1513,14 @@ config = read_file("config.yaml")
 print(config)
 ```
 
+When a block does several calls toward one goal, label them with `tsu_group`:
+
+```python-exec
+with tsu_group("read the config files"):
+    for name in ("config.yaml", "defaults.yaml"):
+        print(name, len(read_file(name)))
+```
+
 Only ```python-exec blocks are executed. A plain ```python block is treated as
 illustration — it is shown to the user but NOT run — so you can quote or explain
 Python without executing it.
@@ -1477,6 +1560,8 @@ the real result next turn.
   Only JSON-serializable values.
 - For a structured (non-string) return: `return_value({{"status": "ok"}})` — ends the run
   and returns the value as-is. For a plain text answer, just stop using code blocks.
+- Group per phase of work, not per call: one `tsu_group` around several related calls,
+  and none at all for a block that does one thing.
 {tools_section}
 ## Rules
 

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

@@ -16,6 +16,8 @@ import pprint
 import sys
 import threading
 import time
+import uuid
+from contextlib import contextmanager
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Callable, Dict, Iterator, List, Optional, Protocol, runtime_checkable
@@ -74,6 +76,8 @@ MAX_EXECUTION_OUTPUT_KB = 50
 # not model input, so they stay small.
 TOOL_CALL_ARG_MAX = 500
 TOOL_CALL_OUTPUT_MAX = 2000
+# Titles are LLM-authored and nothing else bounds them before history.
+GROUP_TITLE_MAX = 200
 
 
 def _cap_text(text: str, limit: int) -> str:
@@ -106,6 +110,9 @@ class ExecutionResult:
     # Per-call records ({tool, arguments, success, duration_ms, output|error}),
     # capped via TOOL_CALL_ARG_MAX / TOOL_CALL_OUTPUT_MAX.
     tool_calls: List[Dict[str, Any]] = field(default_factory=list)
+    # Named `tsu_group` sections opened this turn, in the order they opened:
+    # {group_id, title, parent_group_id, success, duration_ms, error?}.
+    groups: List[Dict[str, Any]] = field(default_factory=list)
     variables_set: Dict[str, str] = field(default_factory=dict)  # name -> "type(size)"
     state_keys: Dict[str, str] = field(default_factory=dict)  # persisted state: name -> "type(size)"
     loaded_skills: Dict[str, str] = field(default_factory=dict)  # name -> content
@@ -129,6 +136,13 @@ class ExecutionResult:
             output = output[:max_bytes]
             self.truncated = True
 
+        # An explicit return_value() is the other way a turn hands back megabytes;
+        # the last-expression path prints instead, so it already rides `output`.
+        return_value = None if self.return_value is None else _mask(str(self.return_value))
+        if return_value is not None and len(return_value) > max_bytes:
+            return_value = return_value[:max_bytes]
+            self.truncated = True
+
         status = "error" if self.error else "success"
         attrs = f'status="{status}"'
         if duration_ms:
@@ -156,8 +170,8 @@ class ExecutionResult:
             state_list = ", ".join(f"{escape(k)}={escape(_mask(v))}" for k, v in self.state_keys.items())
             parts.append(f"<state>{state_list}</state>")
 
-        if self.return_value is not None:
-            parts.append(f"<return_value>{escape(_mask(str(self.return_value)))}</return_value>")
+        if return_value is not None:
+            parts.append(f"<return_value>{escape(return_value)}</return_value>")
 
         parts.append("</tsugite_execution_result>")
         return "\n".join(parts)
@@ -328,6 +342,8 @@ class LocalExecutor:
         self._return_value = None
         self._tools_called = []
         self._tool_calls: List[Dict[str, Any]] = []
+        self._group_stack: List[str] = []
+        self._groups: List[Dict[str, Any]] = []
         self._loaded_skills_for_turn: Dict[str, str] = {}
         self._unloaded_skills_for_turn: List[str] = []
         self.workspace_dir = workspace_dir
@@ -377,6 +393,7 @@ class LocalExecutor:
             return f"Message sent: {msg}"
 
         ns["send_message"] = send_message
+        ns["tsu_group"] = self._tsu_group
 
         def _blocked_open(*args, **kwargs):
             raise RuntimeError(
@@ -475,6 +492,8 @@ class LocalExecutor:
         self._return_value = None
         self._tools_called = []
         self._tool_calls = []
+        self._group_stack = []
+        self._groups = []
         self._loaded_skills_for_turn = {}
         self._unloaded_skills_for_turn = []
 
@@ -565,6 +584,7 @@ class LocalExecutor:
             return_value=None if exec_error else self._return_value,
             tools_called=self._tools_called.copy(),
             tool_calls=[dict(c) for c in self._tool_calls],
+            groups=[dict(g) for g in self._groups],
             variables_set=variables_set,
             state_keys=state_keys,
             loaded_skills=self._loaded_skills_for_turn.copy(),
@@ -619,6 +639,50 @@ class LocalExecutor:
         wrappers = {t.name: self._make_tool_wrapper(t) for t in tools if t.name not in EXECUTOR_BUILTIN_TOOLS}
         self.register_tools(wrappers)
 
+    @contextmanager
+    def _tsu_group(self, title: str):
+        """Bracket the block as a named group on the event stream and the execution result."""
+        from tsugite.events import ExecutionGroupEndEvent, ExecutionGroupStartEvent
+
+        record: Dict[str, Any] = {
+            "group_id": uuid.uuid4().hex[:12],
+            "title": _cap_text(str(title), GROUP_TITLE_MAX),
+            "parent_group_id": self._current_group(),
+        }
+        self._groups.append(record)
+        if self.event_bus:
+            self.event_bus.emit(
+                ExecutionGroupStartEvent(
+                    group_id=record["group_id"],
+                    title=record["title"],
+                    parent_group_id=record["parent_group_id"],
+                )
+            )
+        self._group_stack.append(record["group_id"])
+        t0 = time.perf_counter()
+        try:
+            yield
+            record["success"] = True
+        except BaseException as exc:
+            record["success"] = False
+            record["error"] = _cap_text(f"{type(exc).__name__}: {exc}", TOOL_CALL_ARG_MAX)
+            raise
+        finally:
+            self._group_stack.pop()
+            record["duration_ms"] = int((time.perf_counter() - t0) * 1000)
+            if self.event_bus:
+                self.event_bus.emit(
+                    ExecutionGroupEndEvent(
+                        group_id=record["group_id"],
+                        success=record.get("success", False),
+                        duration_ms=record["duration_ms"],
+                        error=record.get("error"),
+                    )
+                )
+
+    def _current_group(self) -> Optional[str]:
+        return self._group_stack[-1] if self._group_stack else None
+
     def _make_tool_wrapper(self, tool_obj):
         """Build the sync namespace wrapper that calls a tool's async execute()."""
         from tsugite.events import ToolCallEvent, ToolResultEvent
@@ -630,10 +694,13 @@ class LocalExecutor:
             # 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", ()))
+            group = self._current_group()
             record: Dict[str, Any] = {"tool": tool_obj.name, "arguments": _jsonable_call_args(audit_args)}
+            if group:
+                record["group_id"] = group
             self._tool_calls.append(record)
             if self.event_bus:
-                self.event_bus.emit(ToolCallEvent(tool_name=tool_obj.name, arguments=audit_args))
+                self.event_bus.emit(ToolCallEvent(tool_name=tool_obj.name, arguments=audit_args, group_id=group))
             t0 = time.perf_counter()
             try:
                 result = run_async_in_sync_context(tool_obj.execute(**kwargs))