tsugite-cli 0.14.1__tar.gz → 0.14.2__tar.gz

{tsugite_cli-0.14.1 → tsugite_cli-0.14.2}/PKG-INFO

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

{tsugite_cli-0.14.1 → tsugite_cli-0.14.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.14.1"
+version = "0.14.2"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"
@@ -85,7 +85,7 @@ line-length = 120
 
 [tool.pytest.ini_options]
 testpaths = ["tests", "plugins"]
-addopts = "-n auto --dist loadscope --cov=tsugite --cov-report=term-missing --cov-report=html --cov-report=xml"
+addopts = "-n auto --dist loadfile --cov=tsugite --cov-report=term-missing --cov-report=html --cov-report=xml"
 asyncio_mode = "strict"
 asyncio_default_fixture_loop_scope = "function"
 filterwarnings = ["ignore::RuntimeWarning"]

{tsugite_cli-0.14.1 → tsugite_cli-0.14.2}/tsugite/agent_inheritance.py

@@ -281,6 +281,7 @@ def merge_scalar_fields(parent, child) -> Dict[str, Any]:
         "model": child.model if child.model else parent.model,
         "max_turns": child.max_turns if child.max_turns != 5 else parent.max_turns,
         "reasoning_effort": child.reasoning_effort if child.reasoning_effort else parent.reasoning_effort,
+        "auto_load_agent_list": child.auto_load_agent_list or parent.auto_load_agent_list,
     }
 
 
@@ -321,6 +322,7 @@ def merge_list_fields(parent, child) -> Dict[str, List]:
     merged_tools = _merge_dedup(parent.tools, child.tools)
     merged_attachments = _merge_attachments(parent.attachments, child.attachments)
     merged_skills = _merge_dedup(parent.auto_load_skills, child.auto_load_skills)
+    merged_auto_load_agents = _merge_dedup(parent.auto_load_agents, child.auto_load_agents)
 
     # Custom tools - deduplicate by "name" field (child overrides parent)
     custom_tool_dict = {}
@@ -333,6 +335,7 @@ def merge_list_fields(parent, child) -> Dict[str, List]:
         "prefetch": (parent.prefetch or []) + (child.prefetch or []),
         "custom_tools": list(custom_tool_dict.values()),
         "auto_load_skills": merged_skills,
+        "auto_load_agents": merged_auto_load_agents,
     }
 
 

{tsugite_cli-0.14.1 → tsugite_cli-0.14.2}/tsugite/agent_preparation.py

@@ -547,6 +547,19 @@ class AgentPreparer:
                 # Silently continue if prefetch fails
                 prefetch_context = {}
 
+        # Step 1b: Opt-in <available_agents> injection. Default agents call
+        # list_available_agents() on demand instead of carrying the full list.
+        if "available_agents" not in prefetch_context and (
+            agent_config.auto_load_agent_list or agent_config.auto_load_agents
+        ):
+            from tsugite.tools.agents import discover_agents, format_agents_markdown
+
+            agents = discover_agents()
+            if agent_config.auto_load_agents:
+                wanted = set(agent_config.auto_load_agents)
+                agents = [a for a in agents if a["name"] in wanted]
+            prefetch_context["available_agents"] = format_agents_markdown(agents)
+
         # Step 2: Execute tool directives (unless skip_tool_directives=True for render)
         if skip_tool_directives:
             modified_content = agent.content

{tsugite_cli-0.14.1 → tsugite_cli-0.14.2}/tsugite/builtin_agents/default.md

@@ -15,6 +15,7 @@ attachments:
 max_turns: 10
 tools:
   - spawn_agent
+  - list_available_agents
   - read_file
   - list_files
   - write_file
@@ -36,9 +37,6 @@ tools:
 auto_load_skills:
   - response-patterns
 prefetch:
-  - tool: list_agents
-    args: {}
-    assign: available_agents
   - tool: get_skills_for_template
     args: {}
     assign: available_skills
