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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tsugite-cli
-Version: 0.23.2
+Version: 0.24.1
 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.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.23.2"
+version = "0.24.1"
 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.1}/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.1}/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.1}/tsugite/agent_runner/runner.py

@@ -10,7 +10,7 @@ from pathlib import Path  # noqa: E402
 from types import SimpleNamespace  # noqa: E402
 from typing import TYPE_CHECKING, Any, Dict, List, Optional  # noqa: E402
 
-from tsugite.core.agent import TsugiteAgent  # noqa: E402
+from tsugite.core.agent import NO_ACTION_MESSAGE, AgentResult, TsugiteAgent  # noqa: E402
 from tsugite.core.executor_registry import get_executor_class  # noqa: E402
 from tsugite.core.proxy import _parse_pattern  # noqa: E402
 from tsugite.core.state import session_state_path  # noqa: E402
@@ -395,11 +395,13 @@ 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,
     channel_metadata: Optional[Dict[str, Any]] = None,
     usage_sink: Optional[Dict[str, Any]] = None,
+    requires_action: bool = False,
 ) -> str | AgentExecutionResult:
     """Execute agent with a prepared agent.
 
@@ -408,6 +410,9 @@ async def _execute_agent_with_prompt(
     `usage_sink`, when given, receives this call's token and cost counters. It is
     how a multi-step run collects accounting from steps that return plain
     strings.
+
+    `requires_action` makes a run that ends without executing any code raise, so a
+    step whose result feeds later steps cannot pass on a prose answer.
     """
     if exec_options is None:
         exec_options = ExecutionOptions()
@@ -610,9 +615,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=requires_action or (channel_metadata or {}).get("source") == "scheduler",
         )
         # Set event_bus in context so tools can access it during execution
         _setup_event_context(event_bus)
@@ -663,10 +670,18 @@ async def _execute_agent_with_prompt(
         except Exception as e:
             logger.debug("Failed to record usage: %s", e)
 
+        if requires_action and agent.ended_no_action:
+            steps = result.steps if isinstance(result, AgentResult) and result.steps else []
+            raise AgentExecutionError(
+                NO_ACTION_MESSAGE,
+                execution_steps=steps,
+                token_usage=agent.total_tokens,
+                cost=agent.reported_cost,
+                step_count=len(steps),
+            )
+
         # Return appropriate format
         if exec_options.return_token_usage:
-            from tsugite.core.agent import AgentResult
-
             if isinstance(result, AgentResult):
                 step_count = len(result.steps) if result.steps else 0
                 steps_list = result.steps if result.steps else []
@@ -709,8 +724,6 @@ async def _execute_agent_with_prompt(
                     session_id=session_storage.session_id if session_storage else None,
                 )
         else:
-            from tsugite.core.agent import AgentResult
-
             if isinstance(result, AgentResult):
                 return str(result.output)
             else:
@@ -867,7 +880,9 @@ 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
+    requires_action: bool = False
 
 
 def _prepare_step(agent: Any, prompt: str, context: Dict[str, Any], setup: "_RunSetup") -> "PreparedAgent":
@@ -951,6 +966,7 @@ async def _run_unit(
         model_kwargs=model_kwargs,
         injectable_vars=injectable_vars,
         usage_sink=usage_sink,
+        requires_action=setup.requires_action,
     )
 
     try:
@@ -958,6 +974,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 +1168,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 +1180,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 +1229,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.1}/tsugite/agent_runner/steps.py

@@ -251,6 +251,8 @@ 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,
+        requires_action=bool(step.assign_var),
     )
     errors = []
     step_start_time = time.time()

{tsugite_cli-0.23.2 → tsugite_cli-0.24.1}/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)
+        elif not spec.optional:
+            _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.1}/tsugite/builtin_agents/default.md

@@ -6,9 +6,17 @@ extends: none
 # volatile memory last, so a change to today's memory / now.md doesn't invalidate
 # the identity files' cache. A flat list would be one block; these are three.
 attachments:
-  - [PERSONA.md, SOUL.md, USER.md, IDENTITY.md, AGENTS.md]
-  - [MEMORY.md, "memory/{{ yesterday() }}.md", "memory/{{ date_format(now(), '%Y-%m') }}.md"]
-  - ["memory/{{ today() }}.md", notes/context/now.md, NOW.md]
+  - - {path: PERSONA.md, optional: true}
+    - {path: SOUL.md, optional: true}
+    - {path: USER.md, optional: true}
+    - {path: IDENTITY.md, optional: true}
+    - {path: AGENTS.md, optional: true}
+  - - {path: MEMORY.md, optional: true}
+    - {path: "memory/{{ yesterday() }}.md", optional: true}
+    - {path: "memory/{{ date_format(datetime.now().replace(day=1) - timedelta(days=1), '%Y-%m') }}.md", optional: true}
+  - - {path: "memory/{{ today() }}.md", optional: true}
+    - {path: notes/context/now.md, optional: true}
+    - {path: NOW.md, optional: true}
 max_turns: 10
 tools:
   - spawn_agent

{tsugite_cli-0.23.2 → tsugite_cli-0.24.1}/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