tsugite-cli 0.24.1__tar.gz → 0.25.0__tar.gz

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/.gitignore

@@ -196,3 +196,4 @@ plugins/tsugite-daemon/tsugite_daemon/web/
 !plugins/tsugite-daemon/frontend/src/lib/**
 # Per-job git worktrees provisioned by the daemon.
 .tsugite-jobs/
+/packaging/runtime/.cache/

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tsugite-cli
-Version: 0.24.1
+Version: 0.25.0
 Summary: Micro-agent runner for task automation using markdown definitions
 Author: Justyn Shull
 License: GNU AFFERO GENERAL PUBLIC LICENSE
@@ -241,6 +241,7 @@ License: GNU AFFERO GENERAL PUBLIC LICENSE
 License-File: LICENSE
 Keywords: agents,automation,cli,jinja2
 Requires-Python: >=3.11
+Requires-Dist: certifi>=2026.10.23
 Requires-Dist: cryptography>=46.0.5
 Requires-Dist: html2text>=2020.1.16
 Requires-Dist: httpx>=0.25

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.24.1"
+version = "0.25.0"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"
@@ -12,6 +12,7 @@ dependencies = [
   "jinja2>=3.1",
   "pyyaml>=6.0",
   "httpx>=0.25",
+  "certifi>=2026.10.23",
   "rich>=13.0",
   "questionary>=2.1.1",
   "html2text>=2020.1.16",

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/tsugite/agent_preparation.py

@@ -434,7 +434,6 @@ class AgentPreparer:
             _combine_instructions,
             execute_exec_directives,
             execute_tool_directives,
-            get_default_instructions,
         )
         from tsugite.core.agent import build_system_prompt
         from tsugite.renderer import AgentRenderer
@@ -506,12 +505,16 @@ class AgentPreparer:
                     skip_reason=skip_reason,
                 )
 
+        tools = self._expand_tools(agent_config, full_context, interactive_mode)
+        # Templates test membership against the names actually installed, not the
+        # frontmatter specs (`"@secrets"`).
+        full_context["tools"] = [t.name for t in tools]
+
         try:
             rendered_prompt = renderer.render(modified_content, full_context)
         except Exception as e:
             raise RuntimeError(f"Template rendering failed: {e}") from e
 
-        base_instructions = get_default_instructions()
         agent_instructions = getattr(agent_config, "instructions", "")
 
         # Render agent instructions as Jinja2 template
@@ -521,9 +524,7 @@ class AgentPreparer:
             except Exception as e:
                 raise RuntimeError(f"Failed to render agent instructions: {e}") from e
 
-        combined_instructions = _combine_instructions(base_instructions, agent_instructions)
-
-        tools = self._expand_tools(agent_config, full_context, interactive_mode)
+        combined_instructions = _combine_instructions(agent_instructions)
 
         skill_load = self._load_skills(agent_config, prompt, full_context, _skill_manager, event_bus)
         skills, expiring_skills = skill_load.skills, skill_load.expiring

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/tsugite/agent_runner/__init__.py

@@ -31,7 +31,6 @@ from tsugite.agent_runner.runner import (  # noqa: F401
     _execute_agent_with_prompt,
     execute_prefetch,
     execute_tool_directives,
-    get_default_instructions,
     preview_multistep_agent,
     run_agent,
     run_agent_async,
@@ -47,7 +46,6 @@ __all__ = [
     "execute_exec_directives",
     "run_python_block",
     "ExecBlockResult",
-    "get_default_instructions",
     "AgentExecutionResult",
     "StepMetrics",
     "display_step_metrics",

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/tsugite/agent_runner/runner.py

@@ -155,31 +155,6 @@ def _setup_event_context(event_bus: Optional["EventBus"]) -> None:
         set_ui_context(event_bus=event_bus)
 
 
-def get_default_instructions() -> str:
-    """Get minimal default instructions. Detailed guidance comes from skills.
-
-    Returns:
-        Default instructions for code execution mode
-    """
-    base = "You accomplish tasks by writing Python code.\n\n"
-
-    output = (
-        "## Output\n\n"
-        "- `print(x)` - See in next turn (internal)\n"
-        "- `send_message(msg)` - Show user progress\n"
-        "- `final_answer(msg)` - Final response (stops execution)\n\n"
-    )
-
-    rules = (
-        "## Rules\n\n"
-        "1. Always respond with Python code blocks\n"
-        "2. Call `final_answer()` when done\n"
-        "3. Variables persist between turns\n"
-    )
-
-    return base + output + rules
-
-
 def _render_args(value: Any, renderer: AgentRenderer, context: Dict[str, Any]) -> Any:
     """Recursively render Jinja in string leaves of a tool args structure.
 
@@ -320,32 +295,17 @@ def execute_tool_directives(
     return modified_content, new_context
 
 
-def _extract_reasoning_content(agent: TsugiteAgent, custom_logger: Optional[Any] = None) -> None:
-    """Extract and display reasoning content from TsugiteAgent memory.
-
-    For models like Claude/Deepseek that expose reasoning_content, displays the actual reasoning.
-
-    Args:
-        agent: The TsugiteAgent instance that just completed execution
-        custom_logger: Custom logger to display reasoning content
-    """
-    if not hasattr(agent, "memory") or not agent.memory.reasoning_history:
-        return
+# Daemon chat sources with a person at the other end; any other source counts as background.
+INTERACTIVE_SOURCES = frozenset({"http", "discord"})
 
-    # Display each reasoning entry
-    for reasoning_content in agent.memory.reasoning_history:
-        if reasoning_content and custom_logger:
-            # Check if custom_logger has ui_handler (custom UI mode)
-            ui_handler = get_ui_handler(custom_logger)
-            if ui_handler:
-                from tsugite.events import EventBus, ReasoningContentEvent
 
-                event_bus = EventBus()
-                event_bus.subscribe(ui_handler.handle_event)
-                event_bus.emit(ReasoningContentEvent(content=reasoning_content, step=None))
+def _run_is_interactive(channel_metadata: Optional[Dict[str, Any]]) -> bool:
+    """Whether a person is present: the session source in the daemon, the TTY otherwise."""
+    source = (channel_metadata or {}).get("source")
+    return source in INTERACTIVE_SOURCES if source else is_interactive()
 
 
-def _make_pre_llm_call_callback(hooks_dir: Path, agent_name: str):
+def _make_pre_llm_call_callback(hooks_dir: Path, agent_name: str, interactive: bool):
     """Build an async callback that fires pre_llm_call hooks to mutate outgoing
     messages in place. Returns None when no such hooks exist (keeps the hot path clean)."""
     from tsugite.hooks import fire_hooks, load_hooks_config
@@ -359,7 +319,7 @@ def _make_pre_llm_call_callback(hooks_dir: Path, agent_name: str):
             hooks_dir,
             "pre_llm_call",
             {"messages": messages, "model": model, "agent": agent_name},
-            interactive=is_interactive(),
+            interactive=interactive,
         )
 
     return _callback
@@ -449,8 +409,9 @@ async def _execute_agent_with_prompt(
         hooks_dir = path_context.effective_cwd
     else:
         hooks_dir = Path.cwd()
-    setup_hook_handler(hooks_dir, event_bus, interactive=is_interactive())
-    pre_llm_call_cb = _make_pre_llm_call_callback(hooks_dir, agent_config.name)
+    interactive = _run_is_interactive(channel_metadata)
+    setup_hook_handler(hooks_dir, event_bus, interactive=interactive)
+    pre_llm_call_cb = _make_pre_llm_call_callback(hooks_dir, agent_config.name, interactive)
 
     # Start with tools from prepared agent
     tools = list(prepared.tools)  # Make a copy
@@ -637,9 +598,6 @@ async def _execute_agent_with_prompt(
             stream=exec_options.stream,
         )
 
-        # Extract and display reasoning content if present
-        _extract_reasoning_content(agent, custom_logger)
-
         if usage_sink is not None:
             usage_sink.update(
                 token_count=agent.total_tokens,
@@ -839,15 +797,17 @@ def _domain_within_ceiling(desired_pattern: str, ceiling: list) -> bool:
 
 
 def _resolve_workspace_dir(workspace: Optional[Any], path_context: Optional[Any]) -> Optional[Path]:
-    """Resolve the executor's workspace directory.
+    """Resolve the directory the executor runs code in.
 
-    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).
+    Checks: an explicit Workspace -> the directory bound with set_workspace_dir
+    (the daemon binds the session's working directory) -> path_context.workspace_dir.
     """
+    from tsugite.cli.helpers import get_workspace_dir
+
     if workspace:
         return workspace.path
+    if bound := get_workspace_dir():
+        return bound
     if path_context and getattr(path_context, "workspace_dir", None):
         return path_context.workspace_dir
     return None
@@ -934,7 +894,7 @@ async def _run_unit(
             "rendered_prompt": prepared.rendered_prompt[:500] if prepared.rendered_prompt else "",
             "tools": [t.name for t in prepared.tools] if prepared.tools else [],
         },
-        interactive=is_interactive(),
+        interactive=_run_is_interactive(setup.channel_metadata),
         on_status=setup.on_status,
         on_result=setup.on_hook_result,
     )
@@ -1140,10 +1100,11 @@ async def run_agent_async(
         on_status = None
         on_hook_result = None
 
+    interactive = _run_is_interactive(channel_metadata)
     hook_vars = await fire_pre_message_hooks(
         hooks_dir,
         {"message": hook_message, "agent_name": agent_path.stem},
-        interactive=is_interactive(),
+        interactive=interactive,
         on_status=on_status,
         on_result=on_hook_result,
     )
@@ -1157,7 +1118,7 @@ async def run_agent_async(
         hooks_dir,
         "pre_context_build",
         {"message": hook_message, "agent_name": agent_path.stem, **context, "blocks": context_blocks},
-        interactive=is_interactive(),
+        interactive=interactive,
         on_status=on_status,
         on_result=on_hook_result,
     )

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/tsugite/approval.py

@@ -31,23 +31,28 @@ _LABEL_TO_DECISION = {
 
 
 def request_approval(
-    prompt: str, *, allow_always: bool = False, allow_never: bool = False, detail: Optional[str] = None
+    prompt: str,
+    *,
+    allow_always: bool = False,
+    allow_never: bool = False,
+    extra_options: Optional[dict[str, str]] = None,
+    detail: Optional[str] = None,
 ) -> str:
     """Ask the user to approve an action, returning an :data:`ApprovalDecision`.
 
-    Builds ``Approve``/``Deny`` options (plus ``Always allow`` when ``allow_always``
-    and ``Always deny`` when ``allow_never``) and routes them through the active
-    interaction backend as an ``"approval"`` question, then maps the chosen label
-    back to a decision.
+    Offers ``Approve``/``Deny`` plus the optional choices below as an
+    ``"approval"`` question on the active interaction backend, and maps the
+    chosen label back to a decision.
 
     Args:
         prompt: The action to approve, phrased as a question.
         allow_always: Offer an "Always allow" option (a persistent allow).
         allow_never: Offer an "Always deny" option (a persistent deny).
+        extra_options: Caller-specific choices, as ``{label: decision}``.
         detail: Extra context appended below the prompt for the user to read.
 
     Returns:
-        One of ``"approve"``, ``"deny"``, ``"always"``, or ``"never"``.
+        One of ``"approve"``, ``"deny"``, ``"always"``, ``"never"``, or a value of ``extra_options``.
 
     Fail-closed: returns ``"deny"`` WITHOUT prompting when there is no backend or
     the backend is non-interactive, and for any unrecognized reply.
@@ -61,7 +66,9 @@ def request_approval(
         options.append(ALWAYS_LABEL)
     if allow_never:
         options.append(NEVER_LABEL)
+    decisions = _LABEL_TO_DECISION | (extra_options or {})
+    options.extend(extra_options or ())
 
     question = f"{prompt}\n\n{detail}" if detail else prompt
     answer = backend.ask_user(question, "approval", options)
-    return _LABEL_TO_DECISION.get(answer, "deny")
+    return decisions.get(answer, "deny")

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/tsugite/builtin_agents/default.md

@@ -73,7 +73,7 @@ instructions: |
   - Break down complex tasks into clear steps
   - Ask clarifying questions when the task is ambiguous
   - Write Python code to accomplish tasks
-  - Call return_value(result) when you've completed the task
+  - When you've completed the task, reply in plain text, or call return_value() for structured output
   - If you intend to call multiple tools and there are no dependencies between the calls, make all independent calls in a single code block
   - Never guess about code you have not read. Use read_file or list_files to investigate before answering questions about code
 
@@ -235,13 +235,6 @@ You have running tmux sessions that you can interact with using tmux tools (tmux
 {% endfor %}
 {% endif %}
 
-{% if "run" in tools and "tmux_create" in tools %}
-## Shell vs Tmux
-
-- Use `run()` for commands that produce output and exit: `run("ls -la")`, `run("git status")`, `run("python script.py")`
-- Use tmux tools for interactive programs (htop, k9s, psql, python REPL), long-running processes you want to monitor, or when you need a persistent shell session where state carries across commands
-{% endif %}
-
 {% if subagent_instructions is defined and subagent_instructions %}
 {{ subagent_instructions }}
 {% endif %}
@@ -299,11 +292,11 @@ Load these skills for specialized knowledge:
 - **{{ skill.name }}** - {{ skill.description }}
 {% endfor %}
 
-Call `load_skill("skill_name")` and stop. The skill content appears next turn as `<loaded_skill>`. Then use what you learned.
+Call `load_skill("skill_name")` and stop. The skill content appears next turn as `<skill_content>`. Then use what you learned.
 
 Do not act in the same turn you load a skill. Skip loading if you already know how to do the task.
 
-Skills may show bash commands. Translate to Python: `shell.run("kubectl get pods")`
+Skills may show bash commands. Translate to Python: `run("kubectl get pods")`
 </available_skills>
 {% endif %}
 

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/tsugite/builtin_agents/job_verifier.md

@@ -76,7 +76,9 @@ is `true` only if every `ac_results[i].pass` is `true`.
 
 `reason` opens with the basis for the verdict, then one sentence:
 
-- `inspected:` - you read the artifact, file, or Output text yourself.
+- `inspected:` - you read the artifact or file yourself with a tool call.
+- `read Output:` - the deliverable is inline text and you judged the `## Output`
+  text itself, with no tool call.
 - `ran <command>:` - you executed the command and judged its exit status.
 - `accepted worker claim:` - you could not check it, so the verdict rests on
   the worker's report.

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/tsugite/builtin_skills/codebase-exploration/SKILL.md

@@ -365,7 +365,7 @@ If available via custom tools configuration, consider using:
 tools:
   - name: ast_search
     description: Search code using AST patterns
-    command: "ast-grep -p '{pattern}' {path}"
+    command: "ast-grep -p {pattern} {path}"
     parameters:
       pattern: {required: true}
       path: "."

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/tsugite/builtin_skills/response-patterns/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: response-patterns
-description: How to respond effectively - when to use print/send_message/final_answer/ask_user
+description: How to respond effectively - when to use print/send_message/return_value/ask_user
 ---
 
 # Response Patterns
@@ -11,21 +11,18 @@ description: How to respond effectively - when to use print/send_message/final_a
 |----------|----------|-----------|---------|
 | `print(x)` | You (next turn) | Continues | Intermediate data |
 | `send_message(msg)` | User | Continues | Progress updates |
-| `final_answer(msg)` | User | **Stops** | Final response |
+| `return_value(value)` | User | **Stops** | Structured final result |
 | `ask_user(q)` | User | **Blocks** | Get user input |
 
 ## Simple Responses
 
-No functions needed? One line:
+No functions needed? Reply in plain text:
 
-```python-exec
-final_answer("Hello! What can I help you with?")
-```
+- "Thanks" replies `You're welcome!`
+- "What's 2+2?" replies `4`
+- "What can you do?" replies `I can read/write files, run commands, and help with tasks.`
 
-More examples:
-- "Thanks" → `final_answer("You're welcome!")`
-- "What's 2+2?" → `final_answer("4")`
-- "What can you do?" → `final_answer("I can read/write files, run commands, search code, and help with tasks.")`
+Call `return_value(value)` only when the caller needs a structured result.
 
 ## Progress Updates
 
@@ -33,14 +30,14 @@ For longer tasks, keep user informed:
 
 ```python-exec
 send_message("Searching codebase...")
-results = search_code("def main")
+results = run("grep -rn 'def main' .")
 print(results)  # You'll see this next turn
 ```
 
 ```python-exec
-send_message(f"Found {len(results)} matches. Analyzing...")
+send_message(f"Found {len(results.splitlines())} matches. Analyzing...")
 # ... more work ...
-final_answer("Here's what I found: ...")
+return_value("Here's what I found: ...")
 ```
 
 ## Asking the User
@@ -87,7 +84,7 @@ Use `ask_user` when:
 - Ask unnecessary questions when a reasonable default exists
 
 ✅ Do:
-- `final_answer()` immediately for simple responses
+- Plain text immediately for simple responses
 - `send_message()` for progress on tasks > 5 seconds
 - `ask_user()` when you genuinely need user input
 - `print()` only for data YOU need to see

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/tsugite/cli/helpers.py

@@ -500,8 +500,8 @@ class PathContext:
     effective_cwd: Path
 
 
-# Mirrors PathContext.workspace_dir for call sites (fs tools, shell, subprocesses)
-# that don't receive PathContext explicitly. Task-local so concurrent agent runs
+# The directory the running agent's code and fs tools work in, for call sites
+# (fs tools, shell, subprocesses, the executor) that don't receive PathContext explicitly. Task-local so concurrent agent runs
 # don't share state.
 _workspace_dir_cv: contextvars.ContextVar[Optional[Path]] = contextvars.ContextVar("workspace_dir", default=None)
 

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/tsugite/cli/run.py

@@ -257,7 +257,6 @@ def run(
     ),
     no_workspace: bool = typer.Option(False, "--no-workspace", help="Disable workspace (ignore default workspace)"),
     new_session: bool = typer.Option(False, "--new-session", help="Start fresh session (ignore workspace session)"),
-    join_daemon: bool = typer.Option(False, "--daemon", "-d", help="Join the daemon's most recent session"),
     sandbox: bool = typer.Option(False, "--sandbox", help="Run agent code in bubblewrap sandbox"),
     no_sandbox: bool = typer.Option(False, "--no-sandbox", help="Disable sandbox (overrides config)"),
     allow_domain: Optional[List[str]] = typer.Option(
@@ -282,7 +281,6 @@ def run(
         tsu run --continue "prompt"  # Continue latest conversation (auto-detect agent)
         tsu run +assistant --continue "prompt"  # Continue latest with specific agent
         tsu run --continue --conversation-id CONV_ID "prompt"  # Continue specific conversation
-        tsu run --daemon "follow up message"  # Join the daemon's most recent session
     """
     from tsugite.agent_runner import get_agent_info, run_agent
     from tsugite.console import get_stderr_console
@@ -381,7 +379,7 @@ def run(
     # Resolve UI mode to update ui_opts
     ui_opts = _resolve_ui_mode(ui, ui_opts, stderr_console)
 
-    # Handle subagent mode and daemon mode (both need os)
+    # Handle subagent mode
     import os
 
     if subagent_mode:
@@ -393,54 +391,6 @@ def run(
         history_opts.enabled = False
         os.environ["TSUGITE_SUBAGENT_MODE"] = "1"
 
-    daemon_metadata = None
-    if join_daemon:
-        from tsugite.agent_runner.history_integration import get_latest_conversation
-
-        try:
-            from tsugite_daemon.config import load_daemon_config
-
-            # Probe: the daemon battery has to be installed and configured.
-            load_daemon_config()
-        except ModuleNotFoundError as e:
-            stderr_console.print(
-                "[red]The daemon battery is not installed.[/red] Install it with: pip install tsugite-cli[daemon]"
-            )
-            raise typer.Exit(1) from e
-        except ValueError as e:
-            stderr_console.print(f"[red]Daemon config not found: {e}[/red]")
-            stderr_console.print("[dim]Run 'tsugite daemon' to start daemon first[/dim]")
-            raise typer.Exit(1)
-
-        user_id = os.environ.get("USER", "cli-user")
-
-        latest_conv_id = get_latest_conversation()
-        if latest_conv_id:
-            stderr_console.print(f"[cyan]Joining daemon session: {latest_conv_id}[/cyan]")
-            history_opts.continue_id = latest_conv_id
-        else:
-            stderr_console.print("[yellow]No active daemon session found[/yellow]")
-            stderr_console.print("[dim]Creating new daemon-managed session...[/dim]")
-
-        # Build CLI metadata for history
-        from datetime import datetime, timezone
-
-        daemon_metadata = {
-            "source": "cli",
-            "channel_id": None,
-            "user_id": user_id,
-            "reply_to": "cli",
-            "is_daemon_managed": True,
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-        }
-
-        all_attachments = list(attachment) if attachment else []
-        attach_opts = AttachmentOptions(
-            sources=all_attachments,
-            refresh_cache=refresh_cache,
-            auto_context=auto_context,
-        )
-
     # Handle conversation continuation - check before parsing args
     if continue_conversation and not history_opts.continue_id:
         from tsugite.agent_runner.history_integration import get_latest_conversation
@@ -641,7 +591,6 @@ def run(
                     continue_conversation_id=target_session,
                     system_prompt=system_prompt,
                     attachments=attachments,
-                    channel_metadata=daemon_metadata,
                     status=status,
                     error_message=error_message,
                 )

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/tsugite/core/agent.py

@@ -173,6 +173,40 @@ def _has_tool_call_markup(content: str) -> bool:
     return bool(content) and _TOOL_CALL_MARKUP.search(_CODE_MARKUP.sub("", content)) is not None
 
 
+# A single response holding this many characters of one whitespace run, or of one
+# short chunk repeated back to back, is a degenerate loop, not output. Real
+# content (long reports, tables, code) never gets near it. Not a length cap.
+_RUNAWAY_MIN_CHARS = 5000
+_RUNAWAY_CHECK_STRIDE = 1000
+_WHITESPACE_RUN = re.compile(rf"\s{{{_RUNAWAY_MIN_CHARS},}}")
+_MAX_CHUNK = 256
+_REPEATED_CHUNK = re.compile(rf"(.{{1,{_MAX_CHUNK}}}?)\1+", re.DOTALL)
+
+
+class RunawayOutputError(Exception):
+    """A streamed response degenerated into a whitespace run or a repeated chunk."""
+
+    def __init__(self, reason: str, content: str):
+        super().__init__(reason)
+        self.reason = reason
+        self.content = content
+
+
+def _find_runaway(content: str) -> Optional[tuple[str, int]]:
+    """Return (reason, start offset) of a degenerate run in the tail of `content`."""
+    window_start = max(0, len(content) - (_RUNAWAY_MIN_CHARS + _MAX_CHUNK + _RUNAWAY_CHECK_STRIDE))
+    window = content[window_start:]
+    if m := _WHITESPACE_RUN.search(window):
+        return f"a whitespace run of at least {_RUNAWAY_MIN_CHARS} characters", window_start + m.start()
+    tail = window[-_MAX_CHUNK:]
+    # Prefilter: skip the regex unless the tail text occurred earlier in the window.
+    if window.find(tail) < len(window) - len(tail):
+        for m in _REPEATED_CHUNK.finditer(window):
+            if len(m.group(0)) >= _RUNAWAY_MIN_CHARS:
+                return f"one chunk repeated for at least {_RUNAWAY_MIN_CHARS} characters", window_start + m.start()
+    return 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
@@ -233,6 +267,15 @@ def _build_unexecuted_tool_call_notice_xml() -> str:
     )
 
 
+def _build_runaway_notice_xml(reason: str) -> str:
+    return (
+        "\n<tsugite_runaway_output_notice>"
+        f"Your response was cut off because it contained {reason}. "
+        "Nothing in it ran. Reply again with prose or exactly one ```python-exec block."
+        "</tsugite_runaway_output_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.
@@ -480,7 +523,39 @@ class TsugiteAgent:
 
                 self._record_prompt_snapshot(messages, turn_num)
 
-                turn = await self._provider_turn(messages, turn_num, stream)
+                try:
+                    turn = await self._provider_turn(messages, turn_num, stream)
+                except RunawayOutputError as e:
+                    logger.warning("Aborted runaway response (step %d): %s", turn_num + 1, e.reason)
+                    aborted_text, _ = escape_runtime_injection_tags(e.content)
+                    last_response_text = aborted_text
+                    self._previous_turn_had_error = True
+                    if self.event_bus:
+                        self.event_bus.emit(
+                            WarningEvent(
+                                message=f"Response aborted: it contained {e.reason}.",
+                                category="runaway_output",
+                                step=turn_num + 1,
+                            )
+                        )
+                    self.memory.add_step(
+                        thought="",
+                        code="",
+                        output="",
+                        error=e.reason,
+                        tools_called=[],
+                        raw_content=aborted_text,
+                        xml_observation=_build_runaway_notice_xml(e.reason),
+                    )
+                    self._record_model_response(
+                        turn_num,
+                        raw_content=aborted_text,
+                        parsed=ParsedResponse(thought=aborted_text, code=""),
+                        usage=None,
+                        cost=None,
+                        response=None,
+                    )
+                    continue
                 thought, code = turn.thought, turn.code
                 last_response_text = turn.response.content if turn.response else (thought or "")
 
@@ -855,11 +930,20 @@ class TsugiteAgent:
         chunks = await self._provider.acompletion(
             messages=messages, model=self._model_id, stream=True, **self._model_kwargs
         )
+        checked_len = 0
         async for chunk in chunks:
             if chunk.content:
                 content += chunk.content
                 if self.event_bus:
                     self.event_bus.emit(StreamChunkEvent(chunk=chunk.content))
+                if len(content) - checked_len >= _RUNAWAY_CHECK_STRIDE:
+                    checked_len = len(content)
+                    if runaway := _find_runaway(content):
+                        reason, start = runaway
+                        await chunks.aclose()
+                        if self.event_bus:
+                            self.event_bus.emit(StreamCompleteEvent())
+                        raise RunawayOutputError(reason, content[:start])
             if getattr(chunk, "reasoning_content", ""):
                 reasoning += chunk.reasoning_content
                 if self.event_bus:
@@ -1188,7 +1272,7 @@ class TsugiteAgent:
             {"role": "assistant", "content": "previous response 1"},
             {"role": "user", "content": task},
             {"role": "assistant", "content": "```python-exec\\n...```"},
-            {"role": "user", "content": <loaded_skill>...</loaded_skill>\\n<observation>..."},
+            {"role": "user", "content": <skill_content>...</skill_content>\\n<observation>..."},
             ...
         ]
         """

{tsugite_cli-0.24.1 → tsugite_cli-0.25.0}/tsugite/history/base.py

@@ -18,9 +18,9 @@ class Session(Protocol):
 
     session_id: str
 
-    def record(self, type: str, *, ts: Optional[datetime] = None, **data: Any) -> None: ...
+    def record(self, type: str, *, ts: Optional[datetime] = None, **data: Any) -> int: ...
 
-    def record_many(self, events: Iterable[Event]) -> None: ...
+    def record_many(self, events: Iterable[Event]) -> List[int]: ...
 
     def iter_events(self, types: Optional[Iterable[str]] = None) -> Iterator[Event]: ...