kolega-code 0.34.0__tar.gz → 0.35.0__tar.gz

{kolega_code-0.34.0 → kolega_code-0.35.0}/CHANGELOG.md

@@ -6,6 +6,34 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.35.0 - 2026-09-03
+
+### Added
+
+- Added Google Gemini 3.8 Flash (`gemini-3.8-flash`): 1M-token context, 64K
+  output, vision and function calling, and `low`/`medium`/`high` thinking
+  levels. It omits Google's deprecated temperature parameter and is now the
+  default Google model.
+- **Descriptive session titles.** Sessions now get a natural-language title
+  and a short description generated in the background by the active LLM after
+  substantive turns, while the stable session name keeps its role as the
+  peer-addressing handle. `/retitle` regenerates them on demand, a dedicated
+  Session card in the sidebar shows them, and the header, status dashboard,
+  startup banner, and `sessions` CLI output all display the title.
+- **`kolega-code gateway restart` and auto-restart on update.** The new
+  subcommand restarts an installed gateway service in place (systemd user
+  unit on Linux, launchd agent on macOS). `kolega-code update`, the `/update`
+  TUI command, and the shell installer now restart the gateway automatically
+  when the service is installed, so an update picks up the new build without
+  a manual daemon restart.
+
+### Changed
+
+- OpenRouter catalog refreshed from the live endpoint (2026-09-03 snapshot):
+  277 tool-capable models (20 featured), adding `google/gemini-3.8-flash` and
+  the `meta/muse-spark-1.3` pair, with featured order re-ranked by the latest
+  weekly token volume.
+
 ## 0.34.0 - 2026-09-02
 
 ### Added