@@ -54,6 +52,14 @@ instructions: |
   Before starting work, check the `<available_skills>` section and load one if it matches.
   Call `load_skill("skill_name")` and wait for the next turn before proceeding.
 
+  ## Delegating to Sub-Agents
+
+  The list of available sub-agents is not auto-attached to your context. When a task
+  clearly benefits from a specialized agent (and isn't something you can handle inline),
+  call `list_available_agents()` to discover them, then `spawn_agent(path, prompt)` to
+  delegate. Skip both for simple tasks or single-file edits - most work doesn't need
+  delegation.
+
   ## Guidelines
 
   - Be concise and direct in your responses

{tsugite_cli-0.14.1 → tsugite_cli-0.14.2}/tsugite/core/executor.py

@@ -8,18 +8,47 @@ injected `state` object persist across turns.
 """
 
 import ast
+import contextlib
 import io
+import os
 import pprint
 import sys
+import threading
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, Iterator, List, Optional
 
 from tsugite.core.state import load_state, save_state
 from tsugite.exceptions import StateSerializationError
 
 PPRINT_WIDTH = 100
 
+# CWD is process-global. Concurrent execute() calls in different threads must
+# serialize their chdir+exec+restore window; the lock is held across the whole
+# user-code exec(), so heavy parallel LocalExecutor turns serialize end-to-end.
+# Accepted trade-off: silent disagreement between raw `os.getcwd()` and tool
+# path resolution is worse than the serialization. `spawn_session` returns
+# immediately so a parent holding the lock doesn't starve a nested child.
+_chdir_lock = threading.Lock()
+
+
+@contextlib.contextmanager
+def _locked_chdir(target: Optional[Path]) -> Iterator[None]:
+    """chdir to target under `_chdir_lock`; restore CWD and release on exit.
+
+    No-op when target is None.
+    """
+    if target is None:
+        yield
+        return
+    with _chdir_lock:
+        previous = os.getcwd()
+        os.chdir(str(target))
+        try:
+            yield
+        finally:
+            os.chdir(previous)
+
 
 def _looks_html_escaped(source: str) -> bool:
     """True if `source` is HTML-entity-escaped XML (observation content leaked into exec)."""
@@ -203,6 +232,11 @@ class LocalExecutor:
         self._sticky_injections: Dict[str, Any] = {}
         self._content_blocks: Dict[str, str] = {}
 
+        target = workspace_dir
+        if target is None and path_context is not None:
+            target = path_context.effective_cwd or path_context.workspace_dir
+        self._chdir_target_resolved: Optional[Path] = Path(target).resolve() if target is not None else None
+
         self.namespace: Dict[str, Any] = self._build_turn_namespace()
 
     def _build_turn_namespace(self) -> Dict[str, Any]:
@@ -317,11 +351,24 @@ class LocalExecutor:
             return pprint.pformat(value, width=PPRINT_WIDTH, compact=False)
         return repr(value)
 
+    def _workspace_chdir_target(self) -> Optional[Path]:
+        """Target for the per-execute chdir, or None if CWD already matches (or no workspace)."""
+        target = self._chdir_target_resolved
+        if target is None:
+            return None
+        try:
+            if target == Path.cwd().resolve():
+                return None
+        except FileNotFoundError:
+            pass
+        return target
+
     async def execute(self, code: str) -> ExecutionResult:
         """Execute code using exec().
 
         Automatically displays the value of the last expression (REPL-like behavior).
-        CWD is managed at CLI level - no directory changes here.
+        When a workspace is bound, chdir to it under a process-wide lock so raw
+        Python file APIs (os.getcwd, open, Path.cwd) resolve against the workspace.
 
         Args:
             code: Python code to execute
@@ -367,19 +414,20 @@ class LocalExecutor:
             sys.stdout = stdout_capture
             sys.stderr = stderr_capture
 
-            setup_code, last_expr = self._split_code_for_last_expr(code)
+            with _locked_chdir(self._workspace_chdir_target()):
+                setup_code, last_expr = self._split_code_for_last_expr(code)
 
-            if last_expr:
-                if setup_code.strip():
-                    exec(setup_code, self.namespace)
+                if last_expr:
+                    if setup_code.strip():
+                        exec(setup_code, self.namespace)
 
-                result = eval(last_expr, self.namespace)
+                    result = eval(last_expr, self.namespace)
 
-                if result is not None:
-                    formatted = self._format_value(result)
-                    print(formatted)
-            else:
-                exec(code, self.namespace)
+                    if result is not None:
+                        formatted = self._format_value(result)
+                        print(formatted)
+                else:
+                    exec(code, self.namespace)
 
         except Exception as e:
             exec_error = f"{type(e).__name__}: {str(e)}"

{tsugite_cli-0.14.1 → tsugite_cli-0.14.2}/tsugite/daemon/adapters/base.py

@@ -83,7 +83,7 @@ _BROADCAST_SKIP_EVENTS = frozenset({"stream_chunk", "stream_complete", "prompt_s
 
 # Event types persisted to the session JSONL by the SSE handler so the web UI
 # can replay them after a reload (the agent already records execution events).
-_PERSIST_EVENT_TYPES = frozenset({"prompt_snapshot", "reaction", "final_result", "error", "cancelled"})
+_PERSIST_EVENT_TYPES = frozenset({"prompt_snapshot", "reaction", "final_result", "error", "cancelled", "info"})
 
 
 class SSEBroadcastHandler(JSONLUIHandler):
@@ -355,12 +355,17 @@ class BaseAdapter(ABC):
         if custom_logger and hasattr(custom_logger, "ui_handler"):
             custom_logger.ui_handler._emit(event_type, {})
 
-    def _broadcast_compaction(self, event_type: str, agent: str, **payload: Any) -> None:
-        """Broadcast a compaction lifecycle/progress event to SSE subscribers."""
+    def _broadcast_compaction(self, event_type: str, agent: str, session_id: str, **payload: Any) -> None:
+        """Broadcast a compaction lifecycle/progress event to SSE subscribers.
+
+        session_id is required so per-session UI state (the "compacting…"
+        spinner, composer-disabled flag) can scope itself to the actual
+        compacting session instead of bleeding to every session in the agent.
+        """
         if not self.event_bus:
             return
         try:
-            self.event_bus.emit(event_type, {"agent": agent, **payload})
+            self.event_bus.emit(event_type, {"agent": agent, "session_id": session_id, **payload})
         except Exception:
             logger.debug("Failed to broadcast %s", event_type)
 
@@ -511,7 +516,10 @@ class BaseAdapter(ABC):
         if not self.event_bus:
             return
         try:
-            self.event_bus.emit("history_update", {"agent": self.agent_name})
+            payload: Dict[str, Any] = {"agent": self.agent_name}
+            if conv_id:
+                payload["session_id"] = conv_id
+            self.event_bus.emit("history_update", payload)
             if conv_id:
                 self.event_bus.emit("session_update", {"action": "updated", "id": conv_id})
         except Exception as e:
@@ -740,18 +748,18 @@ class BaseAdapter(ABC):
         for non-default or non-interactive sources.
         """
         new_session: Optional[Session] = None
-        if self.session_store.begin_compaction(user_id, self.agent_name):
+        if self.session_store.begin_compaction(user_id, self.agent_name, session_id=conv_id):
             self._emit_ui(custom_logger, "compacting")
-            self._broadcast_compaction("compaction_started", self.agent_name)
+            self._broadcast_compaction("compaction_started", self.agent_name, conv_id)
 
             def progress_cb(payload: Dict[str, Any]) -> None:
-                self._broadcast_compaction("compaction_progress", self.agent_name, **payload)
+                self._broadcast_compaction("compaction_progress", self.agent_name, conv_id, **payload)
 
             try:
                 new_session = await self._compact_session(conv_id, reason=reason, progress_callback=progress_cb)
             finally:
-                self.session_store.end_compaction(user_id, self.agent_name)
-                self._broadcast_compaction("compaction_finished", self.agent_name)
+                self.session_store.end_compaction(user_id, self.agent_name, session_id=conv_id)
+                self._broadcast_compaction("compaction_finished", self.agent_name, conv_id)
         else:
             self._emit_ui(custom_logger, "compacting_waiting")
             done = await asyncio.to_thread(self.session_store.wait_for_compaction, user_id, self.agent_name)
@@ -836,7 +844,7 @@ class BaseAdapter(ABC):
                     self.session_store.drop_sticky(conv_id, name)
                     if self.event_bus:
                         try:
-                            self.event_bus.emit(SkillUnloadedEvent(skill_name=name))
+                            self.event_bus.emit(SkillUnloadedEvent(skill_name=name, session_id=conv_id))
                         except Exception:
                             logger.debug("Failed to emit SkillUnloadedEvent for %s", name, exc_info=True)
         except Exception:

{tsugite_cli-0.14.1 → tsugite_cli-0.14.2}/tsugite/daemon/adapters/http.py

@@ -7,12 +7,15 @@ import mimetypes
 import re
 import shutil
 import threading
-from dataclasses import asdict
+from dataclasses import asdict, dataclass
 from dataclasses import fields as dataclass_fields
 from datetime import datetime, timezone
 from pathlib import Path
 from types import SimpleNamespace
-from typing import Any, Callable, Optional
+from typing import TYPE_CHECKING, Any, Callable, Optional
+
+if TYPE_CHECKING:
+    from tsugite.daemon.session_store import SessionStore
 
 from starlette.applications import Starlette
 from starlette.requests import Request
@@ -23,7 +26,7 @@ from starlette.staticfiles import StaticFiles
 from tsugite.agent_inheritance import get_builtin_agents_path, get_global_agents_paths
 from tsugite.attachments.base import AttachmentContentType
 from tsugite.attachments.file import FileHandler
-from tsugite.daemon.adapters.base import BaseAdapter, ChannelContext
+from tsugite.daemon.adapters.base import _PERSIST_EVENT_TYPES, BaseAdapter, ChannelContext
 from tsugite.daemon.config import AgentConfig, HTTPConfig
 from tsugite.daemon.scheduler import ScheduleEntry
 from tsugite.daemon.webhook_store import WebhookStore
@@ -36,6 +39,27 @@ from tsugite.utils import parse_yaml_frontmatter
 WEB_DIR = Path(__file__).resolve().parent.parent / "web"
 
 
+def build_session_event_persister(session_store: "SessionStore", session_id: str) -> Callable:
+    """Persist selected agent events to the per-session JSONL, and sync
+    `Session.cumulative_tokens` to `prompt_snapshot.token_breakdown.total` so
+    the UI badge matches the prompt inspector. See `tests/test_displayed_token_count.py`
+    for the failure modes this addresses.
+    """
+
+    def _persist(payload: dict[str, Any]) -> None:
+        session_store.append_event(
+            session_id,
+            {**payload, "timestamp": datetime.now(timezone.utc).isoformat()},
+        )
+        if payload.get("type") != "prompt_snapshot":
+            return
+        total = (payload.get("token_breakdown") or {}).get("total")
+        if isinstance(total, int) and total > 0:
+            session_store.set_cumulative_tokens(session_id, total)
+
+    return _persist
+
+
 def _resolve_full_model_id(model: str) -> str:
     """Return 'provider:full-model-id' so UI can show e.g. claude_code:opus -> claude-opus-4-7.
 
@@ -243,9 +267,9 @@ async def sse_stream(queue: asyncio.Queue, keepalive_interval: float = 15.0):
 # fires history_update on the global event bus after the turn settles, which
 # triggers loadHistory() in those tabs and rebuilds the message list from JSONL.
 # Broadcasting turn-end events too would race the active tab's per-chat reader
-# (sendingBySession is cleared in streaming.js's finally block, leaving a window
-# where late-arriving session_event(final_result) bypasses the dedup guard and
-# pushes a duplicate bubble until the next reload).
+# (the session's `sending` flag in sessionsState is cleared in streaming.js's
+# finally block, leaving a window where late-arriving session_event(final_result)
+# bypasses the dedup guard and pushes a duplicate bubble until the next reload).
 _BROADCAST_SKIP_EVENTS = frozenset(
     {
         "stream_chunk",
@@ -312,7 +336,7 @@ class SSEProgressHandler(JSONLUIHandler):
         else:
             self.queue.put_nowait(payload)
 
-        if event_type in ("prompt_snapshot", "reaction", "final_result", "error", "cancelled") and self._persist_event:
+        if event_type in _PERSIST_EVENT_TYPES and self._persist_event:
             self._persist_event(payload)
 
         if self._broadcaster and self._session_id and event_type not in _BROADCAST_SKIP_EVENTS:
@@ -393,6 +417,20 @@ class HTTPAgentAdapter(BaseAdapter):
         pass
 
 
+@dataclass
+class ActiveChat:
+    """In-flight chat interaction. One per (agent, user, session_id) triple.
+
+    Consolidates what used to be three parallel maps keyed by the same triple
+    so adding a fourth piece of per-chat state doesn't mean adding a fourth map
+    and remembering to keep their lifecycles in sync.
+    """
+
+    backend: HTTPInteractionBackend
+    progress: SSEProgressHandler
+    task: Optional[asyncio.Task] = None
+
+
 class HTTPServer:
     """Runs a Starlette ASGI app with uvicorn for the HTTP API."""
 
@@ -416,9 +454,7 @@ class HTTPServer:
         self.session_runner = None  # Set by Gateway after SessionRunner is created
         self.push_store = None  # Set by Gateway if web-push is configured
         self.vapid_public_key = None  # Set by Gateway if web-push is configured
-        self._active_backends: dict[tuple[str, str, str], HTTPInteractionBackend] = {}
-        self._active_chat_tasks: dict[tuple[str, str, str], asyncio.Task] = {}
-        self._active_progress: dict[tuple[str, str, str], SSEProgressHandler] = {}
+        self._active_chats: dict[tuple[str, str, str], ActiveChat] = {}
         self.event_bus = SSEBroadcaster()
         self.app = self._build_app()
 
@@ -650,7 +686,7 @@ class HTTPServer:
         if err := self._check_auth(request):
             return err
         running_by_agent: dict[str, set[str]] = {}
-        for agent_name, _user_id, session_id in self._active_backends:
+        for agent_name, _user_id, session_id in self._active_chats:
             running_by_agent.setdefault(agent_name, set()).add(session_id)
         agents = [
             {
@@ -790,7 +826,8 @@ class HTTPServer:
             tokens = session.cumulative_tokens
             message_count = session.message_count
             session_metadata = session.metadata or {}
-            backend = self._active_backends.get((adapter.agent_name, user_id, session.id))
+            chat = self._active_chats.get((adapter.agent_name, user_id, session.id))
+            backend = chat.backend if chat else None
         else:
             tokens, message_count, session_metadata, backend = 0, 0, {}, None
 
@@ -802,7 +839,9 @@ class HTTPServer:
                 "context_limit": adapter.session_store.get_context_limit(adapter.agent_name),
                 "threshold": adapter.session_store.get_compaction_threshold(adapter.agent_name),
                 "message_count": message_count,
-                "compacting": adapter.session_store.is_compacting(user_id, adapter.agent_name),
+                "compacting": adapter.session_store.is_compacting(
+                    user_id, adapter.agent_name, session_id=session.id if session else None
+                ),
                 "metadata": session_metadata,
                 "busy": backend is not None,
                 "pending_message": backend.pending_message if backend else None,
@@ -950,7 +989,8 @@ class HTTPServer:
         breakdown = snapshots[-1].get("token_breakdown", {}) if snapshots else {}
 
         backend_key = (agent_name, user_id, session_id)
-        live_progress = self._active_progress.get(backend_key)
+        chat = self._active_chats.get(backend_key)
+        live_progress = chat.progress if chat else None
         if live_progress and live_progress.latest_prompt_messages:
             return JSONResponse(
                 {
@@ -993,10 +1033,10 @@ class HTTPServer:
         agent_name = request.path_params["agent"]
         old_conv_id = session.id
 
-        if not adapter.session_store.begin_compaction(user_id, adapter.agent_name):
+        if not adapter.session_store.begin_compaction(user_id, adapter.agent_name, session_id=old_conv_id):
             return JSONResponse({"error": "compaction already in progress"}, status_code=409)
 
-        adapter._broadcast_compaction("compaction_started", agent_name)
+        adapter._broadcast_compaction("compaction_started", agent_name, old_conv_id)
         new_session = None
         try:
             instructions = body.get("instructions")
@@ -1006,8 +1046,8 @@ class HTTPServer:
             logger.exception("Compaction failed for agent %s", adapter.agent_name)
             return JSONResponse({"error": f"compaction failed: {msg}"}, status_code=500)
         finally:
-            adapter.session_store.end_compaction(user_id, adapter.agent_name)
-            adapter._broadcast_compaction("compaction_finished", agent_name)
+            adapter.session_store.end_compaction(user_id, adapter.agent_name, session_id=old_conv_id)
+            adapter._broadcast_compaction("compaction_finished", agent_name, old_conv_id)
 
         self.event_bus.emit("agent_status", {"agent": agent_name})
         if new_session:
@@ -1220,11 +1260,11 @@ class HTTPServer:
         logger.info("[%s] respond from user_id=%s session_id=%s", agent_name, user_id, session_id)
 
         key = (agent_name, user_id, session_id)
-        backend = self._active_backends.get(key)
-        if not backend:
+        chat = self._active_chats.get(key)
+        if not chat:
             return JSONResponse({"error": "no pending question for this session"}, status_code=404)
 
-        backend.submit_response(response)
+        chat.backend.submit_response(response)
         return JSONResponse({"status": "ok"})
 
     async def _upload(self, request: Request) -> JSONResponse:
@@ -1370,7 +1410,8 @@ class HTTPServer:
         target_session_id = target_session.id
 
         backend_key = (agent_name, user_id, target_session_id)
-        existing_task = self._active_chat_tasks.get(backend_key)
+        existing_chat = self._active_chats.get(backend_key)
+        existing_task = existing_chat.task if existing_chat else None
         if existing_task is not None and not existing_task.done():
             return JSONResponse(
                 {"error": "a turn is already running for this session"},
@@ -1389,21 +1430,13 @@ class HTTPServer:
         progress.set_loop(asyncio.get_running_loop())
         progress.set_session_id(target_session_id)
         progress.set_broadcaster(self.event_bus)
-        progress.set_event_persister(
-            lambda payload: adapter.session_store.append_event(
-                target_session_id,
-                {
-                    **payload,
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
-                },
-            )
-        )
+        progress.set_event_persister(build_session_event_persister(adapter.session_store, target_session_id))
         custom_logger = SimpleNamespace(ui_handler=progress)
 
         interaction_backend = HTTPInteractionBackend(progress)
         interaction_backend.pending_message = message
-        self._active_backends[backend_key] = interaction_backend
-        self._active_progress[backend_key] = progress
+        chat_state = ActiveChat(backend=interaction_backend, progress=progress)
+        self._active_chats[backend_key] = chat_state
 
         async def run_agent():
             from tsugite.interaction import set_interaction_backend
@@ -1424,7 +1457,7 @@ class HTTPServer:
                     progress._emit("final_result", {"result": response})
 
                 self.event_bus.emit("agent_status", {"agent": agent_name})
-                self.event_bus.emit("history_update", {"agent": agent_name})
+                self.event_bus.emit("history_update", {"agent": agent_name, "session_id": target_session_id})
 
                 try:
                     refreshed = adapter.session_store.get_session(target_session_id)
@@ -1450,13 +1483,11 @@ class HTTPServer:
                 logger.exception("[%s] Chat error", adapter.agent_name)
                 progress._emit("error", {"error": str(e)})
             finally:
-                self._active_backends.pop(backend_key, None)
-                self._active_chat_tasks.pop(backend_key, None)
-                self._active_progress.pop(backend_key, None)
+                self._active_chats.pop(backend_key, None)
                 progress.signal_done()
 
         task = asyncio.create_task(run_agent())
-        self._active_chat_tasks[backend_key] = task
+        chat_state.task = task
 
         return StreamingResponse(
             progress.event_generator(),
@@ -1483,9 +1514,9 @@ class HTTPServer:
         if not session_id:
             return JSONResponse({"error": "session_id is required"}, status_code=400)
         backend_key = (request.path_params["agent"], user_id, session_id)
-        task = self._active_chat_tasks.get(backend_key)
-        if task and not task.done():
-            task.cancel()
+        chat = self._active_chats.get(backend_key)
+        if chat and chat.task and not chat.task.done():
+            chat.task.cancel()
             return JSONResponse({"status": "cancelled"})
         return JSONResponse({"error": "no active chat"}, status_code=404)
 

{tsugite_cli-0.14.1 → tsugite_cli-0.14.2}/tsugite/daemon/commands.py

@@ -110,19 +110,19 @@ async def cmd_compact(adapter: BaseAdapter, user_id: str, message: str | None =
     if session is None or session.message_count == 0:
         return "No conversation to compact."
 
-    if not adapter.session_store.begin_compaction(user_id, adapter.agent_name):
+    old_id = session.id
+    if not adapter.session_store.begin_compaction(user_id, adapter.agent_name, session_id=old_id):
         return "Compaction already in progress."
 
-    old_id = session.id
-    adapter._broadcast_compaction("compaction_started", adapter.agent_name)
+    adapter._broadcast_compaction("compaction_started", adapter.agent_name, old_id)
     new_session = None
     try:
         new_session = await adapter._compact_session(session.id, instructions=message, reason="manual")
     except Exception as e:
         return f"Compaction failed: {e}"
     finally:
-        adapter.session_store.end_compaction(user_id, adapter.agent_name)
-        adapter._broadcast_compaction("compaction_finished", adapter.agent_name)
+        adapter.session_store.end_compaction(user_id, adapter.agent_name, session_id=old_id)
+        adapter._broadcast_compaction("compaction_finished", adapter.agent_name, old_id)
 
     if new_session is None:
         return f"Nothing to compact (id: {old_id[:12]})"

{tsugite_cli-0.14.1 → tsugite_cli-0.14.2}/tsugite/daemon/compaction_scheduler.py

@@ -112,7 +112,8 @@ class CompactionScheduler:
                 continue
 
             user_id = session.user_id or ""
-            if not self._session_store.begin_compaction(user_id, agent_name):
+            sid = session.id
+            if not self._session_store.begin_compaction(user_id, agent_name, session_id=sid):
                 logger.debug("[%s] Compaction already in progress, skipping", agent_name)
                 continue
 
@@ -123,17 +124,17 @@ class CompactionScheduler:
             )
 
             try:
-                new_session = await adapter._compact_session(session.id, reason="scheduled")
+                new_session = await adapter._compact_session(sid, reason="scheduled")
                 if new_session is None:
                     logger.info("[%s] Scheduled compaction skipped (nothing to compact)", agent_name)
                 else:
                     logger.info(
                         "[%s] Scheduled compaction completed (old=%s new=%s)",
                         agent_name,
-                        session.id,
+                        sid,
                         new_session.id,
                     )
             except Exception:
                 logger.exception("[%s] Scheduled compaction failed", agent_name)
             finally:
-                self._session_store.end_compaction(user_id, agent_name)
+                self._session_store.end_compaction(user_id, agent_name, session_id=sid)