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

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

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

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

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

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

@@ -242,7 +242,7 @@ class AgentPreparer:
         auto_load_skills = [s for s in (agent_config.auto_load_skills or []) if s not in suppressed_skills]
 
         for skill_name in auto_load_skills:
-            result = skill_manager.load_skill(skill_name)
+            result = skill_manager.load_skill(skill_name, explicit=True)
             if result.startswith("Failed") or result.startswith("Skill '"):
                 if event_bus:
                     event_bus.emit(SkillLoadFailedEvent(skill_name=skill_name, error_message=result))
@@ -268,7 +268,7 @@ class AgentPreparer:
             if name in auto_load_skills:
                 # Already loaded above; no need to double-load but it's still sticky.
                 continue
-            result = skill_manager.load_skill(name)
+            result = skill_manager.load_skill(name, explicit=True)
             if result.startswith("Failed") or result.startswith("Skill '"):
                 if event_bus:
                     event_bus.emit(SkillLoadFailedEvent(skill_name=name, error_message=result))

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

@@ -73,7 +73,11 @@ def open_or_create_session(
     backend = get_history_backend()
     if continue_conversation_id:
         if backend.exists(continue_conversation_id):
-            return backend.load(continue_conversation_id)
+            session = backend.load(continue_conversation_id)
+            # Daemon-spawned sessions are created without a model.
+            if session.summary().model is None:
+                session.record("session_start", agent=agent_name, model=model, workspace=workspace)
+            return session
         return backend.create(
             agent_name=agent_name,
             model=model,
@@ -92,8 +96,8 @@ 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. A final_result also ends a turn: compaction copies
-    retained turns into the successor without their session_end.
+    so this stays False for it. A final_result also ends a turn copied without
+    its session_end (branches, older compacted sessions).
     """
     events = list(storage.iter_events(types=("user_input", "session_end", "final_result")))
     return bool(events) and events[-1].type == "user_input"
@@ -129,8 +133,9 @@ def record_user_input(
         data["attachments"] = [
             {"name": a.name, "type": a.content_type.value, "source_url": a.source_url} for a in uploads
         ]
-    if channel_metadata:
-        data["channel"] = channel_metadata
+    channel = {k: v for k, v in (channel_metadata or {}).items() if k != "tsugite_token"}
+    if channel:
+        data["channel"] = channel
     # Structured client context, recorded alongside the folded <client_context> XML
     # in `text` so the UI reads it back without re-parsing the prompt string.
     if client_context_items:
@@ -244,8 +249,8 @@ def save_run_to_history(
     agent_already_recorded = last_model_response > last_session_start
 
     if agent_already_recorded:
-        # A continued conversation pins session_start at index 0, so the current
-        # turn starts at its own user_input.
+        # A continued conversation's session_start can sit at index 0 or come from
+        # a backfill. The current turn starts at its own user_input.
         turn_start = max(last_session_start, last_user_input)
         if last_session_end < turn_start:
             record_session_end(storage, status=status, error_message=error_message)
@@ -264,19 +269,20 @@ def save_run_to_history(
                 tools_called=list(getattr(step, "tools_called", []) or []),
             )
 
-    state_delta = provider_state if provider_state else None
-    # Split as the agent loop records it: bare id in `model`, prefix in `provider`.
-    model_provider, _, model_id = model.partition(":")
-    storage.record(
-        "model_response",
-        provider=model_provider if model_id else None,
-        model=model_id or model,
-        raw_content=result or "",
-        usage={"total_tokens": token_count} if token_count else None,
-        cost=cost,
-        duration_ms=duration_ms,
-        state_delta=state_delta,
-    )
+    if status == "success":
+        state_delta = provider_state if provider_state else None
+        # Split as the agent loop records it: bare id in `model`, prefix in `provider`.
+        model_provider, _, model_id = model.partition(":")
+        storage.record(
+            "model_response",
+            provider=model_provider if model_id else None,
+            model=model_id or model,
+            raw_content=result or "",
+            usage={"total_tokens": token_count} if token_count else None,
+            cost=cost,
+            duration_ms=duration_ms,
+            state_delta=state_delta,
+        )
 
     record_session_end(storage, status=status, error_message=error_message)
     return storage.session_id
@@ -288,6 +294,7 @@ class ResumableSessionState:
 
     session_id: str
     compacted: bool = False
+    cumulative_cost: float = 0.0
 
 
 def get_resumable_session_state(conversation_id: str) -> Optional[ResumableSessionState]:
@@ -324,6 +331,7 @@ def get_resumable_session_state(conversation_id: str) -> Optional[ResumableSessi
             return ResumableSessionState(
                 session_id=session_id,
                 compacted=bool(state.get("compacted", False)),
+                cumulative_cost=state.get("cumulative_cost") or 0.0,
             )
         return None
     except Exception:

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

@@ -395,6 +395,7 @@ async def _execute_agent_with_prompt(
     path_context: Optional[Any] = None,
     resume_session: Optional[str] = None,
     resume_after_compaction: bool = False,
+    resume_cost_baseline: float = 0.0,
     hook_vars: Optional[Dict[str, str]] = None,
     continue_conversation_id: Optional[str] = None,
     user_input_for_history: Optional[str] = None,
@@ -610,9 +611,11 @@ async def _execute_agent_with_prompt(
             previous_messages=previous_messages,
             resume_session=resume_session,
             resume_after_compaction=resume_after_compaction,
+            resume_cost_baseline=resume_cost_baseline,
             hook_vars=hook_vars,
             storage=session_storage,
             pre_llm_call=pre_llm_call_cb,
+            expects_action=(channel_metadata or {}).get("source") == "scheduler",
         )
         # Set event_bus in context so tools can access it during execution
         _setup_event_context(event_bus)
@@ -867,6 +870,7 @@ class _RunSetup:
     previous_messages: List[Dict] = field(default_factory=list)
     resume_session: Optional[str] = None
     resume_after_compaction: bool = False
+    resume_cost_baseline: float = 0.0
     conversation_id: Optional[str] = None
 
 
@@ -958,6 +962,7 @@ async def _run_unit(
             previous_messages=setup.previous_messages,
             resume_session=setup.resume_session,
             resume_after_compaction=setup.resume_after_compaction,
+            resume_cost_baseline=setup.resume_cost_baseline,
             **execute_kwargs,
         )
     except (RuntimeError, AgentExecutionError) as e:
@@ -1151,6 +1156,7 @@ async def run_agent_async(
     previous_messages = []
     resume_session = None
     resume_after_compaction = False
+    resume_cost_baseline = 0.0
     if continue_conversation_id:
         from tsugite.agent_runner.history_integration import (
             get_resumable_session_state,
@@ -1162,6 +1168,7 @@ async def run_agent_async(
         if session_info:
             resume_session = session_info.session_id
             resume_after_compaction = session_info.compacted
+            resume_cost_baseline = session_info.cumulative_cost
             logger.info(
                 "Resuming provider session %s (compacted=%s)",
                 resume_session,
@@ -1210,6 +1217,7 @@ async def run_agent_async(
         previous_messages=previous_messages,
         resume_session=resume_session,
         resume_after_compaction=resume_after_compaction,
+        resume_cost_baseline=resume_cost_baseline,
         conversation_id=continue_conversation_id,
     )
 

{tsugite_cli-0.23.2 → tsugite_cli-0.24.0}/tsugite/agent_runner/steps.py

@@ -251,6 +251,7 @@ async def _execute_step_with_retries(
         user_input_for_history=f"[Step {i}/{total_steps}: {step.name}]",
         resume_session=None,
         resume_after_compaction=False,
+        resume_cost_baseline=0.0,
     )
     errors = []
     step_start_time = time.time()

{tsugite_cli-0.23.2 → tsugite_cli-0.24.0}/tsugite/attachments/agent_config.py

@@ -17,6 +17,12 @@ from tsugite.utils import has_glob_chars
 logger = logging.getLogger(__name__)
 
 
+def _warn_skipped(subject: str, detail: str) -> None:
+    from tsugite.events.helpers import emit_warning_event
+
+    emit_warning_event(f"Agent attachment skipped: {subject} ({detail})")
+
+
 def _render_path(template: str, template_vars: Dict[str, Any]) -> Optional[str]:
     """Render a Jinja path template; return None on render failure."""
     from tsugite.renderer import AgentRenderer
@@ -24,7 +30,7 @@ def _render_path(template: str, template_vars: Dict[str, Any]) -> Optional[str]:
     try:
         return AgentRenderer().render_string(template, template_vars)
     except Exception as e:
-        logger.debug("Failed to render attachment path %r: %s", template, e)
+        _warn_skipped(template, f"path template failed to render: {e}")
         return None
 
 
@@ -124,12 +130,10 @@ def _resolve_string_item(
         return
     resolved = _resolve_path(rendered, workspace_path)
     if not resolved.exists():
-        logger.debug("Agent attachment not found (skipped): %s", resolved)
+        _warn_skipped(template, f"not found: {resolved}")
         return
-    att = file_handler.fetch(str(resolved))
-    if att:
-        attachments.append(att)
-        logger.debug("Loaded agent attachment: %s", resolved)
+    attachments.append(file_handler.fetch(str(resolved)))
+    logger.debug("Loaded agent attachment: %s", resolved)
 
 
 def _resolve_spec(
@@ -161,13 +165,12 @@ def _resolve_spec(
             if not spec.attach and spec.assign:
                 try:
                     content = path.read_text(encoding="utf-8")
-                except (OSError, UnicodeDecodeError):
+                except (OSError, UnicodeDecodeError) as e:
+                    _warn_skipped(str(path), f"unreadable: {e}")
                     continue
                 bindings[spec.assign].append({"path": str(path), "content": content})
                 continue
             att = file_handler.fetch(str(path))
-            if not att:
-                continue
             if spec.attach:
                 attachments.append(att)
             if spec.assign and att.content_type == AttachmentContentType.TEXT:
@@ -178,14 +181,11 @@ def _resolve_spec(
     if not resolved.exists():
         if spec.assign:
             bindings[spec.assign] = None
-        logger.debug("Agent attachment not found (skipped): %s", resolved)
+        else:
+            _warn_skipped(spec.path, f"not found: {resolved}")
         return
 
     att = file_handler.fetch(str(resolved))
-    if not att:
-        if spec.assign:
-            bindings[spec.assign] = None
-        return
     if spec.attach:
         attachments.append(att)
     if spec.assign:

{tsugite_cli-0.23.2 → tsugite_cli-0.24.0}/tsugite/builtin_skills/scheduling/SKILL.md

@@ -178,6 +178,8 @@ print(schedules)
 
 Each schedule includes: `id`, `execution_type`, `schedule_type`, `enabled`, `next_run`, `last_run`, `last_status`, `last_error`.
 
+`last_status` is `success`, `error`, `skipped`, or `no_action`.
+
 ## Managing Schedules
 
 ```python-exec

{tsugite_cli-0.23.2 → tsugite_cli-0.24.0}/tsugite/cli/daemon.py

@@ -4,6 +4,7 @@ import logging
 import os
 import re
 import sys
+from contextlib import contextmanager
 from pathlib import Path
 from typing import Optional
 
@@ -11,15 +12,14 @@ import typer
 from rich.console import Console
 from rich.panel import Panel
 
-from tsugite.constants import DEFAULT_DAEMON_HOST, DEFAULT_DAEMON_PORT
+from tsugite.daemon_client import DaemonClient, DaemonError
 
 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")
+# Precedence: flag > TSUGITE_DAEMON_HOST/PORT > TSUGITE_DAEMON_URL > default.
+HOST_OPTION = typer.Option(None, "--host", envvar="TSUGITE_DAEMON_HOST", help="Daemon HTTP host")
+PORT_OPTION = typer.Option(None, "--port", "-p", envvar="TSUGITE_DAEMON_PORT", help="Daemon HTTP port")
 TOKEN_OPTION = typer.Option(None, "--token", "-t", envvar="TSUGITE_DAEMON_TOKEN", help="Auth token")
 
 
@@ -363,43 +363,25 @@ def init_daemon(
     _show_next_steps(token_file, bot_name)
 
 
-def _daemon_request(method: str, host: str, port: int, path: str, token: Optional[str] = None, **kwargs):
-    """Make an HTTP request to the daemon, handling connection errors and non-2xx responses.
-
-    Returns the parsed JSON response body on success, or exits on failure.
-    """
-    import httpx
-
-    url = f"http://{host}:{port}{path}"
-    headers = {"Authorization": f"Bearer {token}"} if token else {}
-
+@contextmanager
+def _daemon_errors():
+    """Print a daemon failure and exit 1."""
     try:
-        resp = httpx.request(method, url, headers=headers, timeout=kwargs.pop("timeout", 10), **kwargs)
-    except httpx.ConnectError:
-        console.print(f"[red]Could not connect to daemon at {host}:{port}[/red]")
-        raise typer.Exit(1)
-
-    if resp.status_code >= 400:
-        try:
-            msg = resp.json().get("error", resp.text)
-        except Exception:
-            msg = resp.text
-        console.print(f"[red]Error ({resp.status_code}):[/red] {msg}")
+        yield
+    except DaemonError as e:
+        console.print(f"[red]Error ({e.status}):[/red] {e}" if e.status else f"[red]{e}[/red]")
         raise typer.Exit(1)
 
-    return resp.json()
-
 
 @daemon_app.command("sessions")
 def list_sessions(
-    host: str = HOST_OPTION,
-    port: int = PORT_OPTION,
+    host: Optional[str] = HOST_OPTION,
+    port: Optional[int] = PORT_OPTION,
     token: Optional[str] = TOKEN_OPTION,
 ):
     """List active daemon sessions."""
-    data = _daemon_request("GET", host, port, "/api/chat/sessions", token)
-
-    sessions = data.get("sessions", [])
+    with _daemon_errors():
+        sessions = DaemonClient(host, port, token).list_chat_sessions()
     if not sessions:
         console.print("No active sessions")
         return
@@ -418,20 +400,13 @@ def list_sessions(
 @daemon_app.command("compact")
 def compact_session(
     user_id: str = typer.Option("web-anonymous", "--user", "-u", help="User ID to compact"),
-    host: str = HOST_OPTION,
-    port: int = PORT_OPTION,
+    host: Optional[str] = HOST_OPTION,
+    port: Optional[int] = PORT_OPTION,
     token: Optional[str] = TOKEN_OPTION,
 ):
     """Force compact a daemon session."""
-    data = _daemon_request(
-        "POST",
-        host,
-        port,
-        "/api/chat/compact",
-        token,
-        json={"user_id": user_id},
-        timeout=120,
-    )
+    with _daemon_errors():
+        data = DaemonClient(host, port, token).compact_chat(user_id)
     console.print(f"[green]✓[/green] Session compacted for user [cyan]{user_id}[/cyan]")
     console.print(f"  old: {data['old_conversation_id']}")
     console.print(f"  new: {data['new_conversation_id']}")
@@ -448,41 +423,40 @@ 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 = HOST_OPTION,
-    port: int = PORT_OPTION,
+    host: Optional[str] = HOST_OPTION,
+    port: Optional[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={})
+    with _daemon_errors():
+        DaemonClient(host, port, token).set_primary_session(session_id)
     console.print(f"[green]✓[/green] Session [cyan]{session_id}[/cyan] is now primary")
 
 
 @session_app.command("clear-primary")
 def session_clear_primary(
     user_id: str = typer.Option("web-anonymous", "--user", "-u", help="User ID"),
-    host: str = HOST_OPTION,
-    port: int = PORT_OPTION,
+    host: Optional[str] = HOST_OPTION,
+    port: Optional[int] = PORT_OPTION,
     token: Optional[str] = TOKEN_OPTION,
 ):
     """Remove the primary flag from any of the user's sessions."""
-    from urllib.parse import urlencode
-
-    path = f"/api/sessions/clear-primary?{urlencode({'user_id': user_id})}"
-    _daemon_request("POST", host, port, path, token)
+    with _daemon_errors():
+        DaemonClient(host, port, token).clear_primary_session(user_id)
     console.print(f"[green]✓[/green] Cleared primary for user [cyan]{user_id}[/cyan]")
 
 
 @session_app.command("list")
 def session_list(
-    host: str = HOST_OPTION,
-    port: int = PORT_OPTION,
+    host: Optional[str] = HOST_OPTION,
+    port: Optional[int] = PORT_OPTION,
     token: Optional[str] = TOKEN_OPTION,
 ):
     """List all daemon sessions, indicating which one is primary."""
     from rich.table import Table
 
-    data = _daemon_request("GET", host, port, "/api/sessions", token)
-    sessions = data.get("sessions", [])
+    with _daemon_errors():
+        sessions = DaemonClient(host, port, token).list_sessions()
     if not sessions:
         console.print("No sessions")
         return
@@ -520,15 +494,15 @@ def _parse_every_to_cron(every: str) -> str:
 
 @schedule_app.command("list")
 def schedule_list(
-    host: str = HOST_OPTION,
-    port: int = PORT_OPTION,
+    host: Optional[str] = HOST_OPTION,
+    port: Optional[int] = PORT_OPTION,
     token: Optional[str] = TOKEN_OPTION,
 ):
     """List all schedules."""
     from rich.table import Table
 
-    data = _daemon_request("GET", host, port, "/api/schedules", token)
-    schedules = data.get("schedules", [])
+    with _daemon_errors():
+        schedules = DaemonClient(host, port, token).list_schedules()
     if not schedules:
         console.print("No schedules configured")
         return
@@ -545,7 +519,7 @@ def schedule_list(
         sched_str = s.get("cron_expr") or s.get("run_at") or ""
         enabled = "[green]yes[/green]" if s.get("enabled") else "[red]no[/red]"
         status = s.get("last_status") or "-"
-        if status == "error":
+        if status in ("error", "no_action"):
             status = f"[red]{status}[/red]"
         elif status == "success":
             status = f"[green]{status}[/green]"
@@ -572,8 +546,8 @@ def schedule_add(
         "--target-session",
         help="Where the inject_history turn lands: primary, originating, none, name:<n>, or <session_id>",
     ),
-    host: str = HOST_OPTION,
-    port: int = PORT_OPTION,
+    host: Optional[str] = HOST_OPTION,
+    port: Optional[int] = PORT_OPTION,
     token: Optional[str] = TOKEN_OPTION,
 ):
     """Add a new schedule."""
@@ -601,7 +575,8 @@ def schedule_add(
     if target_session:
         body["target_session"] = target_session
 
-    data = _daemon_request("POST", host, port, "/api/schedules", token, json=body)
+    with _daemon_errors():
+        data = DaemonClient(host, port, token).create_schedule(**body)
     console.print(f"[green]✓[/green] Schedule [cyan]{schedule_id}[/cyan] created")
     if data.get("next_run"):
         console.print(f"  next run: {data['next_run']}")
@@ -609,12 +584,13 @@ def schedule_add(
 
 @schedule_app.command("cleanup")
 def schedule_cleanup(
-    host: str = HOST_OPTION,
-    port: int = PORT_OPTION,
+    host: Optional[str] = HOST_OPTION,
+    port: Optional[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)
+    with _daemon_errors():
+        data = DaemonClient(host, port, token).cleanup_schedules()
     removed = data.get("removed", [])
     if not removed:
         console.print("Nothing to clean up")
@@ -627,60 +603,65 @@ def schedule_cleanup(
 @schedule_app.command("remove")
 def schedule_remove(
     schedule_id: str = typer.Argument(help="Schedule ID to remove"),
-    host: str = HOST_OPTION,
-    port: int = PORT_OPTION,
+    host: Optional[str] = HOST_OPTION,
+    port: Optional[int] = PORT_OPTION,
     token: Optional[str] = TOKEN_OPTION,
 ):
     """Remove a schedule."""
-    _daemon_request("DELETE", host, port, f"/api/schedules/{schedule_id}", token)
+    with _daemon_errors():
+        DaemonClient(host, port, token).delete_schedule(schedule_id)
     console.print(f"[green]✓[/green] Schedule [cyan]{schedule_id}[/cyan] removed")
 
 
 @schedule_app.command("enable")
 def schedule_enable(
     schedule_id: str = typer.Argument(help="Schedule ID"),
-    host: str = HOST_OPTION,
-    port: int = PORT_OPTION,
+    host: Optional[str] = HOST_OPTION,
+    port: Optional[int] = PORT_OPTION,
     token: Optional[str] = TOKEN_OPTION,
 ):
     """Enable a schedule."""
-    _daemon_request("POST", host, port, f"/api/schedules/{schedule_id}/enable", token)
+    with _daemon_errors():
+        DaemonClient(host, port, token).enable_schedule(schedule_id)
     console.print(f"[green]✓[/green] Schedule [cyan]{schedule_id}[/cyan] enabled")
 
 
 @schedule_app.command("disable")
 def schedule_disable(
     schedule_id: str = typer.Argument(help="Schedule ID"),
-    host: str = HOST_OPTION,
-    port: int = PORT_OPTION,
+    host: Optional[str] = HOST_OPTION,
+    port: Optional[int] = PORT_OPTION,
     token: Optional[str] = TOKEN_OPTION,
 ):
     """Disable a schedule."""
-    _daemon_request("POST", host, port, f"/api/schedules/{schedule_id}/disable", token)
+    with _daemon_errors():
+        DaemonClient(host, port, token).disable_schedule(schedule_id)
     console.print(f"[green]✓[/green] Schedule [cyan]{schedule_id}[/cyan] disabled")
 
 
 @schedule_app.command("run")
 def schedule_run(
     schedule_id: str = typer.Argument(help="Schedule ID to trigger now"),
-    host: str = HOST_OPTION,
-    port: int = PORT_OPTION,
+    host: Optional[str] = HOST_OPTION,
+    port: Optional[int] = PORT_OPTION,
     token: Optional[str] = TOKEN_OPTION,
 ):
     """Trigger a schedule immediately."""
-    _daemon_request("POST", host, port, f"/api/schedules/{schedule_id}/run", token)
+    with _daemon_errors():
+        DaemonClient(host, port, token).run_schedule(schedule_id)
     console.print(f"[green]✓[/green] Schedule [cyan]{schedule_id}[/cyan] triggered")
 
 
 @schedule_app.command("show")
 def schedule_show(
     schedule_id: str = typer.Argument(help="Schedule ID"),
-    host: str = HOST_OPTION,
-    port: int = PORT_OPTION,
+    host: Optional[str] = HOST_OPTION,
+    port: Optional[int] = PORT_OPTION,
     token: Optional[str] = TOKEN_OPTION,
 ):
     """Show schedule details."""
-    data = _daemon_request("GET", host, port, f"/api/schedules/{schedule_id}", token)
+    with _daemon_errors():
+        data = DaemonClient(host, port, token).get_schedule(schedule_id)
 
     console.print(f"[bold]{data['id']}[/bold]")
     console.print(f"  agent:    {data['agent']}")

{tsugite_cli-0.23.2 → tsugite_cli-0.24.0}/tsugite/cli/history.py

@@ -55,7 +55,7 @@ def _format_cost(cost: Optional[float]) -> str:
 
 
 def _status_style(status: Optional[str]) -> str:
-    return {"success": "green", "error": "red", "interrupted": "yellow"}.get(status or "", "dim")
+    return {"success": "green", "error": "red", "no_action": "red", "interrupted": "yellow"}.get(status or "", "dim")
 
 
 def _format_created(dt: Optional[datetime]) -> str:
@@ -77,7 +77,7 @@ def _parse_date(date_str: Optional[str]) -> Optional[datetime]:
 @history_app.command("list")
 def history_list(
     agent: str = typer.Option(None, "--agent", help="Filter by agent name"),
-    status: str = typer.Option(None, "--status", help="Filter by status (success, error, interrupted)"),
+    status: str = typer.Option(None, "--status", help="Filter by status (success, error, interrupted, no_action)"),
     tool: str = typer.Option(None, "--tool", help="Filter by tool/function name"),
     since: str = typer.Option(None, "--since", help="Only sessions after this date (YYYY-MM-DD)"),
     before: str = typer.Option(None, "--before", help="Only sessions before this date (YYYY-MM-DD)"),