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

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

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

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

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

{tsugite_cli-0.14.2 → tsugite_cli-0.14.3}/tsugite/cli/daemon.py

@@ -44,13 +44,14 @@ def _prompt_bot_name(style) -> str:
     ).ask()
 
 
-def _prompt_token_env_var(style) -> str:
-    """Prompt for token environment variable name."""
+def _prompt_token_file_path(style, bot_name: str) -> str:
+    """Prompt for the file path that holds the Discord token."""
     import questionary
 
+    default_path = f"~/.config/tsugite/discord-{bot_name}.token"
     return questionary.text(
-        "Environment variable name for Discord token:",
-        default="DISCORD_BOT_TOKEN",
+        "Path to file containing Discord token:",
+        default=default_path,
         style=style,
     ).ask()
 
@@ -200,7 +201,8 @@ def _config_to_dict(config) -> dict:
         "discord_bots": [
             {
                 "name": bot.name,
-                "token": bot.token,
+                **({"token_secret": bot.token_secret} if bot.token_secret else {}),
+                **({"token_file": str(bot.token_file)} if bot.token_file else {}),
                 "agent": bot.agent,
                 "command_prefix": bot.command_prefix,
                 "dm_policy": bot.dm_policy,
@@ -220,14 +222,17 @@ def _show_generated_config(config_data: dict):
     console.print(Panel(config_yaml, border_style="cyan"))
 
 
-def _show_next_steps(token_env_var: str, bot_name: str):
+def _show_next_steps(token_file: str, bot_name: str):
     """Display next steps for the user."""
     console.print("\n" + "=" * 60)
     console.print("[bold green]Setup Complete![/bold green]")
     console.print("=" * 60)
 
     console.print("\n[bold]Next Steps:[/bold]")
-    console.print(f'  1. Set your Discord token: [cyan]export {token_env_var}="your-token"[/cyan]')
+    console.print(f"  1. Save your Discord token to: [cyan]{token_file}[/cyan]")
+    console.print(
+        f'     [dim]mkdir -p $(dirname {token_file}) && echo "your-token" > {token_file} && chmod 600 {token_file}[/dim]'
+    )
     console.print("  2. Start the daemon: [cyan]tsugite daemon[/cyan]")
     console.print("  3. DM your bot with: [cyan]!hello[/cyan]")
 
@@ -295,8 +300,8 @@ def init_daemon(
     if not bot_name:
         raise typer.Exit(1)
 
-    token_env_var = _prompt_token_env_var(style)
-    if not token_env_var:
+    token_file = _prompt_token_file_path(style, bot_name)
+    if not token_file:
         raise typer.Exit(1)
 
     command_prefix = _prompt_command_prefix(style)
@@ -335,7 +340,7 @@ def init_daemon(
 
     bot_config = {
         "name": bot_name,
-        "token": f"${{{token_env_var}}}",
+        "token_file": token_file,
         "agent": agent_config_name,
         "command_prefix": command_prefix,
         "dm_policy": dm_policy,
@@ -357,7 +362,7 @@ def init_daemon(
 
     console.print(f"[green]✓[/green] Configuration saved to: {config_path}")
 
-    _show_next_steps(token_env_var, bot_name)
+    _show_next_steps(token_file, bot_name)
 
 
 def _daemon_request(method: str, host: str, port: int, path: str, token: Optional[str] = None, **kwargs):

{tsugite_cli-0.14.2 → tsugite_cli-0.14.3}/tsugite/cli/run.py

@@ -87,19 +87,21 @@ def _check_and_run_onboarding(
     return workspace
 
 
-def _resolve_ui_mode(ui_mode: Optional[str], ui_opts: UIOptions, console: Console) -> UIOptions:
+def _resolve_ui_mode(ui_mode: Optional[str], ui_opts: UIOptions, stderr_console: Console) -> UIOptions:
     """Resolve UI mode flag and return updated UIOptions."""
     if not ui_mode:
         return ui_opts
 
     if ui_opts.plain or ui_opts.headless:
-        console.print("[red]Error: --ui cannot be used with --plain or --headless[/red]")
+        stderr_console.print("[red]Error: --ui cannot be used with --plain or --headless[/red]")
         raise typer.Exit(1)
 
     ui_modes = {"plain", "headless", "live"}
     ui_lower = ui_mode.lower()
     if ui_lower not in ui_modes:
-        console.print(f"[red]Error: Invalid UI mode '{ui_mode}'. Choose from: {', '.join(sorted(ui_modes))}[/red]")
+        stderr_console.print(
+            f"[red]Error: Invalid UI mode '{ui_mode}'. Choose from: {', '.join(sorted(ui_modes))}[/red]"
+        )
         raise typer.Exit(1)
 
     if ui_lower == "plain":
@@ -142,7 +144,7 @@ def _build_executor_kwargs(
 
 
 def _resolve_conversation_continuation(
-    continue_conversation: bool, conversation_id: Optional[str], console: Console
+    continue_conversation: bool, conversation_id: Optional[str], stderr_console: Console
 ) -> Optional[str]:
     """Resolve which conversation to continue."""
     if not continue_conversation:
@@ -151,15 +153,15 @@ def _resolve_conversation_continuation(
     from tsugite.agent_runner.history_integration import get_latest_conversation
 
     if conversation_id:
-        console.print(f"[cyan]Continuing conversation: {conversation_id}[/cyan]")
+        stderr_console.print(f"[cyan]Continuing conversation: {conversation_id}[/cyan]")
         return conversation_id
 
     continue_conversation_id = get_latest_conversation()
     if not continue_conversation_id:
-        console.print("[red]No conversations found to resume[/red]")
+        stderr_console.print("[red]No conversations found to resume[/red]")
         raise typer.Exit(1)
 
-    console.print(f"[cyan]Continuing latest conversation: {continue_conversation_id}[/cyan]")
+    stderr_console.print(f"[cyan]Continuing latest conversation: {continue_conversation_id}[/cyan]")
     return continue_conversation_id
 
 
@@ -318,21 +320,24 @@ def run(
         tsu run --daemon odyn "follow up message"  # Join daemon session for agent 'odyn'
     """
     from tsugite.agent_runner import get_agent_info, run_agent
+    from tsugite.console import get_stderr_console
     from tsugite.md_agents import validate_agent_execution
     from tsugite.secrets import init_cli as init_secrets
     from tsugite.utils import should_use_plain_output
 
     from . import console
 
+    stderr_console = get_stderr_console(no_color=no_color)
+
     init_secrets(no_secrets)
 
     # Validate flag combinations
     if new_session and continue_conversation:
-        console.print("[red]Error: Cannot use --new-session with --continue[/red]")
+        stderr_console.print("[red]Error: Cannot use --new-session with --continue[/red]")
         raise typer.Exit(1)
 
     if workspace and no_workspace:
-        console.print("[red]Error: Cannot use --workspace with --no-workspace[/red]")
+        stderr_console.print("[red]Error: Cannot use --workspace with --no-workspace[/red]")
         raise typer.Exit(1)
 
     ui_opts = UIOptions(
@@ -349,7 +354,7 @@ def run(
     workspace_to_use, resolved_workspace = _resolve_effective_workspace(workspace, no_workspace)
 
     if new_session and not workspace_to_use:
-        console.print("[yellow]Warning: --new-session has no effect without a workspace[/yellow]")
+        stderr_console.print("[yellow]Warning: --new-session has no effect without a workspace[/yellow]")
     exec_opts = ExecutionOptions.from_cli(
         model=model,
         debug=debug,
@@ -367,7 +372,7 @@ def run(
         history_dir=history_dir,
     )
     if workspace_to_use and not resolved_workspace:
-        console.print(f"[yellow]Warning: Workspace '{workspace_to_use}' not found[/yellow]")
+        stderr_console.print(f"[yellow]Warning: Workspace '{workspace_to_use}' not found[/yellow]")
 
     # Auto-continue workspace session unless explicitly overridden
     workspace_session_continued = False
@@ -407,14 +412,16 @@ def run(
         console.no_color = True
 
     # Resolve UI mode to update ui_opts
-    ui_opts = _resolve_ui_mode(ui, ui_opts, console)
+    ui_opts = _resolve_ui_mode(ui, ui_opts, stderr_console)
 
     # Handle subagent mode and daemon mode (both need os)
     import os
 
     if subagent_mode:
         if ui_opts.plain or ui_opts.headless or ui_opts.live:
-            console.print("[red]Error: --subagent-mode cannot be combined with --plain, --headless, or --ui live[/red]")
+            stderr_console.print(
+                "[red]Error: --subagent-mode cannot be combined with --plain, --headless, or --ui live[/red]"
+            )
             raise typer.Exit(1)
 
         ui_opts.non_interactive = True
@@ -430,14 +437,14 @@ def run(
 
             daemon_config = load_daemon_config()
             if daemon_agent not in daemon_config.agents:
-                console.print(f"[red]Agent '{daemon_agent}' not found in daemon config[/red]")
+                stderr_console.print(f"[red]Agent '{daemon_agent}' not found in daemon config[/red]")
                 raise typer.Exit(1)
 
             agent_config = daemon_config.agents[daemon_agent]
 
         except ValueError as e:
-            console.print(f"[red]Daemon config not found: {e}[/red]")
-            console.print("[dim]Run 'tsugite daemon' to start daemon first[/dim]")
+            stderr_console.print(f"[red]Daemon config not found: {e}[/red]")
+            stderr_console.print("[dim]Run 'tsugite daemon' to start daemon first[/dim]")
             raise typer.Exit(1)
 
         # Find latest session for this agent
@@ -455,11 +462,11 @@ def run(
                 continue
 
         if latest_conv_id:
-            console.print(f"[cyan]Joining daemon session: {latest_conv_id}[/cyan]")
+            stderr_console.print(f"[cyan]Joining daemon session: {latest_conv_id}[/cyan]")
             history_opts.continue_id = latest_conv_id
         else:
-            console.print(f"[yellow]No active daemon session found for '{daemon_agent}'[/yellow]")
-            console.print("[dim]Creating new daemon-managed session...[/dim]")
+            stderr_console.print(f"[yellow]No active daemon session found for '{daemon_agent}'[/yellow]")
+            stderr_console.print("[dim]Creating new daemon-managed session...[/dim]")
 
         # Override agent with daemon agent
         args = [f"+{daemon_agent}"] + args
@@ -489,9 +496,9 @@ def run(
 
     # Handle conversation continuation - check before parsing args
     if continue_conversation and not history_opts.continue_id:
-        history_opts.continue_id = _resolve_conversation_continuation(True, None, console)
+        history_opts.continue_id = _resolve_conversation_continuation(True, None, stderr_console)
     elif history_opts.continue_id:
-        console.print(f"[cyan]Continuing conversation: {history_opts.continue_id}[/cyan]")
+        stderr_console.print(f"[cyan]Continuing conversation: {history_opts.continue_id}[/cyan]")
 
     # Parse CLI arguments into agents and prompt (allow empty agents when continuing)
     try:
@@ -501,10 +508,10 @@ def run(
             args, allow_empty_agents=continue_conversation, check_stdin=not continue_conversation
         )
     except ValueError as e:
-        console.print(f"[red]Error: {e}[/red]")
+        stderr_console.print(f"[red]Error: {e}[/red]")
         raise typer.Exit(1)
 
-    with workspace_directory_context(resolved_workspace, root, console) as path_context:
+    with workspace_directory_context(resolved_workspace, root, stderr_console) as path_context:
         try:
             base_dir = Path.cwd()
 
@@ -518,15 +525,17 @@ def run(
                     if not agent_name:
                         raise ValueError("agent name missing from session_start")
                 except Exception:
-                    console.print(f"[red]Could not load metadata for conversation: {history_opts.continue_id}[/red]")
+                    stderr_console.print(
+                        f"[red]Could not load metadata for conversation: {history_opts.continue_id}[/red]"
+                    )
                     raise typer.Exit(1)
 
-                console.print(f"[cyan]Auto-detected agent from conversation: {agent_name}[/cyan]")
+                stderr_console.print(f"[cyan]Auto-detected agent from conversation: {agent_name}[/cyan]")
                 agent_refs = [f"+{agent_name}"]
 
             # Handle multi-agent mode: first agent is primary, rest are allowed to spawn
             if not agent_refs:
-                console.print("[red]Error: No agent specified[/red]")
+                stderr_console.print("[red]Error: No agent specified[/red]")
                 raise typer.Exit(1)
 
             from tsugite.agent_runner.helpers import set_allowed_agents
@@ -537,27 +546,23 @@ def run(
             if len(agent_refs) > 1:
                 allowed_agent_names = []
                 for allowed_ref in agent_refs[1:]:
-                    _, allowed_file, _ = load_and_validate_agent(allowed_ref, console)
+                    _, allowed_file, _ = load_and_validate_agent(allowed_ref, stderr_console)
                     allowed_agent = parse_agent_file(allowed_file)
                     allowed_agent_names.append(allowed_agent.config.name)
 
                 set_allowed_agents(allowed_agent_names)
-                console.print(f"[cyan]Allowed agents to spawn: {', '.join(allowed_agent_names)}[/cyan]")
+                stderr_console.print(f"[cyan]Allowed agents to spawn: {', '.join(allowed_agent_names)}[/cyan]")
             else:
                 set_allowed_agents(None)
 
-            _, agent_file, _ = load_and_validate_agent(primary_agent_ref, console)
+            _, agent_file, _ = load_and_validate_agent(primary_agent_ref, stderr_console)
 
         except ValueError as e:
-            console.print(f"[red]Error: {e}[/red]")
+            stderr_console.print(f"[red]Error: {e}[/red]")
             raise typer.Exit(1)
 
         use_plain_output = ui_opts.plain or should_use_plain_output()
 
-        from tsugite.console import get_stderr_console
-
-        stderr_console = get_stderr_console(no_color=ui_opts.no_color)
-
         # Print deferred workspace status messages
         if not ui_opts.headless and not ui_opts.final_only:
             if workspace_to_use and not workspace:
@@ -591,7 +596,7 @@ def run(
             cli_attachments=attach_opts.sources,
             base_dir=base_dir,
             refresh_cache=attach_opts.refresh_cache,
-            console=console,
+            console=stderr_console,
             stdin_attachment=stdin_attachment,
         )
 
@@ -624,7 +629,7 @@ def run(
 
         is_valid, error_msg = validate_agent_execution(agent_file)
         if not is_valid:
-            get_error_console(ui_opts.headless, console).print(f"[red]Agent validation failed: {error_msg}[/red]")
+            stderr_console.print(f"[red]Agent validation failed: {error_msg}[/red]")
             raise typer.Exit(1)
 
         from tsugite.agent_runner import preview_multistep_agent, run_multistep_agent
@@ -638,11 +643,11 @@ def run(
                 preview_multistep_agent(
                     agent_path=agent_file,
                     prompt=prompt,
-                    console=console,
+                    console=stderr_console,
                 )
             else:
-                console.print("[yellow]Dry-run mode is for multi-step agents only.[/yellow]")
-                console.print("[dim]This is a single-step agent. Use --debug to see the rendered prompt.[/dim]")
+                stderr_console.print("[yellow]Dry-run mode is for multi-step agents only.[/yellow]")
+                stderr_console.print("[dim]This is a single-step agent. Use --debug to see the rendered prompt.[/dim]")
             return
 
         executor = run_multistep_agent if is_multistep else run_agent
@@ -708,7 +713,7 @@ def run(
                 executor_kwargs,
                 ui_opts,
                 use_plain_output,
-                console,
+                stderr_console,
             )
 
             (
@@ -734,20 +739,19 @@ def run(
 
         except ValueError as e:
             _save_history(status="error", error_message=str(e))
-            get_error_console(ui_opts.headless, console).print(f"[red]Configuration error: {e}[/red]")
+            stderr_console.print(f"[red]Configuration error: {e}[/red]")
             raise typer.Exit(1)
         except RuntimeError as e:
             _save_history(status="error", error_message=str(e))
-            get_error_console(ui_opts.headless, console).print(f"[red]Execution error: {e}[/red]")
+            stderr_console.print(f"[red]Execution error: {e}[/red]")
             raise typer.Exit(1)
         except KeyboardInterrupt:
             _save_history(status="interrupted")
-            get_error_console(ui_opts.headless, console).print("\n[yellow]Agent execution interrupted by user[/yellow]")
+            stderr_console.print("\n[yellow]Agent execution interrupted by user[/yellow]")
             raise typer.Exit(130)
         except Exception as e:
             _save_history(status="error", error_message=str(e))
-            err_console = get_error_console(ui_opts.headless, console)
-            err_console.print(f"[red]Unexpected error: {e}[/red]")
+            stderr_console.print(f"[red]Unexpected error: {e}[/red]")
             if not ui_opts.log_json:
-                err_console.print("\n[dim]Use --log-json for machine-readable output[/dim]")
+                stderr_console.print("\n[dim]Use --log-json for machine-readable output[/dim]")
             raise typer.Exit(1)

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

@@ -431,6 +431,7 @@ class BaseAdapter(ABC):
             scheduled_xml = render_iso_element("scheduled_for", meta.get("scheduled_for"), tz, tz_label, now)
             actual_xml = render_iso_element("actual_fire_time", meta.get("actual_fire_time"), tz, tz_label, now)
             scheduler_timing_xml = scheduled_xml + actual_xml
+        context_limit_for_render = self.session_store.get_context_limit(self.agent_name)
         try:
             conv_id_override = (channel_context.metadata or {}).get("conv_id_override")
             if conv_id_override:
@@ -440,6 +441,7 @@ class BaseAdapter(ABC):
             if session is None:
                 raise ValueError("no default session yet")
             tokens_used = session.cumulative_tokens
+            context_limit_for_render = self.session_store.get_session_context_limit(session.id)
             session_started_xml = render_iso_element("session_started", session.created_at, tz, tz_label, now)
             last_active_xml = render_iso_element("last_active", session.last_active, tz, tz_label, now)
             if session.metadata:
@@ -465,7 +467,7 @@ class BaseAdapter(ABC):
   <source>{channel_context.source}</source>
   <user_id>{channel_context.user_id}</user_id>
   <context_tokens_used>{tokens_used}</context_tokens_used>
-  <context_limit>{self.agent_config.context_limit}</context_limit>{session_topic_xml}{session_meta_xml}{scratchpad_xml}
+  <context_limit>{context_limit_for_render}</context_limit>{session_topic_xml}{session_meta_xml}{scratchpad_xml}
 </message_context>
 
 {message}"""
@@ -684,8 +686,10 @@ class BaseAdapter(ABC):
 
         ps = getattr(result, "provider_state", None) or {}
         if ps.get("context_window"):
-            self.session_store.update_context_limit(self.agent_name, ps["context_window"])
-            self.agent_config.context_limit = ps["context_window"]
+            # Per-session storage: this turn's reported window applies to THIS
+            # session only. An agent-wide scalar would let any other turn (or a
+            # secondary model call) clobber the displayed limit.
+            self.session_store.update_session_context_limit(conv_id, ps["context_window"])
 
         last_input = getattr(result, "last_input_tokens", None)
         context_tokens = last_input if isinstance(last_input, int) and last_input > 0 else (result.token_count or 0)
@@ -866,7 +870,27 @@ class BaseAdapter(ABC):
         use the returned session for downstream id-keyed work; rediscovering
         via `find_default_session` is unreliable for non-default or
         non-interactive sessions.
+
+        Defensive snapshot/restore of the agent-wide context-limit fallback. The
+        primary per-session limit lives on `Session.context_limit` and isn't
+        touched here; this guard catches any future code path that mutates the
+        agent-wide default during the compaction flow.
         """
+        saved_session_store_limit = self.session_store.get_context_limit(self.agent_name)
+        saved_agent_config_limit = self.agent_config.context_limit
+        try:
+            return await self._compact_session_inner(session_id, instructions, reason, progress_callback)
+        finally:
+            self.session_store.update_context_limit(self.agent_name, saved_session_store_limit)
+            self.agent_config.context_limit = saved_agent_config_limit
+
+    async def _compact_session_inner(
+        self,
+        session_id: str,
+        instructions: str | None,
+        reason: str | None,
+        progress_callback: Optional[Callable[[Dict[str, Any]], None]],
+    ) -> Optional[Session]:
         if instructions is None:
             instructions = self._DEFAULT_COMPACT_INSTRUCTIONS
         from tsugite.daemon.memory import (
@@ -894,7 +918,12 @@ class BaseAdapter(ABC):
             None,
         )
 
-        context_limit = get_context_limit(model, fallback=self.agent_config.context_limit)
+        # Fallback to the session's tracked window (set from the main model's
+        # last reported context_window) rather than the agent-wide scalar so
+        # sessions with different model overrides compute their own correct
+        # retention budget.
+        session_limit_fallback = self.session_store.get_session_context_limit(session_id)
+        context_limit = get_context_limit(model, fallback=session_limit_fallback)
         retention_budget = int(context_limit * RETENTION_BUDGET_RATIO)
 
         old_events, recent_events = split_events_for_compaction(all_events, model, retention_budget)
@@ -1002,25 +1031,16 @@ class BaseAdapter(ABC):
 
         old_messages = sanitize_for_summary(old_messages, model=model, attachment_basenames=attachment_basenames)
 
-        # Snapshot the agent's tracked context limit before summarization so
-        # that any mutation during the call (e.g. provider state leakage from
-        # a smaller compact model) doesn't corrupt the displayed value or
-        # the next compaction-threshold computation.
-        saved_session_store_limit = self.session_store.get_context_limit(self.agent_name)
-        saved_agent_config_limit = self.agent_config.context_limit
         try:
             summary = await summarize_session(
                 old_messages,
                 model=model,
-                max_context_tokens=self.agent_config.context_limit,
+                max_context_tokens=session_limit_fallback,
                 progress_callback=progress_callback,
             )
         except Exception:
             logger.exception("[%s] Compaction summarization failed", self.agent_name)
             raise
-        finally:
-            self.session_store.update_context_limit(self.agent_name, saved_session_store_limit)
-            self.agent_config.context_limit = saved_agent_config_limit
 
         new_session = self.session_store.compact_session(session_id)
         new_session_path = get_history_dir() / f"{new_session.id}.jsonl"
@@ -1044,7 +1064,14 @@ class BaseAdapter(ABC):
             source_session_id=old_conv_id,
         )
         for event in recent_events:
-            new_storage.record(event.type, **event.data)
+            data = event.data
+            if event.type == "model_response" and "state_delta" in data:
+                # state_delta holds provider-specific runtime IDs (e.g. claude_code
+                # session_id, compaction flags) tied to the pre-compaction session.
+                # Carrying them forward causes the next turn to resume the old
+                # Claude Code session and bypass compaction entirely.
+                data = {k: v for k, v in data.items() if k != "state_delta"}
+            new_storage.record(event.type, **data)
 
         post_compact_execs = await fire_compact_hooks(
             self.agent_config.workspace_dir,

{tsugite_cli-0.14.2 → tsugite_cli-0.14.3}/tsugite/daemon/adapters/discord.py

@@ -892,7 +892,7 @@ class DiscordAdapter(BaseAdapter):
         backoff = 5
         for attempt in range(max_retries):
             try:
-                await self.bot.start(self.bot_config.token)
+                await self.bot.start(self.bot_config.resolve_token())
                 break
             except (discord.errors.DiscordServerError, OSError) as e:
                 if attempt < max_retries - 1:

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

@@ -7,7 +7,7 @@ import mimetypes
 import re
 import shutil
 import threading
-from dataclasses import asdict, dataclass
+from dataclasses import dataclass
 from dataclasses import fields as dataclass_fields
 from datetime import datetime, timezone
 from pathlib import Path
@@ -28,7 +28,7 @@ from tsugite.attachments.base import AttachmentContentType
 from tsugite.attachments.file import FileHandler
 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.scheduler import ScheduleEntry, entry_to_dict
 from tsugite.daemon.webhook_store import WebhookStore
 from tsugite.events.base import BaseEvent
 from tsugite.history.storage import get_history_dir
@@ -836,8 +836,16 @@ class HTTPServer:
                 "model": model,
                 "resolved_model": resolved_model if resolved_model != model else None,
                 "tokens": tokens,
-                "context_limit": adapter.session_store.get_context_limit(adapter.agent_name),
-                "threshold": adapter.session_store.get_compaction_threshold(adapter.agent_name),
+                "context_limit": (
+                    adapter.session_store.get_session_context_limit(session.id)
+                    if session
+                    else adapter.session_store.get_context_limit(adapter.agent_name)
+                ),
+                "threshold": (
+                    adapter.session_store.get_session_compaction_threshold(session.id)
+                    if session
+                    else adapter.session_store.get_compaction_threshold(adapter.agent_name)
+                ),
                 "message_count": message_count,
                 "compacting": adapter.session_store.is_compacting(
                     user_id, adapter.agent_name, session_id=session.id if session else None
@@ -860,6 +868,10 @@ class HTTPServer:
 
         if "model" in body:
             new_model = body["model"].strip() if body["model"] else None
+            # Pin existing sessions to the current model before mutating the
+            # agent default so they don't silently switch on their next turn.
+            # The default change should only affect sessions created after it.
+            adapter.session_store.freeze_session_models_to_current(adapter.agent_name, agent_config.model)
             agent_config.model = new_model
 
             from tsugite.daemon.memory import DEFAULT_CONTEXT_LIMIT, get_context_limit
@@ -1469,8 +1481,8 @@ class HTTPServer:
                         {
                             "session_id": target_session_id,
                             "tokens": refreshed.cumulative_tokens,
-                            "context_limit": adapter.session_store.get_context_limit(adapter.agent_name),
-                            "threshold": adapter.session_store.get_compaction_threshold(adapter.agent_name),
+                            "context_limit": adapter.session_store.get_session_context_limit(target_session_id),
+                            "threshold": adapter.session_store.get_session_compaction_threshold(target_session_id),
                             "message_count": refreshed.message_count,
                             "model": adapter.resolve_model(),
                             "attachments": [a.name for a in adapter._get_all_attachments()],
@@ -1541,7 +1553,7 @@ class HTTPServer:
     async def _list_schedules(self, request: Request) -> JSONResponse:
         if err := self._require_auth_and_scheduler(request):
             return err
-        return JSONResponse({"schedules": [asdict(e) for e in self.scheduler.list()]})
+        return JSONResponse({"schedules": [entry_to_dict(e) for e in self.scheduler.list()]})
 
     async def _create_schedule(self, request: Request) -> JSONResponse:
         if err := self._require_auth_and_scheduler(request):
@@ -1565,7 +1577,7 @@ class HTTPServer:
             return JSONResponse({"error": str(e)}, status_code=400)
 
         self.event_bus.emit("schedule_update", {"action": "created", "id": entry.id})
-        return JSONResponse(asdict(entry), status_code=201)
+        return JSONResponse(entry_to_dict(entry), status_code=201)
 
     async def _get_schedule(self, request: Request) -> JSONResponse:
         if err := self._require_auth_and_scheduler(request):
@@ -1574,7 +1586,7 @@ class HTTPServer:
             entry = self.scheduler.get(request.path_params["schedule_id"])
         except ValueError as e:
             return JSONResponse({"error": str(e)}, status_code=404)
-        return JSONResponse(asdict(entry))
+        return JSONResponse(entry_to_dict(entry))
 
     async def _update_schedule(self, request: Request) -> JSONResponse:
         if err := self._require_auth_and_scheduler(request):
@@ -1609,7 +1621,7 @@ class HTTPServer:
         except ValueError as e:
             return JSONResponse({"error": str(e)}, status_code=400)
         self.event_bus.emit("schedule_update", {"action": "updated", "id": schedule_id})
-        return JSONResponse(asdict(entry))
+        return JSONResponse(entry_to_dict(entry))
 
     async def _delete_schedule(self, request: Request) -> JSONResponse:
         if err := self._require_auth_and_scheduler(request):