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

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

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

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

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

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

@@ -152,7 +152,8 @@ class AgentPreparer:
 
         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.
+        entry. Front-matter paths render with `paths` and resolve against the
+        workspace, or the CWD when the run has no workspace.
         """
         all_attachments = list(attachments or [])
 
@@ -160,7 +161,8 @@ 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, Path(paths["CWD"]), paths)
+        base = paths["WORKSPACE_DIR"] or paths["CWD"]
+        loaded, bindings = resolve_agent_config_attachments(keep_items, Path(base), paths)
         all_attachments = loaded + all_attachments
 
         seen_names: set[str] = set()

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

@@ -92,14 +92,11 @@ def _current_turn_already_has_user_input(storage: Session) -> bool:
     session_end after it; the post-hoc save_run_to_history on the error path
     would otherwise record a second, identical one (a duplicate user bubble).
     A genuinely repeated message opens a new turn *after* the prior session_end,
-    so this stays False for it.
+    so this stays False for it. A final_result also ends a turn: compaction copies
+    retained turns into the successor without their session_end.
     """
-    for event in reversed(list(storage.iter_events(types=("user_input", "session_end")))):
-        if event.type == "session_end":
-            return False
-        if event.type == "user_input":
-            return True
-    return False
+    events = list(storage.iter_events(types=("user_input", "session_end", "final_result")))
+    return bool(events) and events[-1].type == "user_input"
 
 
 def record_user_input(

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

@@ -1281,6 +1281,7 @@ def preview_multistep_agent(
 
     # Extract steps
     from tsugite.md_agents import extract_step_directives, has_step_directives
+    from tsugite.tools import format_tool_specs
 
     if not has_step_directives(agent.content):
         output("[yellow]This is a single-step agent (no step directives).[/yellow]", is_warning=True)
@@ -1302,7 +1303,7 @@ def preview_multistep_agent(
     output(f"Prompt: {prompt}")
     output(f"Steps: {len(steps)}")
     output(f"Model: {resolve_effective_model(agent_model=agent.config.model) or 'unknown'}")
-    output(f"Tools: {', '.join(agent.config.tools) if agent.config.tools else 'None'}")
+    output(f"Tools: {format_tool_specs(agent.config.tools) if agent.config.tools else 'None'}")
     output("")
 
     # Show steps in table format

{tsugite_cli-0.23.0 → tsugite_cli-0.23.2}/tsugite/approval.py

@@ -1,9 +1,9 @@
 """Backend-driven approval primitive.
 
 A human-in-the-loop gate that pauses a turn before an action and asks the user
-to approve or deny it. It rides the same InteractionBackend used by ``ask_user``,
-so an approval surfaces on whatever adapter the user is on (CLI prompt, web SSE
-frame, etc.).
+to approve or deny it, once or persistently. It rides the same InteractionBackend
+used by ``ask_user``, so an approval surfaces on whatever adapter the user is on
+(CLI prompt, web SSE frame, etc.).
 
 Fail-closed by design: when no interactive surface is available (no backend, or a
 non-interactive scheduler/headless backend), or when the reply is unrecognized,
@@ -15,34 +15,39 @@ from typing import Literal, Optional
 
 from tsugite.interaction import NonInteractiveBackend, get_interaction_backend
 
-ApprovalDecision = Literal["approve", "deny", "always"]
+ApprovalDecision = Literal["approve", "deny", "always", "never"]
 
 APPROVE_LABEL = "Approve"
 DENY_LABEL = "Deny"
 ALWAYS_LABEL = "Always allow"
+NEVER_LABEL = "Always deny"
 
 _LABEL_TO_DECISION = {
     APPROVE_LABEL: "approve",
     DENY_LABEL: "deny",
     ALWAYS_LABEL: "always",
+    NEVER_LABEL: "never",
 }
 
 
-def request_approval(prompt: str, *, allow_always: bool = False, detail: Optional[str] = None) -> str:
+def request_approval(
+    prompt: str, *, allow_always: bool = False, allow_never: bool = False, 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 routes them through the active interaction backend as an
-    ``"approval"`` question, then maps the chosen label back to ``"approve"``,
-    ``"deny"``, or ``"always"``.
+    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.
 
     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).
         detail: Extra context appended below the prompt for the user to read.
 
     Returns:
-        One of ``"approve"``, ``"deny"``, or ``"always"``.
+        One of ``"approve"``, ``"deny"``, ``"always"``, or ``"never"``.
 
     Fail-closed: returns ``"deny"`` WITHOUT prompting when there is no backend or
     the backend is non-interactive, and for any unrecognized reply.
@@ -54,6 +59,8 @@ def request_approval(prompt: str, *, allow_always: bool = False, detail: Optiona
     options = [APPROVE_LABEL, DENY_LABEL]
     if allow_always:
         options.append(ALWAYS_LABEL)
+    if allow_never:
+        options.append(NEVER_LABEL)
 
     question = f"{prompt}\n\n{detail}" if detail else prompt
     answer = backend.ask_user(question, "approval", options)

{tsugite_cli-0.23.0 → tsugite_cli-0.23.2}/tsugite/cli/agents.py

@@ -75,6 +75,7 @@ def agents_show(
     """
     from tsugite.agent_inheritance import find_agent_file
     from tsugite.md_agents import parse_agent_file
+    from tsugite.tools import format_tool_spec
 
     try:
         agent_file = Path(agent_path)
@@ -113,7 +114,7 @@ def agents_show(
         if config.tools:
             console.print(f"\n[bold]Tools ({len(config.tools)}):[/bold]")
             for tool in config.tools:
-                console.print(f"  • {tool}")
+                console.print(f"  • {format_tool_spec(tool)}")
 
         if config.extends:
             console.print(f"\n[bold]Extends:[/bold] {config.extends}")

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

@@ -288,6 +288,7 @@ def run(
     from tsugite.console import get_stderr_console
     from tsugite.md_agents import validate_agent_execution
     from tsugite.secrets import init_cli as init_secrets
+    from tsugite.tools import format_tool_specs
     from tsugite.utils import should_use_plain_output
 
     from . import console
@@ -562,7 +563,7 @@ def run(
                 "Directory": str(Path.cwd()),
                 "Model": resolve_effective_model(exec_opts.model_override, agent_info.get("model_raw")) or "unknown",
                 "Instructions": instruction_label,
-                "Tools": ", ".join(agent_info.get("tools", [])),
+                "Tools": format_tool_specs(agent_info.get("tools", [])),
             }
 
             agent_attachments = agent_info.get("attachments")

{tsugite_cli-0.23.0 → tsugite_cli-0.23.2}/tsugite/core/executor.py

@@ -98,6 +98,13 @@ def _jsonable_call_args(kwargs: Dict[str, Any]) -> Dict[str, Any]:
     return safe
 
 
+NAME_ERROR_NOTE = (
+    " (each code block starts with a fresh namespace: names from earlier blocks and"
+    " <content> blocks do not carry over, so re-import or recompute them, or keep"
+    " values in state['key'])"
+)
+
+
 def truncate_observation(text: str, max_output_kb: int = MAX_EXECUTION_OUTPUT_KB) -> tuple[str, bool]:
     """Clip text to the observation cap, returning (text, was_truncated).
 
@@ -134,6 +141,8 @@ def build_execution_result(
 
     children = [El("output", [output], inline=True)]
     if error:
+        if error.startswith("NameError:"):
+            error += NAME_ERROR_NOTE
         children.append(El("error", [error], inline=True))
         if traceback:
             children.append(El("traceback", [traceback], inline=True))

{tsugite_cli-0.23.0 → tsugite_cli-0.23.2}/tsugite/core/record_store.py

@@ -201,6 +201,7 @@ class RecordStore:
     valid_transitions: dict[str, frozenset[str]]
     terminal_states: frozenset[str]
     transition_error_cls: type[ValueError] = ValueError
+    missing_error_cls: type[LookupError] = KeyError
 
     def __init__(self, path: Path):
         self._path = path  # legacy JSON location; migration source only
@@ -237,11 +238,18 @@ class RecordStore:
         with self._lock:
             return [r for r in self._records.values() if r.parent_session_id == parent_session_id]
 
+    def require(self, record_id: str):
+        """Raises `missing_error_cls` when no record has that id."""
+        record = self.get(record_id)
+        if record is None:
+            raise self.missing_error_cls(f"Unknown {self.record_label}: {record_id}")
+        return record
+
     def update_state(self, record_id: str, new_state: str):
         with self._lock:
             record = self._records.get(record_id)
             if record is None:
-                raise KeyError(f"Unknown {self.record_label}: {record_id}")
+                raise self.missing_error_cls(f"Unknown {self.record_label}: {record_id}")
             allowed = self.valid_transitions.get(record.state, frozenset())
             if new_state not in allowed:
                 raise self.transition_error_cls(
@@ -270,7 +278,7 @@ class RecordStore:
         with self._lock:
             record = self._records.get(record_id)
             if record is None:
-                raise KeyError(f"Unknown {self.record_label}: {record_id}")
+                raise self.missing_error_cls(f"Unknown {self.record_label}: {record_id}")
             for key, value in fields.items():
                 if not hasattr(record, key):
                     raise ValueError(f"Unknown {self.record_cls.__name__} field: {key}")

{tsugite_cli-0.23.0 → tsugite_cli-0.23.2}/tsugite/history/reconstruction.py

@@ -11,6 +11,7 @@ from datetime import datetime
 from typing import Any, Dict, Iterable, List, Optional
 from xml.sax.saxutils import escape, quoteattr
 
+from tsugite.prompt_xml import El
 from tsugite.renderer import format_prompt_ts, parse_iso_utc
 
 from .models import Event
@@ -176,6 +177,11 @@ def _event_to_message(event: Event, executed: bool = False) -> Optional[Dict[str
         return {"role": "user", "content": _format_error_xml(event.data)}
     if event.type == "delivery":
         return {"role": "user", "content": _delivery_xml(event.data, event.ts)}
+    if event.type == "error":
+        # send_failed is a notification that never left the daemon, not a turn failure.
+        if event.data.get("kind") == "send_failed":
+            return None
+        return {"role": "user", "content": _turn_failed_xml(event.data, event.ts)}
     return None
 
 
@@ -223,6 +229,22 @@ def _delivery_xml(data: Dict[str, Any], ts: Optional[datetime] = None) -> str:
     return "\n".join(parts)
 
 
+_TURN_FAILED_NOTE = (
+    "The previous attempt failed before it finished. Continue from where it stopped rather than starting over."
+)
+
+
+def _turn_failed_xml(data: Dict[str, Any], ts: datetime) -> str:
+    return El(
+        "tsugite_turn_failed",
+        [
+            El("note", [_TURN_FAILED_NOTE], inline=True),
+            El("error", [data.get("error")], inline=True),
+        ],
+        {"ts": _format_event_ts(ts)},
+    ).render()
+
+
 def _format_error_xml(data: Dict[str, Any]) -> str:
     reason = data.get("reason", "")
     msg = (

{tsugite_cli-0.23.0 → tsugite_cli-0.23.2}/tsugite/permissions.py

@@ -3,23 +3,26 @@
 Merges two YAML sources, the same way hooks does:
 
 1. ``runtime_path``: a mutable ``permissions.yaml`` next to ``daemon.yaml``.
-   "Always allow" decisions append here, so they survive a restart.
+   "Always allow" and "Always deny" decisions append here, so they survive a restart.
 2. ``workspace_dir``: an optional, read-only ``<workspace_dir>/.tsugite/permissions.yaml``,
    hand-authored per agent (exactly like ``.tsugite/hooks.yaml``). The store never
    writes it.
 
-``is_allowed`` is the union of both files. ``allow`` only ever writes the runtime
+``is_listed`` is the union of both files. ``add`` only ever writes the runtime
 file, atomically, preserving every unrelated section.
 
-The file groups allowlists by section, e.g.::
+The file groups lists by section, e.g.::
 
     web:
       fetch_allowlist:
         - example.com
+      fetch_denylist:
+        - ads.example.com
 
-The generic ``is_allowed(section, key)`` / ``allow(section, key)`` address a list
-by dotted path (``"web.fetch_allowlist"``). The ``web_fetch_*`` wrappers hide that
-layout so callers stay decoupled from it.
+The generic ``is_listed(section, key)`` / ``add(section, key)`` address a list by
+dotted path (``"web.fetch_allowlist"``). The ``web_fetch_*`` wrappers hide that
+layout so callers stay decoupled from it. The store applies no precedence between
+lists. The caller decides.
 """
 
 import contextvars
@@ -31,6 +34,7 @@ import yaml
 from tsugite.utils import atomic_write_text
 
 WEB_FETCH_ALLOWLIST = "web.fetch_allowlist"
+WEB_FETCH_DENYLIST = "web.fetch_denylist"
 
 
 def _load_yaml_mapping(path: Optional[Path]) -> dict:
@@ -70,20 +74,20 @@ def _atomic_write_yaml(path: Path, data: dict) -> None:
 
 
 class Permissions:
-    """Union of a mutable runtime allowlist and a read-only workspace allowlist."""
+    """Union of a mutable runtime permissions file and a read-only workspace one."""
 
     def __init__(self, runtime_path: Path, workspace_dir: Optional[Path] = None):
         self.runtime_path = Path(runtime_path)
         self._workspace_path = (Path(workspace_dir) / ".tsugite" / "permissions.yaml") if workspace_dir else None
 
-    def is_allowed(self, section: str, key: str) -> bool:
+    def is_listed(self, section: str, key: str) -> bool:
         """True if ``key`` is listed at dotted ``section`` in EITHER source."""
         parts = section.split(".")
         return key in _get_list(_load_yaml_mapping(self.runtime_path), parts) or key in _get_list(
             _load_yaml_mapping(self._workspace_path), parts
         )
 
-    def allow(self, section: str, key: str) -> None:
+    def add(self, section: str, key: str) -> None:
         """Append ``key`` to the RUNTIME file's list at dotted ``section``.
 
         Only ever touches the runtime file (never the workspace file), writes
@@ -102,11 +106,19 @@ class Permissions:
 
     def web_fetch_allowed(self, domain: str) -> bool:
         """True if ``domain`` is on the web fetch allowlist (either source)."""
-        return self.is_allowed(WEB_FETCH_ALLOWLIST, domain.lower())
+        return self.is_listed(WEB_FETCH_ALLOWLIST, domain.lower())
 
     def web_fetch_allow(self, domain: str) -> None:
         """Persist ``domain`` to the runtime web fetch allowlist."""
-        self.allow(WEB_FETCH_ALLOWLIST, domain.lower())
+        self.add(WEB_FETCH_ALLOWLIST, domain.lower())
+
+    def web_fetch_denied(self, domain: str) -> bool:
+        """True if ``domain`` is on the web fetch denylist (either source)."""
+        return self.is_listed(WEB_FETCH_DENYLIST, domain.lower())
+
+    def web_fetch_deny(self, domain: str) -> None:
+        """Persist ``domain`` to the runtime web fetch denylist."""
+        self.add(WEB_FETCH_DENYLIST, domain.lower())
 
 
 _permissions_var: contextvars.ContextVar[Optional[Permissions]] = contextvars.ContextVar("permissions", default=None)

{tsugite_cli-0.23.0 → tsugite_cli-0.23.2}/tsugite/providers/anthropic.py

@@ -48,6 +48,7 @@ _ANTHROPIC_MODELS: dict[str, ModelInfo] = {
     "anthropic/claude-opus-4-7": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "xhigh", "max"], thinking_style="adaptive"),
     "anthropic/claude-opus-4-8": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "xhigh", "max"], thinking_style="adaptive"),
     "anthropic/claude-opus-5": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "xhigh", "max"], thinking_style="adaptive"),
+    "anthropic/claude-opus-5-5": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=4.0, output_cost_per_million=20.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "xhigh", "max"], thinking_style="adaptive"),
     "anthropic/claude-sonnet-4-5": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=64_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
     "anthropic/claude-sonnet-4-5-20250929": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=64_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
     "anthropic/claude-sonnet-4-6": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),

{tsugite_cli-0.23.0 → tsugite_cli-0.23.2}/tsugite/providers/model_registry.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import re
+
 from .base import ModelInfo, Usage
 
 _REGISTRY: dict[str, ModelInfo] = {}
@@ -22,11 +24,13 @@ def get_model_info(provider: str, model: str) -> ModelInfo | None:
     for reg_key, info in _REGISTRY.items():
         if not key.startswith(reg_key) or len(reg_key) <= best_len:
             continue
-        # Only treat the prefix as the same model when the remainder is a date/version
-        # continuation (e.g. "-20250805"), not a distinct variant ("-mini", "-turbo")
-        # — otherwise an unlisted variant silently inherits a sibling's pricing.
+        # Only treat the prefix as the same model when the remainder is a dated
+        # continuation (e.g. "-20250805", "-2024-05-13"), not a distinct variant
+        # ("-mini", "-turbo") or a point release ("-5"). An unlisted variant
+        # would otherwise silently inherit a sibling's pricing. A year is 4+
+        # digits, so require the digit run right after the dash to be that long.
         suffix = key[len(reg_key) :]
-        if suffix and not (suffix.startswith("-") and len(suffix) > 1 and suffix[1].isdigit()):
+        if suffix and not re.match(r"^-\d{4}", suffix):
             continue
         best_match = info
         best_len = len(reg_key)

{tsugite_cli-0.23.0 → tsugite_cli-0.23.2}/tsugite/providers/openai_compat.py

@@ -55,6 +55,8 @@ _OPENAI_MODELS: dict[str, ModelInfo] = {
     "openai/gpt-5.6-sol": ModelInfo(max_input_tokens=1_050_000, max_output_tokens=128_000, input_cost_per_million=4.0, output_cost_per_million=20.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["none", "low", "medium", "high", "xhigh", "max"]),
     "openai/gpt-5.6-terra": ModelInfo(max_input_tokens=1_050_000, max_output_tokens=128_000, input_cost_per_million=2.0, output_cost_per_million=12.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["none", "low", "medium", "high", "xhigh", "max"]),
     "openai/gpt-6-astra": ModelInfo(max_input_tokens=1_050_000, max_output_tokens=128_000, input_cost_per_million=10.0, output_cost_per_million=50.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "xhigh", "max"]),
+    "openai/gpt-6-luna": ModelInfo(max_input_tokens=1_050_000, max_output_tokens=128_000, input_cost_per_million=0.1, output_cost_per_million=0.5, supports_vision=True, supports_reasoning=True, supported_effort_levels=["none", "low", "medium", "high", "xhigh", "max"]),
+    "openai/gpt-6-sol": ModelInfo(max_input_tokens=1_050_000, max_output_tokens=128_000, input_cost_per_million=2.0, output_cost_per_million=10.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["none", "low", "medium", "high", "xhigh", "max"]),
     "openai/o1": ModelInfo(max_input_tokens=200_000, max_output_tokens=100_000, input_cost_per_million=15.0, output_cost_per_million=60.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high"]),
     "openai/o1-pro": ModelInfo(max_input_tokens=200_000, max_output_tokens=100_000, input_cost_per_million=150.0, output_cost_per_million=600.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high"]),
     "openai/o3": ModelInfo(max_input_tokens=200_000, max_output_tokens=100_000, input_cost_per_million=2.0, output_cost_per_million=8.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high"]),

{tsugite_cli-0.23.0 → tsugite_cli-0.23.2}/tsugite/tools/__init__.py

@@ -376,6 +376,21 @@ def expand_tool_specs(tool_specs: List[str], strict: bool = False) -> List[str]:
     return result
 
 
+def format_tool_spec(spec: str) -> str:
+    """Render one frontmatter tool spec for console output, with `@category` as `name (toolset)`.
+
+    An agent that shells out to tsugite reads this through its own tool layer, where `@name`
+    expands as a file mention if it matches a directory.
+    """
+    prefix, name = ("-", spec[1:]) if spec.startswith("-") else ("", spec)
+    return f"{prefix}{name[1:]} (toolset)" if name.startswith("@") else spec
+
+
+def format_tool_specs(tool_specs: List[str]) -> str:
+    """Render a frontmatter tool list as one comma-separated line."""
+    return ", ".join(format_tool_spec(spec) for spec in tool_specs)
+
+
 def load_custom_shell_tools() -> None:
     """Register the shell tools defined in custom_tools.yaml.
 

{tsugite_cli-0.23.0 → tsugite_cli-0.23.2}/tsugite/tools/http.py

@@ -18,6 +18,11 @@ _WEB_EXTRA_HINT = "Install it with: pip install 'tsugite-cli[web]'"
 # reach anything the original request couldn't.
 _MAX_REDIRECTS = 5
 
+# readability emits a near-empty node when it finds no article. An extraction that is
+# both short and a sliver of the whole page means extraction failed, not a short article.
+_MIN_ARTICLE_CHARS = 200
+_ARTICLE_PAGE_RATIO = 10
+
 
 def _extract_article(html: str) -> str:
     """Extract the main article body from HTML using readability (optional dep)."""
@@ -150,9 +155,21 @@ def fetch_text(
     if "text/html" not in content_type or (not strip_html and not extract_article):
         return text
 
-    if extract_article:
-        text = _extract_article(text)
-    return convert_html_to_markdown(text)
+    if not extract_article:
+        return convert_html_to_markdown(text)
+
+    article = convert_html_to_markdown(_extract_article(text))
+    article_len = len(article.strip())
+    if article_len >= _MIN_ARTICLE_CHARS:
+        return article
+
+    page = convert_html_to_markdown(text)
+    page_len = len(page.strip())
+    if not page_len:
+        raise RuntimeError(f"{url} has no readable text; the page is likely rendered client-side")
+    if article_len * _ARTICLE_PAGE_RATIO < page_len:
+        return page
+    return article
 
 
 # No sensitive_args: the built-in key rules already redact Authorization,

{tsugite_cli-0.23.0 → tsugite_cli-0.23.2}/tsugite/ui/jsonl.py

@@ -1,7 +1,7 @@
 """JSONL UI handler for subprocess-based subagent communication."""
 
 import json
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 from tsugite.events import (
     CodeExecutionEvent,
@@ -32,6 +32,7 @@ from tsugite.events import (
     ToolResultEvent,
     WarningEvent,
 )
+from tsugite.events.base import BaseEvent
 from tsugite.ui.dispatch import EventDispatchMixin, handles
 
 # Event types that share the same file-io payload shape
@@ -73,6 +74,17 @@ class JSONLUIHandler(EventDispatchMixin):
     - Failed tool: {"type": "tool_result", "tool": "read_file", "success": false, "error": "..."}
     """
 
+    final_seen = False
+    latest_prompt_messages: Optional[list] = None
+
+    def handle_event(self, event: BaseEvent) -> None:
+        if isinstance(event, PromptSnapshotEvent):
+            if event.messages:
+                self.latest_prompt_messages = event.messages
+            if not event.token_breakdown:
+                return
+        super().handle_event(event)
+
     @handles(TaskStartEvent)
     def _handle_task_start(self, event: TaskStartEvent) -> None:
         self._emit("init", {"agent": event.task, "model": event.model})
@@ -132,6 +144,7 @@ class JSONLUIHandler(EventDispatchMixin):
 
     @handles(FinalAnswerEvent)
     def _handle_final_answer(self, event: FinalAnswerEvent) -> None:
+        self.final_seen = True
         self._emit(
             "final_result",
             {

{tsugite_cli-0.23.0 → tsugite_cli-0.23.2}/tsugite/usage/quota.py

@@ -3,9 +3,8 @@ subscription or budget the user has consumed ("week 73%, resets Aug 19").
 
 A source is contributed by a plugin through the ``tsugite.usage_providers``
 entry point (a module-only entry point whose import registers the source) and
-fetches from whatever local state that provider keeps. The shape has no severity
-field: the UI derives its own warn threshold, and a second source of truth would
-let the two disagree.
+fetches from that provider's local state or API. The shape has no severity
+field because the UI derives its own warn threshold.
 """
 
 from __future__ import annotations
@@ -31,8 +30,8 @@ class QuotaWindow:
 
 @dataclass(frozen=True)
 class QuotaReport:
-    """One provider's quota. ``error`` is set instead of windows when local
-    state was unreadable."""
+    """One provider's quota. ``error`` is set instead of windows when the
+    source could not be read."""
 
     provider: str
     label: str
@@ -69,10 +68,9 @@ def reset_quota_sources() -> None:
 
 
 def ensure_loaded() -> None:
-    """Import the ``tsugite.usage_providers`` entry-point modules once, so every
-    ``register_quota_source`` call has run before the registry is read. The
-    daemon collects from worker threads, so a reader racing the first load
-    waits for it rather than seeing an empty registry."""
+    """Import the ``tsugite.usage_providers`` entry-point modules once, before
+    the registry is read. A daemon worker thread racing the first load waits
+    for it."""
     global _loaded
     if _loaded:
         return
@@ -102,7 +100,7 @@ def collect_quota_reports() -> list[dict]:
             logger.warning("Quota source '%s' failed: %s", source.provider, e)
             report = QuotaReport(provider=source.provider, label=source.label, error=str(e))
         row = asdict(report)
-        # asdict keeps the dataclass's tuple; the wire shape is an array.
+        # asdict keeps windows as a tuple and the wire shape is an array.
         row["windows"] = list(row["windows"])
         rows.append(row)
     return rows

{tsugite_cli-0.23.0 → tsugite_cli-0.23.2}/tsugite/utils.py

@@ -128,6 +128,7 @@ def execute_shell_command(
             shell=shell,
             capture_output=True,
             text=True,
+            errors="replace",
             timeout=timeout,
             check=False,
             cwd=resolved_cwd,