tsugite-cli 0.8.2__tar.gz → 0.9.1__tar.gz

{tsugite_cli-0.8.2 → tsugite_cli-0.9.1}/PKG-INFO

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

{tsugite_cli-0.8.2 → tsugite_cli-0.9.1}/pyproject.toml

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

{tsugite_cli-0.8.2 → tsugite_cli-0.9.1}/tsugite/agent_runner/history_integration.py

@@ -241,16 +241,27 @@ def get_claude_code_session_info(conversation_id: str) -> Optional["ClaudeCodeSe
         storage = SessionStorage(session_path)
         records = storage.load_records()
 
-        # Single reversed pass: find the last Turn with a session ID,
-        # but bail if we hit a CompactionSummary (stale Claude Code session)
-        for record in reversed(records):
+        # Find the last CompactionSummary index (if any).
+        # Session IDs from retained turns (carried over from pre-compaction)
+        # are stale, but session IDs from turns AFTER the compaction are valid.
+        compaction_idx = -1
+        for i, record in enumerate(records):
             if isinstance(record, CompactionSummary):
-                return None
+                compaction_idx = i
+
+        for record in reversed(records):
             if isinstance(record, Turn) and record.metadata:
                 session_id = record.metadata.get("claude_code_session_id")
-                if session_id:
-                    compacted = record.metadata.get("claude_code_compacted", False)
-                    return ClaudeCodeSessionInfo(session_id, compacted)
+                if not session_id:
+                    continue
+                # If this turn is a retained turn from before compaction
+                # (carried over with stale session ID), skip it
+                if compaction_idx >= 0:
+                    turn_idx = records.index(record)
+                    if turn_idx <= compaction_idx:
+                        continue
+                compacted = record.metadata.get("claude_code_compacted", False)
+                return ClaudeCodeSessionInfo(session_id, compacted)
         return None
     except Exception:
         return None

{tsugite_cli-0.8.2 → tsugite_cli-0.9.1}/tsugite/agent_runner/runner.py

@@ -1,7 +1,10 @@
 """Agent execution engine using TsugiteAgent."""
 
 import asyncio
+import logging
 import time
+
+logger = logging.getLogger(__name__)
 from pathlib import Path
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
@@ -779,6 +782,9 @@ async def run_agent_async(
         if session_info:
             claude_code_resume_session = session_info.session_id
             claude_code_resume_after_compaction = session_info.compacted
+            logger.info("Resuming Claude Code session %s (compacted=%s)", claude_code_resume_session, claude_code_resume_after_compaction)
+        else:
+            logger.debug("No Claude Code session to resume for %s", continue_conversation_id)
 
         if not claude_code_resume_session:
             # No Claude Code session to resume -- load history for serialization
@@ -838,7 +844,7 @@ async def run_agent_async(
             )
         except (RuntimeError, AgentExecutionError) as e:
             err_str = str(e).lower()
-            if claude_code_resume_session and ("process ended" in err_str or "no conversation found" in err_str):
+            if claude_code_resume_session and ("process ended" in err_str or "no conversation found" in err_str or "prompt too long" in err_str):
                 logger.warning("Claude Code resume failed (%s), retrying with full history", e)
                 try:
                     previous_messages = load_and_apply_history(continue_conversation_id)

{tsugite_cli-0.8.2 → tsugite_cli-0.9.1}/tsugite/core/agent.py

@@ -210,6 +210,7 @@ class TsugiteAgent:
         self._claude_code_model = self.litellm_params.get("model") if self._is_claude_code else None
         self._claude_code_session_id: Optional[str] = None
         self._claude_code_last_turn_tokens: int = 0
+        self._claude_code_context_tokens: int = 0
         self._claude_code_context_window: Optional[int] = None
         self._claude_code_cache_creation_tokens: int = 0
         self._claude_code_cache_read_tokens: int = 0
@@ -627,9 +628,10 @@ class TsugiteAgent:
                         self._claude_code_session_id = claude_process.session_id
 
                     if return_full_result:
+                        context_tokens = self._claude_code_context_tokens or total_tokens
                         return AgentResult(
                             output=exec_result.final_answer,
-                            token_usage=total_tokens,
+                            token_usage=context_tokens,
                             cost=self.total_cost if self.total_cost > 0 else None,
                             steps=self.memory.steps,
                             claude_code_session_id=self._claude_code_session_id,
@@ -747,6 +749,7 @@ class TsugiteAgent:
                 output_tokens = event.get("output_tokens") or 0
                 turn_total = input_tokens + cache_creation + cache_read + output_tokens
                 self._claude_code_last_turn_tokens = turn_total
+                self._claude_code_context_tokens = input_tokens + cache_creation + cache_read
                 self._claude_code_cache_creation_tokens += cache_creation
                 self._claude_code_cache_read_tokens += cache_read
                 self.total_tokens += turn_total
@@ -756,6 +759,9 @@ class TsugiteAgent:
         if stream and self.event_bus:
             self.event_bus.emit(StreamCompleteEvent())
 
+        if accumulated.strip().lower() == "prompt is too long":
+            raise RuntimeError(f"Claude Code prompt too long (session={self._claude_code_session_id})")
+
         parsed = self._parse_response_from_text(accumulated)
 
         # If no code block was found, preserve the raw text as thought so the

{tsugite_cli-0.8.2 → tsugite_cli-0.9.1}/tsugite/core/claude_code.py

@@ -132,7 +132,8 @@ class ClaudeCodeProcess:
 
         # Start draining stderr in background to prevent pipe buffer deadlock
         self._stderr_task = asyncio.create_task(self._drain_stderr())
-        logger.info("Claude Code subprocess started (pid=%d, model=%s)", self._process.pid, model)
+        mode = f"resume={resume_session}" if resume_session else "new session"
+        logger.info("Claude Code subprocess started (pid=%d, model=%s, %s)", self._process.pid, model, mode)
 
     async def send_message(self, content: str) -> AsyncIterator[dict]:
         """Write user message to stdin and yield streaming events from stdout.

{tsugite_cli-0.8.2 → tsugite_cli-0.9.1}/tsugite/daemon/adapters/base.py

@@ -430,6 +430,8 @@ class BaseAdapter(ABC):
                 # Get the new session ID after compaction
                 session = self.session_store.get_or_create_interactive(user_id, self.agent_name)
                 conv_id = session.id
+                if self.event_bus:
+                    self.event_bus.emit("session_update", {"action": "compacted", "id": conv_id})
 
         metadata = channel_context.to_dict()
         metadata["daemon_agent"] = self.agent_name
@@ -520,12 +522,29 @@ class BaseAdapter(ABC):
             self.session_store.update_context_limit(self.agent_name, result.context_window)
             self.agent_config.context_limit = result.context_window
 
-        if result.token_count:
-            self.session_store.update_token_count(conv_id, result.token_count)
+        self.session_store.update_token_count(conv_id, result.token_count or 0)
+
+        try:
+            session = self.session_store.get_session(conv_id)
+            if session and session.message_count <= 1 and not session.title:
+                asyncio.ensure_future(self._auto_title_session(conv_id, message, str(result)))
+        except Exception as e:
+            logger.debug("Auto-title check failed for session '%s': %s", conv_id, e)
 
         return str(result)
 
-    async def _compact_session(self, session_id: str) -> None:
+    async def _auto_title_session(self, session_id: str, user_message: str, assistant_response: str) -> None:
+        try:
+            from tsugite.daemon.memory import auto_title_session
+
+            await auto_title_session(
+                session_id, user_message, assistant_response,
+                self.resolve_model(), self.session_store, self.event_bus,
+            )
+        except Exception as e:
+            logger.debug("Auto-title failed for session '%s': %s", session_id, e)
+
+    async def _compact_session(self, session_id: str, instructions: str | None = None) -> None:
         """Compact session when approaching context limit.
 
         Uses a sliding window: recent turns are kept verbatim while older
@@ -613,6 +632,9 @@ class BaseAdapter(ABC):
 
             old_messages.extend(msg for turn in old_turns for msg in turn.messages)
 
+            if instructions:
+                old_messages.append({"role": "user", "content": f"<compaction_instructions>{instructions}</compaction_instructions>"})
+
             try:
                 summary = await summarize_session(
                     old_messages, model=model, max_context_tokens=self.agent_config.context_limit

{tsugite_cli-0.8.2 → tsugite_cli-0.9.1}/tsugite/daemon/adapters/discord.py

@@ -1,6 +1,7 @@
 """Discord bot adapter."""
 
 import asyncio
+import inspect
 import logging
 import re
 from types import SimpleNamespace
@@ -422,10 +423,25 @@ class DiscordAdapter(BaseAdapter):
         intents.message_content = True
 
         self.bot = commands.Bot(command_prefix=bot_config.command_prefix, intents=intents)
+        self._register_commands()
 
         @self.bot.event
         async def on_ready():
-            logger.info("Discord bot '%s' logged in as %s (agent: %s)", bot_config.name, self.bot.user, agent_name)
+            try:
+                if bot_config.guild_id:
+                    guild = discord.Object(id=int(bot_config.guild_id))
+                    self.bot.tree.copy_global_to(guild=guild)
+                    await self.bot.tree.sync(guild=guild)
+                else:
+                    await self.bot.tree.sync()
+                synced = len(self.bot.tree.get_commands())
+                logger.info(
+                    "Discord bot '%s' logged in as %s (agent: %s, %d app commands synced)",
+                    bot_config.name, self.bot.user, agent_name, synced,
+                )
+            except Exception as e:
+                logger.error("Failed to sync app commands for '%s': %s", bot_config.name, e)
+                logger.info("Discord bot '%s' logged in as %s (agent: %s)", bot_config.name, self.bot.user, agent_name)
 
         @self.bot.event
         async def on_error(event_method, *args, **kwargs):
@@ -473,6 +489,50 @@ class DiscordAdapter(BaseAdapter):
             task = asyncio.create_task(self._process_message(message, user_msg, bot_config.name))
             task.add_done_callback(lambda t: _handle_async_exception(t, bot_config.name))
 
+    def _register_commands(self):
+        """Auto-register adapter commands from the shared registry as Discord app commands."""
+        from tsugite.daemon.commands import get_commands
+
+        for cmd in get_commands().values():
+            self._add_app_command(cmd)
+
+    def _add_app_command(self, cmd: "AdapterCommand"):
+        """Convert an AdapterCommand to a discord app_commands.Command and add to the bot tree."""
+        adapter = self
+
+        # user_id is auto-injected from the interaction, so hide it from the Discord UI
+        visible_params = [p for p in cmd.params if p.name != "user_id"]
+        auto_inject_user_id = len(visible_params) < len(cmd.params)
+
+        sig_params = [
+            inspect.Parameter("interaction", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=discord.Interaction)
+        ]
+        for p in visible_params:
+            ann = Optional[p.type] if not p.required else p.type
+            default = inspect.Parameter.empty if p.required else None
+            sig_params.append(inspect.Parameter(p.name, inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=ann, default=default))
+
+        async def callback(interaction: discord.Interaction, **kwargs):
+            await interaction.response.defer()
+            if auto_inject_user_id:
+                kwargs.setdefault("user_id", str(interaction.user.id))
+            try:
+                result = await cmd.handler(adapter, **kwargs)
+            except Exception as e:
+                logger.error("App command '%s' failed: %s", cmd.name, e)
+                result = f"Command failed: {e}"
+            await interaction.followup.send(str(result)[:2000])
+
+        callback.__signature__ = inspect.Signature(sig_params)
+        callback.__annotations__ = {p.name: p.annotation for p in sig_params}
+
+        descriptions = {p.name: p.description for p in visible_params}
+        if descriptions:
+            callback = discord.app_commands.describe(**descriptions)(callback)
+
+        app_cmd = discord.app_commands.Command(name=cmd.name, description=cmd.description, callback=callback)
+        self.bot.tree.add_command(app_cmd)
+
     async def _process_message(self, message, user_msg: str, bot_name: str):
         """Process a message in an isolated task."""
         is_thread = isinstance(message.channel, discord.Thread)

{tsugite_cli-0.8.2 → tsugite_cli-0.9.1}/tsugite/daemon/adapters/http.py

@@ -365,6 +365,7 @@ class HTTPServer:
             Route("/api/sessions", self._api_list_sessions, methods=["GET"]),
             Route("/api/sessions", self._api_start_session, methods=["POST"]),
             Route("/api/sessions/{session_id}", self._api_get_session, methods=["GET"]),
+            Route("/api/sessions/{session_id}", self._api_update_session, methods=["PATCH"]),
             Route("/api/sessions/{session_id}/cancel", self._api_cancel_session, methods=["POST"]),
             Route("/api/sessions/{session_id}/restart", self._api_restart_session, methods=["POST"]),
             Route("/api/sessions/{session_id}/events", self._api_session_events, methods=["GET"]),
@@ -389,6 +390,8 @@ class HTTPServer:
             Route("/api/kv/namespaces", self._kv_namespaces, methods=["GET"]),
             Route("/api/kv/{namespace}/keys", self._kv_keys, methods=["GET"]),
             Route("/api/kv/{namespace}/keys/{key:path}", self._kv_get, methods=["GET"]),
+            Route("/api/commands", self._list_commands, methods=["GET"]),
+            Route("/api/agents/{agent}/commands/{command_name}", self._run_command, methods=["POST"]),
             Mount("/static", app=StaticFiles(directory=str(WEB_DIR)), name="static"),
             Route("/", self._serve_ui, methods=["GET"]),
         ]
@@ -397,6 +400,53 @@ class HTTPServer:
     async def _health(self, request: Request) -> JSONResponse:
         return JSONResponse({"status": "ok", "agents": list(self.adapters.keys())})
 
+    async def _list_commands(self, request: Request) -> JSONResponse:
+        if err := self._check_auth(request):
+            return err
+        from tsugite.daemon.commands import get_commands
+
+        return JSONResponse({"commands": [
+            {
+                "name": cmd.name,
+                "description": cmd.description,
+                "params": [
+                    {"name": p.name, "type": p.type.__name__, "description": p.description, "required": p.required, **({"choices": p.choices} if p.choices else {})}
+                    for p in cmd.params
+                ],
+            }
+            for cmd in get_commands().values()
+        ]})
+
+    async def _run_command(self, request: Request) -> JSONResponse:
+        adapter, err = self._get_adapter(request)
+        if err:
+            return err
+        from tsugite.daemon.commands import get_commands
+
+        command_name = request.path_params["command_name"]
+        commands = get_commands()
+        if command_name not in commands:
+            return JSONResponse({"error": f"Unknown command: {command_name}"}, status_code=404)
+
+        cmd = commands[command_name]
+        try:
+            body = await request.json()
+        except Exception:
+            body = {}
+
+        allowed_keys = {p.name for p in cmd.params}
+        filtered = {k: v for k, v in body.items() if k in allowed_keys}
+
+        missing = [p.name for p in cmd.params if p.required and p.name not in filtered]
+        if missing:
+            return JSONResponse({"error": f"Missing required params: {', '.join(missing)}"}, status_code=400)
+
+        try:
+            result = await cmd.handler(adapter, **filtered)
+        except Exception as e:
+            return JSONResponse({"error": str(e)}, status_code=500)
+        return JSONResponse({"result": result})
+
     async def _list_agents(self, request: Request) -> JSONResponse:
         if err := self._check_auth(request):
             return err
@@ -452,6 +502,7 @@ class HTTPServer:
                     "model": s.model,
                     "error": s.error,
                     "result": s.result,
+                    "title": s.title,
                 }
             )
 
@@ -725,6 +776,8 @@ class HTTPServer:
 
         new_session = adapter.session_store.get_or_create_interactive(user_id, adapter.agent_name)
         self.event_bus.emit("agent_status", {"agent": agent_name})
+        if new_session:
+            self.event_bus.emit("session_update", {"action": "compacted", "id": new_session.id})
         return JSONResponse(
             {
                 "status": "compacted",
@@ -1143,6 +1196,7 @@ class HTTPServer:
                         "created_at": s.created_at,
                         "updated_at": s.last_active,
                         "error": s.error,
+                        "title": s.title,
                     }
                     for s in sessions
                 ]
@@ -1196,6 +1250,23 @@ class HTTPServer:
         except ValueError as e:
             return JSONResponse({"error": str(e)}, status_code=404)
 
+    async def _api_update_session(self, request: Request) -> JSONResponse:
+        if err := self._require_auth_and_sessions(request):
+            return err
+        session_id = request.path_params["session_id"]
+        try:
+            body = await request.json()
+        except Exception:
+            return JSONResponse({"error": "Invalid JSON"}, status_code=400)
+        title = body.get("title")
+        if title is None:
+            return JSONResponse({"error": "No updatable fields provided"}, status_code=400)
+        try:
+            self.session_runner.store.update_session(session_id, title=title)
+            return JSONResponse({"ok": True, "title": title})
+        except ValueError as e:
+            return JSONResponse({"error": str(e)}, status_code=404)
+
     async def _api_cancel_session(self, request: Request) -> JSONResponse:
         if err := self._require_auth_and_sessions(request):
             return err

{tsugite_cli-0.8.2 → tsugite_cli-0.9.1}/tsugite/daemon/adapters/scheduler_adapter.py

@@ -74,6 +74,7 @@ class SchedulerAdapter:
                 status=SessionStatus.RUNNING.value,
                 parent_id=entry.id,
                 prompt=entry.prompt or entry.command or "",
+                title=entry.id,
             )
             try:
                 adapter.session_store.create_session(sched_session)