{kolega_code-0.34.0 → kolega_code-0.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.34.0
+Version: 0.35.0
 Summary: Multi-agent coding in the terminal
 Project-URL: Homepage, https://kolega-ai.github.io/kolega-code/
 Project-URL: Documentation, https://kolega-ai.github.io/kolega-code/

{kolega_code-0.34.0 → kolega_code-0.35.0}/kolega_code/__init__.py

@@ -174,4 +174,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.34.0"
+__version__ = "0.35.0"

{kolega_code-0.34.0 → kolega_code-0.35.0}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.34.0"
+__version__ = "0.35.0"

kolega_code-0.35.0/kolega_code/agent/session_metadata.py

@@ -0,0 +1,165 @@
+"""Generate descriptive session title and description via the active LLM."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import re
+from dataclasses import dataclass
+from typing import Any, List, Optional, Sequence
+
+from kolega_code.gateway.redaction import scrub
+from kolega_code.llm.ledger import helper_origin, llm_call_origin
+from kolega_code.llm.models import Message, MessageHistory, TextBlock
+
+from .compression import render_transcript
+from .conversation import replace_image_blocks_with_placeholders
+
+logger = logging.getLogger(__name__)
+
+SESSION_METADATA_MIN_MESSAGES = 2
+SESSION_METADATA_MAX_TOKENS = 256
+SESSION_METADATA_HEAD_CHARS = 2000
+SESSION_METADATA_TAIL_CHARS = 6000
+
+TITLE_MAX_CHARS = 60
+DESCRIPTION_MAX_CHARS = 200
+
+SESSION_METADATA_SYSTEM_PROMPT = """\
+You are an assistant that summarizes developer coding sessions.
+Analyze the provided conversation transcript and generate:
+1. title: A concise, descriptive title in Natural Title Case (e.g. "Fix Authentication Middleware", "Add PostgreSQL Connection Pool", "Investigate Bug 662"). Maximum 60 characters. No surrounding quotes or Markdown formatting.
+2. description: A clear 1 to 2 sentence summary of what the session is working on, goals, and key progress or findings so far. Maximum 200 characters.
+
+Respond ONLY with valid JSON in this exact structure:
+{
+  "title": "Natural Title Case Title",
+  "description": "One or two sentences describing the session."
+}
+"""
+
+
+@dataclass(frozen=True)
+class SessionMetadata:
+    """The generated descriptive metadata for a session."""
+
+    title: str
+    description: str
+
+
+class SessionMetadataCancelledError(Exception):
+    """Raised when metadata generation is cancelled."""
+
+
+def _truncate_transcript(transcript: str) -> str:
+    """Bound the transcript sent to the metadata generator."""
+    total_budget = SESSION_METADATA_HEAD_CHARS + SESSION_METADATA_TAIL_CHARS
+    if len(transcript) <= total_budget:
+        return transcript
+    head = transcript[:SESSION_METADATA_HEAD_CHARS]
+    tail = transcript[-SESSION_METADATA_TAIL_CHARS:]
+    return f"{head}\n\n[... middle conversation omitted ...]\n\n{tail}"
+
+
+def parse_session_metadata_json(raw_text: str) -> Optional[SessionMetadata]:
+    """Parse and sanitize the JSON returned by the model."""
+    text = raw_text.strip()
+    if not text:
+        return None
+
+    # Strip code fences if present
+    fence_match = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", text)
+    if fence_match:
+        text = fence_match.group(1).strip()
+
+    data: Optional[dict[str, Any]] = None
+    try:
+        parsed = json.loads(text)
+        if isinstance(parsed, dict):
+            data = parsed
+    except Exception:
+        # Fallback regex extraction for title and description
+        title_match = re.search(r'"title"\s*:\s*"([^"]+)"', text)
+        desc_match = re.search(r'"description"\s*:\s*"([^"]+)"', text)
+        if title_match:
+            data = {
+                "title": title_match.group(1),
+                "description": desc_match.group(1) if desc_match else "",
+            }
+
+    if not data or not isinstance(data.get("title"), str):
+        return None
+
+    raw_title = data["title"].strip().strip("\"'")
+    # Clean control characters and normalize spaces
+    cleaned_title = " ".join(raw_title.split())
+    if not cleaned_title:
+        return None
+
+    if len(cleaned_title) > TITLE_MAX_CHARS:
+        cleaned_title = cleaned_title[:TITLE_MAX_CHARS].rstrip()
+
+    raw_description = str(data.get("description") or "").strip()
+    cleaned_description = " ".join(raw_description.split())
+    if len(cleaned_description) > DESCRIPTION_MAX_CHARS:
+        cleaned_description = cleaned_description[:DESCRIPTION_MAX_CHARS].rstrip()
+
+    return SessionMetadata(title=cleaned_title, description=cleaned_description)
+
+
+async def generate_session_metadata(
+    messages: List[Message],
+    *,
+    llm: Any,
+    model: str,
+    temperature: float = 0.2,
+    cancel_event: Optional[asyncio.Event] = None,
+    secret_values: Sequence[str] = (),
+) -> Optional[SessionMetadata]:
+    """Summarize ``messages`` into a title and description via the active LLM.
+
+    Returns ``None`` if generation fails or is cancelled. Never raises.
+    """
+    if len(messages) < SESSION_METADATA_MIN_MESSAGES:
+        return None
+
+    if cancel_event is None:
+        cancel_event = asyncio.Event()
+
+    try:
+        stripped = replace_image_blocks_with_placeholders(list(messages), model)
+        transcript = render_transcript(stripped)
+        bounded_transcript = _truncate_transcript(transcript)
+        scrubbed_transcript = scrub(bounded_transcript, secret_values)
+
+        user_content = f"Conversation transcript:\n\n{scrubbed_transcript}"
+        request_messages = MessageHistory([Message(role="user", content=[TextBlock(text=user_content)])])
+        system_message = Message(role="system", content=[TextBlock(text=SESSION_METADATA_SYSTEM_PROMPT)])
+
+        if cancel_event.is_set():
+            return None
+
+        with llm_call_origin(helper_origin("session_metadata")):
+            stream_cm = await llm.stream(
+                messages=request_messages,
+                system=system_message,
+                temperature=temperature,
+                model=model,
+                max_completion_tokens=SESSION_METADATA_MAX_TOKENS,
+                thinking=None,
+            )
+            async with stream_cm as stream:
+                async for _event in stream:
+                    if cancel_event.is_set():
+                        return None
+
+            if cancel_event.is_set():
+                return None
+
+            response = await stream.get_final_message()
+            raw_output = response.get_text_content()
+            return parse_session_metadata_json(raw_output)
+    except Exception as exc:
+        logger.warning("Failed to generate session metadata: %s", exc)
+        return None

{kolega_code-0.34.0 → kolega_code-0.35.0}/kolega_code/cli/app.py

@@ -436,6 +436,9 @@ class KolegaCodeApp(
                 with TabbedContent(id="events"):
                     with TabPane("Status", id="status_pane"):
                         with VerticalScroll(id="status_form"):
+                            with Vertical(classes="status-section", id="status_session_section") as session_section:
+                                session_section.border_title = "Session"
+                                yield Static("", id="status_session", markup=True)
                             with Vertical(classes="status-section", id="status_summary_section") as status_section:
                                 status_section.border_title = "Status"
                                 yield Static("", id="status_dashboard", markup=True)
@@ -527,7 +530,7 @@ class KolegaCodeApp(
         self.inbox_registry.register(
             InboxRegistration(
                 session_id=self.session.session_id,
-                describe_title=lambda: self.session.title,
+                describe_title=lambda: self.session.name,
                 describe_project_path=lambda: str(self.active_project_path),
                 describe_status=self._peer_status,
                 deliver_message=self._deliver_peer_message,
@@ -953,7 +956,9 @@ class KolegaCodeApp(
             workspace_id=record.workspace_id,
             thread_id=record.thread_id,
             mode=record.mode,
+            name=record.name,
             title=record.title,
+            description=record.description,
             created_at=record.created_at,
             updated_at=record.updated_at,
             config=dict(record.config),
@@ -2645,8 +2650,16 @@ class KolegaCodeApp(
 
     def _meta_content(self) -> str:
         gigacode = "on" if self._gigacode_enabled else "off"
+        short_id = self.session.session_id[:8]
+        if self.session.title and self.session.title != self.session.name:
+            title = self.session.title
+            if len(title) > 36:
+                title = f"{title[:35]}…"
+            session_segment = f"{title} · {self.session.name} ({short_id})"
+        else:
+            session_segment = f"{self.session.name} ({short_id})"
         return (
-            f"{self.active_project_path} | session {self.session.session_id} | "
+            f"{self.active_project_path} | {session_segment} | "
             f"agent {self.mode} | {self.interaction_mode} | permissions {self.permission_mode.value} | "
             f"gigacode {gigacode}"
         )
@@ -3044,10 +3057,16 @@ class KolegaCodeApp(
         project_lines = [f"Project: {self.active_project_path}"]
         if self.active_project_path != self.project_path:
             project_lines.append(f"Launch project: {self.project_path}")
+        if self.session.title and self.session.title != self.session.name:
+            session_display = f"{session_id} · {self.session.title} ({self.session.name})"
+        elif self.session.name:
+            session_display = f"{session_id} ({self.session.name})"
+        else:
+            session_display = f"{session_id}"
         startup_lines.extend(
             [
                 *project_lines,
-                f"Session: {session_id}",
+                f"Session: {session_display}",
                 f"Mode: {self.mode}",
                 f"Interaction: {self.interaction_mode}",
                 f"Permissions: {self.permission_mode.value}",

{kolega_code-0.34.0 → kolega_code-0.35.0}/kolega_code/cli/gateway.py

@@ -31,6 +31,8 @@ from kolega_code.gateway.service import (
     LAUNCHD_LABEL,
     SERVICE_NAME,
     install_service,
+    is_service_installed,
+    restart_service,
     uninstall_service,
 )
 
@@ -76,6 +78,9 @@ def add_gateway_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentP
     uninstall = gateway_sub.add_parser("uninstall", help="Remove the gateway background service.")
     uninstall.add_argument("--state-dir", type=Path, default=None, help="Override the state directory.")
 
+    restart = gateway_sub.add_parser("restart", help="Restart the gateway background service.")
+    restart.add_argument("--state-dir", type=Path, default=None, help="Override the state directory.")
+
     telegram = gateway_sub.add_parser("telegram", help="Telegram adapter setup.")
     telegram_sub = telegram.add_subparsers(dest="telegram_command", required=True)
     setup = telegram_sub.add_parser("setup", help="Save the @BotFather bot token (stored in settings.json).")
@@ -112,7 +117,7 @@ async def _run_gateway(args: argparse.Namespace) -> int:
         return _gateway_pairing(args, config)
     if args.gateway_command == "telegram":
         return await _gateway_telegram(args, config)
-    if args.gateway_command in ("install", "uninstall"):
+    if args.gateway_command in ("install", "uninstall", "restart"):
         return _gateway_service(args, config)
     return await _gateway_run(config, args)
 
@@ -189,6 +194,20 @@ def _gateway_service(args: argparse.Namespace, config: GatewayConfig) -> int:
         for note in _activate_service(args.gateway_command, result.unit_path):
             print(f"gateway: {note}")
         return 0
+    if args.gateway_command == "restart":
+        if not is_service_installed():
+            print(
+                "gateway: background service is not installed (run 'kolega-code gateway install' to set it up)",
+                file=sys.stderr,
+            )
+            return 1
+        success, notes = restart_service()
+        for note in notes:
+            if success:
+                print(f"gateway: {note}")
+            else:
+                print(f"gateway: {note}", file=sys.stderr)
+        return 0 if success else 1
     for note in _activate_service("uninstall", None):
         print(f"gateway: {note}")
     for note in uninstall_service(config):

{kolega_code-0.34.0 → kolega_code-0.35.0}/kolega_code/cli/main.py

@@ -1015,6 +1015,8 @@ def _run_update() -> int:
         _print_styled(result.error, style="error", stderr=True)
     if result.returncode == 0:
         print("Kolega Code update completed. Run `kolega-code --version` to confirm.")
+        for note in result.gateway_restart_notes:
+            print(f"gateway: {note}")
     elif not result.error:
         _print_styled("Kolega Code update failed.", style="error", stderr=True)
     return result.returncode
@@ -1492,7 +1494,7 @@ def _apply_launch_name(
     *,
     persistable: bool = True,
 ) -> None:
-    """Apply --name at launch. The persisted title is a peer's address for the
+    """Apply --name at launch. The persisted name is a peer's address for the
     session, so invalid names fail loudly instead of being silently mangled."""
     from .peer_messaging import PEER_NAME_MAX_CHARS
 
@@ -1501,6 +1503,7 @@ def _apply_launch_name(
     name = str(raw_name).strip()
     if not name or len(name) > PEER_NAME_MAX_CHARS:
         raise SystemExit(f"Error: --name must be 1-{PEER_NAME_MAX_CHARS} characters.")
+    session.name = name
     session.title = name
     if persistable:
         store.save(session)
@@ -2377,17 +2380,22 @@ def _run_sessions(args: argparse.Namespace) -> int:
             return 0
         entries = []
         for record in reversed(records):
-            entries.append(
-                "\n".join(
-                    (
-                        f"Updated:   {record.updated_at}",
-                        f"Title:     {record.title}",
-                        f"Mode:      {record.mode}",
-                        f"Project:   {record.project_path}",
-                        f"Resume ID: {record.session_id}",
-                    )
-                )
+            item_lines = [
+                f"Updated:   {record.updated_at}",
+                f"Title:     {record.title or record.name}",
+            ]
+            if record.name and record.name != record.title:
+                item_lines.append(f"Name:      {record.name}")
+            if record.description:
+                item_lines.append(f"Description: {record.description}")
+            item_lines.extend(
+                [
+                    f"Mode:      {record.mode}",
+                    f"Project:   {record.project_path}",
+                    f"Resume ID: {record.session_id}",
+                ]
             )
+            entries.append("\n".join(item_lines))
         print("\n\n".join(entries))
         return 0
     if args.sessions_command == "delete":

{kolega_code-0.34.0 → kolega_code-0.35.0}/kolega_code/cli/peer_messaging.py

@@ -184,7 +184,7 @@ async def start_headless_peer_inbox(
 
 def store_title_lookup(store: Any) -> Any:
     """A discovery ``title_lookup`` backed by the shared session store."""
-    titles_by_id = {record.session_id: record.title for record in store.list()}
+    titles_by_id = {record.session_id: record.name for record in store.list()}
     return titles_by_id.get
 
 

{kolega_code-0.34.0 → kolega_code-0.35.0}/kolega_code/cli/provider_registry.py

@@ -98,6 +98,7 @@ MODEL_LABELS: dict[str, str] = {
     "gpt-5.4-mini": "GPT-5.4 Mini",
     "gpt-5.3-codex-spark": "GPT-5.3 Codex Spark",
     # Google
+    "gemini-3.8-flash": "Gemini 3.8 Flash",
     "gemini-3.7-flash": "Gemini 3.7 Flash",
     "gemini-3.6-flash": "Gemini 3.6 Flash",
     "gemini-3.5-flash-lite": "Gemini 3.5 Flash-Lite",
@@ -167,7 +168,7 @@ PROVIDER_DEFAULT_MODEL: dict[ModelProvider, str] = {
     ModelProvider.ANTHROPIC: "claude-opus-5",
     ModelProvider.OPENAI: "gpt-5.6-sol",
     ModelProvider.OPENAI_CHATGPT: "gpt-5.6-sol",
-    ModelProvider.GOOGLE: "gemini-3.7-flash",
+    ModelProvider.GOOGLE: "gemini-3.8-flash",
     ModelProvider.XAI: "grok-4.5",
     ModelProvider.FIREWORKS: "accounts/fireworks/models/glm-5p2",
     ModelProvider.TOGETHER: "moonshotai/Kimi-K2.7-Code",

{kolega_code-0.34.0 → kolega_code-0.35.0}/kolega_code/cli/session_store.py

@@ -139,9 +139,11 @@ class SessionRecord:
     workspace_id: str
     thread_id: str
     mode: str
-    title: str
     created_at: str
     updated_at: str
+    title: str = ""
+    name: str = ""
+    description: str = ""
     config: dict[str, Any] = field(default_factory=dict)
     history: list[dict[str, Any]] = field(default_factory=list)
     compaction: dict[str, Any] = field(default_factory=dict)
@@ -175,12 +177,16 @@ class SessionRecord:
         mode: str,
         config: dict[str, Any],
         session_id: Optional[str] = None,
+        name: Optional[str] = None,
         title: Optional[str] = None,
+        description: Optional[str] = None,
         parent_session_id: Optional[str] = None,
     ) -> "SessionRecord":
         now = _now()
         resolved_project = str(project_path.resolve())
         session_id = session_id or uuid.uuid4().hex
+        assigned_name = name or (title if title else generate_session_name())
+        assigned_title = title if title else (name if name else assigned_name)
         return cls(
             schema_version=SCHEMA_VERSION,
             session_id=session_id,
@@ -188,7 +194,9 @@ class SessionRecord:
             workspace_id=f"cli-{uuid.uuid4().hex}",
             thread_id=uuid.uuid4().hex,
             mode=mode,
-            title=title or generate_session_name(),
+            name=assigned_name,
+            title=assigned_title,
+            description=description or "",
             created_at=now,
             updated_at=now,
             config=config,
@@ -202,6 +210,14 @@ class SessionRecord:
             raise SessionStoreError(f"Unsupported session schema version: {data.get('schema_version')}")
         latest_plan_markdown = data.get("latest_plan_markdown") or ""
         plan_pending = bool(latest_plan_markdown and data.get("plan_pending", False))
+        raw_name = data.get("name")
+        raw_title = data.get("title") or ""
+        if raw_name:
+            name = raw_name
+            title = raw_title or raw_name
+        else:
+            name = raw_title or generate_session_name()
+            title = raw_title or name
         return cls(
             schema_version=data["schema_version"],
             session_id=data["session_id"],
@@ -209,7 +225,9 @@ class SessionRecord:
             workspace_id=data["workspace_id"],
             thread_id=data["thread_id"],
             mode=data["mode"],
-            title=data.get("title") or "Kolega Code",
+            name=name,
+            title=title,
+            description=data.get("description") or "",
             created_at=data["created_at"],
             updated_at=data["updated_at"],
             config=data.get("config") or {},
@@ -238,7 +256,9 @@ class SessionRecord:
             "workspace_id": self.workspace_id,
             "thread_id": self.thread_id,
             "mode": self.mode,
+            "name": self.name,
             "title": self.title,
+            "description": self.description,
             "created_at": self.created_at,
             "updated_at": self.updated_at,
             "config": self.config,
@@ -334,11 +354,20 @@ class SessionStore:
         mode: str,
         config: dict[str, Any],
         session_id: Optional[str] = None,
+        name: Optional[str] = None,
         title: Optional[str] = None,
+        description: Optional[str] = None,
         parent_session_id: Optional[str] = None,
     ) -> SessionRecord:
         record = SessionRecord.create(
-            project_path, mode, config, session_id=session_id, title=title, parent_session_id=parent_session_id
+            project_path,
+            mode,
+            config,
+            session_id=session_id,
+            name=name,
+            title=title,
+            description=description,
+            parent_session_id=parent_session_id,
         )
         self.ensure_dirs()
         session_dir = self.session_dir_for(record.session_id)

{kolega_code-0.34.0 → kolega_code-0.35.0}/kolega_code/cli/slash_commands.py

@@ -68,6 +68,9 @@ TUI_COMMAND_ENTRIES: tuple[SlashCommandEntry, ...] = (
     SlashCommandEntry("tasks", "Show the shared task list", CommandScope.TUI),
     SlashCommandEntry("peers", "List reachable agent sessions you can message", CommandScope.TUI),
     SlashCommandEntry("rename", "Rename this session (/rename <name>)", CommandScope.TUI),
+    SlashCommandEntry(
+        "retitle", "Set or regenerate session title and description (/retitle [title])", CommandScope.TUI
+    ),
     SlashCommandEntry("gigacode", "Toggle gigacode workflow orchestration on or off", CommandScope.TUI),
     SlashCommandEntry("prompts", "Dump, list, or validate project prompt override files", CommandScope.TUI),
     SlashCommandEntry("queue-clear", "Clear queued follow-up messages", CommandScope.TUI),

{kolega_code-0.34.0 → kolega_code-0.35.0}/kolega_code/cli/tui/agent_runtime.py

@@ -273,6 +273,7 @@ class AgentRuntimeMixin(tui_app_base.KolegaAppBase):
             await self._save_session_history_async()
             await self._capture_completed_plan()
             self._log_status(messages.FINISHED, "ok")
+            self._maybe_trigger_session_metadata()
         except asyncio.CancelledError:
             cancelled_by_user = True
             # When the app is quitting, action_quit already settled open
@@ -313,6 +314,74 @@ class AgentRuntimeMixin(tui_app_base.KolegaAppBase):
                     self._schedule_primary_focus_restore()
         return cancelled_by_user
 
+    def _maybe_trigger_session_metadata(self) -> None:
+        """Trigger background session title and description generation if turn meets depth."""
+        if self._exit or self.agent is None or not self.agent.history:
+            return
+        if len(self.agent.history) < 2:
+            return
+        self.run_worker(
+            self._update_session_metadata_worker(),
+            name="kolega-session-metadata",
+            group="metadata",
+            exclusive=True,
+        )
+
+    async def _update_session_metadata_worker(self, *, force_notify: bool = False) -> None:
+        """Generate descriptive session title and description in the background."""
+        if self.agent is None or not getattr(self.agent, "llm", None):
+            if force_notify:
+                self._notify_user("Cannot generate metadata: agent not ready.", severity="warning")
+            return
+        messages = list(self.agent.history)
+        if len(messages) < 2:
+            if force_notify:
+                self._notify_user("Not enough conversation history to generate title.", severity="warning")
+            return
+
+        from kolega_code.agent.session_metadata import generate_session_metadata
+        from ..main import known_secret_values
+
+        secret_values: list[str] = []
+        try:
+            secret_values = known_secret_values(self.settings, self.settings_store, project_path=self.project_path)
+        except Exception:
+            pass
+
+        model_cfg = getattr(self.agent, "primary_model_config", None)
+        model = model_cfg.model if model_cfg is not None else "fast"
+        metadata = await generate_session_metadata(
+            messages,
+            llm=self.agent.llm,
+            model=model,
+            secret_values=secret_values,
+        )
+        if metadata is None:
+            if force_notify:
+                self._notify_user("Could not generate session title.", severity="warning")
+            return
+
+        changed = False
+        if metadata.title and self.session.title != metadata.title:
+            self.session.title = metadata.title
+            changed = True
+        if metadata.description and self.session.description != metadata.description:
+            self.session.description = metadata.description
+            changed = True
+
+        if changed:
+            await self._save_session_async()
+            self._update_mode_chrome()
+
+        if force_notify:
+            self._add_conversation_entry(
+                tui_state.ConversationEntry(
+                    kind="system",
+                    content=f"Session retitled: **{self.session.title}**"
+                    + (f"\n{self.session.description}" if self.session.description else ""),
+                )
+            )
+
     async def _process_message(
         self, message: str, attachments: list[dict] | None = None, *, turn_label: str | None = None
     ) -> bool:
@@ -515,7 +584,7 @@ class AgentRuntimeMixin(tui_app_base.KolegaAppBase):
 
             message = PeerMessage.create(
                 sender_session_id=self.session.session_id,
-                sender_title=self.session.title,
+                sender_title=self.session.name,
                 text=cleaned_text,
             )
 

{kolega_code-0.34.0 → kolega_code-0.35.0}/kolega_code/cli/tui/app_base.py

@@ -292,6 +292,8 @@ class KolegaAppBase(App):
         async def _refresh_agent_memory(self) -> None: ...
         async def _save_session_history_async(self) -> None: ...
         async def _capture_completed_plan(self) -> None: ...
+        def _maybe_trigger_session_metadata(self) -> None: ...
+        async def _update_session_metadata_worker(self, *, force_notify: bool = False) -> None: ...
         def _schedule_primary_focus_restore(self) -> None: ...
         def _set_chat_enabled(self, enabled: bool) -> None: ...
         def _set_composer_status(self, status: str) -> None: ...