tsugite_cli-0.9.1/tsugite/daemon/commands.py

@@ -0,0 +1,168 @@
+"""Adapter command registry — define commands once, auto-register across all adapters."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Callable
+
+if TYPE_CHECKING:
+    from tsugite.daemon.adapters.base import BaseAdapter
+
+logger = logging.getLogger(__name__)
+
+_COMMANDS: dict[str, AdapterCommand] = {}
+
+
+@dataclass
+class CommandParam:
+    name: str
+    type: type
+    description: str
+    required: bool = True
+    choices: list[str] | None = None
+
+
+@dataclass
+class AdapterCommand:
+    name: str
+    description: str
+    handler: Callable
+    params: list[CommandParam] = field(default_factory=list)
+
+
+def adapter_command(
+    name: str,
+    description: str,
+    params: list[CommandParam] | None = None,
+):
+    """Decorator to register an adapter command."""
+
+    def decorator(fn: Callable) -> Callable:
+        if name in _COMMANDS:
+            logger.warning("Overwriting existing adapter command '%s'", name)
+        _COMMANDS[name] = AdapterCommand(
+            name=name,
+            description=description,
+            handler=fn,
+            params=params or [],
+        )
+        return fn
+
+    return decorator
+
+
+def get_commands() -> dict[str, AdapterCommand]:
+    return _COMMANDS
+
+
+# ---------------------------------------------------------------------------
+# Built-in commands
+# ---------------------------------------------------------------------------
+
+
+@adapter_command(
+    name="bg",
+    description="Run a task in the background",
+    params=[
+        CommandParam("prompt", str, "The task to run"),
+        CommandParam("agent", str, "Target agent", required=False),
+    ],
+)
+async def cmd_bg(adapter: BaseAdapter, prompt: str, agent: str | None = None) -> str:
+    """Start a background session with the given prompt."""
+    from tsugite.daemon.session_store import Session, SessionSource
+    from tsugite.tools.sessions import _session_runner
+
+    if not _session_runner:
+        return "Background sessions require the daemon session runner to be enabled."
+
+    target_agent = agent or adapter.agent_name
+
+    session = Session(
+        id="",
+        agent=target_agent,
+        source=SessionSource.BACKGROUND.value,
+        prompt=prompt,
+    )
+
+    try:
+        result = _session_runner.start_session(session)
+    except Exception as e:
+        return f"Failed to start background session: {e}"
+
+    return f"Background session started (ID: {result.id})"
+
+
+@adapter_command(
+    name="compact",
+    description="Compact the current conversation to free context space",
+    params=[
+        CommandParam("user_id", str, "User whose session to compact"),
+        CommandParam("message", str, "Extra instructions for compaction (e.g. remember/forget specific things)", required=False),
+    ],
+)
+async def cmd_compact(adapter: BaseAdapter, user_id: str, message: str | None = None) -> str:
+    """Compact the interactive session for the given user."""
+    session = adapter.session_store.get_or_create_interactive(user_id, adapter.agent_name)
+
+    if session.message_count == 0:
+        return "No conversation to compact."
+
+    if not adapter.session_store.begin_compaction(user_id, adapter.agent_name):
+        return "Compaction already in progress."
+
+    old_id = session.id
+    adapter._broadcast_compaction(adapter.agent_name, started=True)
+    try:
+        await adapter._compact_session(session.id, instructions=message)
+    except Exception as e:
+        return f"Compaction failed: {e}"
+    finally:
+        adapter.session_store.end_compaction(user_id, adapter.agent_name)
+        adapter._broadcast_compaction(adapter.agent_name, started=False)
+
+    new_session = adapter.session_store.get_or_create_interactive(user_id, adapter.agent_name)
+    return f"Session compacted (old: {old_id[:12]}, new: {new_session.id[:12]})"
+
+
+@adapter_command(
+    name="status",
+    description="Show agent status and context usage",
+    params=[CommandParam("user_id", str, "User to check status for")],
+)
+async def cmd_status(adapter: BaseAdapter, user_id: str) -> str:
+    """Show current agent status, token usage, and context window info."""
+    session = adapter.session_store.get_or_create_interactive(user_id, adapter.agent_name)
+    context_limit = adapter.session_store.get_context_limit(adapter.agent_name)
+    tokens = session.cumulative_tokens
+    pct = int(tokens / context_limit * 100) if context_limit else 0
+    compacting = adapter.session_store.is_compacting(user_id, adapter.agent_name)
+
+    lines = [
+        f"Model: {adapter.resolve_model()}",
+        f"Context: {tokens:,} / {context_limit:,} tokens ({pct}%)",
+        f"Messages: {session.message_count}",
+    ]
+    if compacting:
+        lines.append("Compaction: in progress")
+    return "\n".join(lines)
+
+
+@adapter_command(
+    name="sessions",
+    description="List active and recent background sessions",
+    params=[CommandParam("status", str, "Filter by status (running, completed, failed)", required=False)],
+)
+async def cmd_sessions(adapter: BaseAdapter, status: str | None = None) -> str:
+    """List background sessions for the current agent."""
+    sessions = adapter.session_store.list_sessions(agent=adapter.agent_name, status=status)
+    if not sessions:
+        return "No sessions found."
+    lines = []
+    for s in sessions[:10]:
+        label = s.title or (s.prompt or "")[:60]
+        lines.append(f"[{s.status}] {s.id[:12]} — {label}")
+    if len(sessions) > 10:
+        lines.append(f"... and {len(sessions) - 10} more")
+    return "\n".join(lines)

{tsugite_cli-0.8.2 → tsugite_cli-0.9.1}/tsugite/daemon/config.py

@@ -42,6 +42,7 @@ class DiscordBotConfig(BaseModel):
     token: str
     agent: str  # References agents key
     command_prefix: str = "!"
+    guild_id: Optional[str] = None  # Sync app commands to this guild only (instant; good for dev)
     dm_policy: Literal["allowlist", "open"] = "allowlist"
     allow_from: List[str] = Field(default_factory=list)
 

{tsugite_cli-0.8.2 → tsugite_cli-0.9.1}/tsugite/daemon/memory.py

@@ -266,6 +266,56 @@ async def summarize_session(
     return await _combine_summaries(chunk_summaries, model)
 
 
+TITLE_SYSTEM_PROMPT = (
+    "Generate a short title (3-6 words) for this conversation. "
+    "Return only the title, nothing else. No quotes, no punctuation at the end."
+)
+
+TITLE_TIMEOUT = 30
+SHORT_TITLE_THRESHOLD = 60
+
+
+async def generate_session_title(messages: list[dict], model: str) -> str:
+    """Generate a short title from conversation messages using a cheap model."""
+    text_parts = []
+    for msg in messages:
+        content = _message_text(msg)
+        if content:
+            text_parts.append(f"{msg.get('role', 'user').upper()}: {content[:500]}")
+    if not text_parts:
+        return ""
+    convo_text = "\n\n".join(text_parts)
+    title = await asyncio.wait_for(
+        _llm_complete(TITLE_SYSTEM_PROMPT, convo_text, model),
+        timeout=TITLE_TIMEOUT,
+    )
+    return title.strip().strip('"\'')[:80]
+
+
+async def auto_title_session(
+    session_id: str,
+    user_content: str,
+    assistant_content: str,
+    agent_model: str,
+    store,
+    event_bus=None,
+) -> None:
+    """Generate and store a title for a session. Skips LLM call for short prompts."""
+    if len(user_content) <= SHORT_TITLE_THRESHOLD:
+        store.update_session(session_id, title=user_content)
+    else:
+        model = infer_compaction_model(agent_model)
+        messages = [
+            {"role": "user", "content": user_content},
+            {"role": "assistant", "content": assistant_content},
+        ]
+        title = await generate_session_title(messages, model)
+        if title:
+            store.update_session(session_id, title=title)
+    if event_bus:
+        event_bus.emit("session_update", {"action": "titled", "id": session_id})
+
+
 def extract_file_paths_from_turns(turns: "list[Turn]") -> list[str]:
     """Extract file paths mentioned in tool calls across turns.