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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsugite-cli
-Version: 0.8.0
+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.0 → tsugite_cli-0.9.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.8.0"
+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.0 → tsugite_cli-0.9.1}/tests/test_cache_control.py

@@ -28,20 +28,20 @@ class TestApplyCacheControlToMessages:
         assert result == []
 
     def test_single_turn_caching(self):
-        """Test caching a single turn - all messages cached."""
+        """Test caching a single turn - both messages cached (within default limit)."""
         messages = [
             {"role": "user", "content": "Hello"},
             {"role": "assistant", "content": "Hi"},
         ]
         result = apply_cache_control_to_messages(messages)
 
-        # Both messages should have cache_control
+        # Both messages should have cache_control (2 <= default max_markers of 2)
         assert len(result) == 2
         assert result[0]["cache_control"] == {"type": "ephemeral"}
         assert result[1]["cache_control"] == {"type": "ephemeral"}
 
-    def test_multiple_turns_all_cached(self):
-        """Test that all turns are cached (industry best practice)."""
+    def test_multiple_turns_only_last_cached(self):
+        """Test that only the last max_markers messages get cache_control."""
         messages = [
             {"role": "user", "content": "Turn 1 user"},
             {"role": "assistant", "content": "Turn 1 assistant"},
@@ -52,13 +52,15 @@ class TestApplyCacheControlToMessages:
         ]
         result = apply_cache_control_to_messages(messages)
 
-        # All messages should have cache_control
+        # Only last 2 messages should have cache_control (default max_markers=2)
         assert len(result) == 6
-        for i, msg in enumerate(result):
-            assert msg["cache_control"] == {"type": "ephemeral"}, f"Message {i} not cached"
+        for msg in result[:4]:
+            assert "cache_control" not in msg
+        assert result[4]["cache_control"] == {"type": "ephemeral"}
+        assert result[5]["cache_control"] == {"type": "ephemeral"}
 
-    def test_many_turns_all_cached(self):
-        """Test that even many turns are all cached."""
+    def test_many_turns_respects_limit(self):
+        """Test that many turns only cache the last max_markers messages."""
         messages = []
         for i in range(10):
             messages.append({"role": "user", "content": f"Turn {i}"})
@@ -66,11 +68,30 @@ class TestApplyCacheControlToMessages:
 
         result = apply_cache_control_to_messages(messages)
 
-        # All 20 messages should be cached
+        # Only last 2 should be cached (default max_markers=2)
         assert len(result) == 20
-        for msg in result:
+        cached_count = sum(1 for msg in result if "cache_control" in msg)
+        assert cached_count == 2
+        for msg in result[:18]:
+            assert "cache_control" not in msg
+        for msg in result[18:]:
             assert msg["cache_control"] == {"type": "ephemeral"}
 
+    def test_custom_max_markers(self):
+        """Test with a custom max_markers value."""
+        messages = [
+            {"role": "user", "content": f"Turn {i}"}
+            for i in range(10)
+        ]
+        result = apply_cache_control_to_messages(messages, max_markers=3)
+
+        cached_count = sum(1 for msg in result if "cache_control" in msg)
+        assert cached_count == 3
+        assert "cache_control" not in result[6]
+        assert result[7]["cache_control"] == {"type": "ephemeral"}
+        assert result[8]["cache_control"] == {"type": "ephemeral"}
+        assert result[9]["cache_control"] == {"type": "ephemeral"}
+
     def test_preserves_existing_fields(self):
         """Test that existing message fields are preserved."""
         messages = [
@@ -90,12 +111,25 @@ class TestApplyCacheControlToMessages:
         assert result[1]["function_call"] == {"name": "test"}
         assert result[1]["cache_control"] == {"type": "ephemeral"}
 
+    def test_anthropic_limit_with_context_turn(self):
+        """Test that history markers + context turn (2) stay within Anthropic's 4 block limit."""
+        messages = []
+        for i in range(100):
+            messages.append({"role": "user", "content": f"Turn {i}"})
+            messages.append({"role": "assistant", "content": f"Response {i}"})
+
+        result = apply_cache_control_to_messages(messages)
+
+        cached_count = sum(1 for msg in result if "cache_control" in msg)
+        # Default 2 + 2 from context turn = 4 total (Anthropic limit)
+        assert cached_count == 2
+
 
 class TestCacheControlIntegration:
     """Integration tests for cache control with conversation history."""
 
     def test_load_and_cache_conversation(self, temp_history_dir):
-        """Test loading conversation and applying cache control to all messages."""
+        """Test loading conversation and applying cache control."""
         from tsugite.history import reconstruct_messages
 
         storage = SessionStorage.create(agent_name="test_agent", model="test:model")
@@ -114,18 +148,17 @@ class TestCacheControlIntegration:
 
         # Load messages
         messages = reconstruct_messages(storage.session_path)
-        assert len(messages) == 6  # 3 turns × 2 messages
+        assert len(messages) == 6  # 3 turns x 2 messages
 
-        # Apply cache control to all messages (industry best practice)
+        # Apply cache control - only last 2 messages should be cached
         cached = apply_cache_control_to_messages(messages)
 
-        # All messages should be cached
         assert len(cached) == 6
-        for msg in cached:
-            assert msg["cache_control"] == {"type": "ephemeral"}
+        cached_count = sum(1 for msg in cached if "cache_control" in msg)
+        assert cached_count == 2
 
-    def test_long_conversation_all_cached(self, temp_history_dir):
-        """Test that even long conversations have all messages cached."""
+    def test_long_conversation_respects_limit(self, temp_history_dir):
+        """Test that long conversations respect the cache_control block limit."""
         from tsugite.history import reconstruct_messages
 
         storage = SessionStorage.create(agent_name="test_agent", model="test:model")
@@ -143,11 +176,9 @@ class TestCacheControlIntegration:
             )
 
         messages = reconstruct_messages(storage.session_path)
-        assert len(messages) == 20  # 10 turns × 2 messages
+        assert len(messages) == 20  # 10 turns x 2 messages
 
-        # Apply cache control - should cache all messages
         cached = apply_cache_control_to_messages(messages)
 
-        # All 20 messages should be cached
         cached_count = sum(1 for msg in cached if "cache_control" in msg)
-        assert cached_count == 20
+        assert cached_count == 2

{tsugite_cli-0.8.0 → tsugite_cli-0.9.1}/tests/test_continuation.py

@@ -448,5 +448,6 @@ class TestToolCallHistory:
         cached = apply_cache_control_to_messages(reconstructed)
 
         assert len(cached) == 4
-        for msg in cached:
-            assert msg["cache_control"] == {"type": "ephemeral"}
+        # Last 2 messages get cache_control (default max_markers=2, context turn uses the other 2)
+        cached_count = sum(1 for msg in cached if "cache_control" in msg)
+        assert cached_count == 2

tsugite_cli-0.9.1/tests/test_tmux_tools.py

@@ -0,0 +1,397 @@
+"""Tests for tmux session management tools."""
+
+import json
+import subprocess
+from unittest.mock import MagicMock, call, patch
+
+import pytest
+
+from tsugite.tools.tmux import (
+    _get_session_status,
+    _list_managed_sessions,
+    _strip_ansi,
+    _validate_name,
+    get_tmux_sessions,
+    tmux_create,
+    tmux_kill,
+    tmux_list,
+    tmux_read,
+    tmux_send,
+)
+
+
+@pytest.fixture
+def mock_metadata(tmp_path, monkeypatch):
+    """Redirect metadata and log paths to tmp_path."""
+    meta_dir = tmp_path / "tmux"
+    log_dir = tmp_path / "tmux-logs"
+    meta_dir.mkdir()
+    log_dir.mkdir()
+
+    monkeypatch.setattr("tsugite.tools.tmux._get_metadata_path", lambda: meta_dir / "sessions.json")
+    monkeypatch.setattr("tsugite.tools.tmux._get_log_dir", lambda: log_dir)
+    return tmp_path
+
+
+def _make_run_result(returncode=0, stdout="", stderr=""):
+    result = MagicMock(spec=subprocess.CompletedProcess)
+    result.returncode = returncode
+    result.stdout = stdout
+    result.stderr = stderr
+    return result
+
+
+class TestStripAnsi:
+    def test_strips_sgr_sequences(self):
+        assert _strip_ansi("\x1b[31mred\x1b[0m") == "red"
+
+    def test_strips_bold_and_color(self):
+        assert _strip_ansi("\x1b[1;32mgreen bold\x1b[0m") == "green bold"
+
+    def test_strips_osc_sequences(self):
+        assert _strip_ansi("\x1b]0;title\x07text") == "text"
+
+    def test_strips_charset_designator(self):
+        assert _strip_ansi("\x1b(Btext") == "text"
+
+    def test_passthrough_clean_text(self):
+        assert _strip_ansi("hello world") == "hello world"
+
+    def test_mixed_ansi(self):
+        text = "\x1b[1m\x1b[32mOK\x1b[0m: \x1b[34mtest\x1b[0m passed"
+        assert _strip_ansi(text) == "OK: test passed"
+
+
+class TestValidateName:
+    def test_valid_names(self):
+        for name in ["test", "my-session", "project_1", "A-b_C-3"]:
+            _validate_name(name)
+
+    def test_invalid_names(self):
+        for name in ["has space", "semi;colon", "pipe|char", "slash/path", ""]:
+            with pytest.raises(ValueError, match="Invalid session name"):
+                _validate_name(name)
+
+
+class TestGetSessionStatus:
+    @patch("tsugite.tools.tmux._get_pane_command")
+    def test_idle_when_shell(self, mock_cmd):
+        for shell in ["bash", "zsh", "sh", "fish"]:
+            mock_cmd.return_value = shell
+            assert _get_session_status("tsu-test") == "idle"
+
+    @patch("tsugite.tools.tmux._get_pane_command")
+    def test_active_when_process(self, mock_cmd):
+        mock_cmd.return_value = "python3"
+        assert _get_session_status("tsu-test") == "active: python3"
+
+    @patch("tsugite.tools.tmux._get_pane_command")
+    def test_idle_when_empty(self, mock_cmd):
+        mock_cmd.return_value = ""
+        assert _get_session_status("tsu-test") == "idle"
+
+
+class TestTmuxCreate:
+    @patch("tsugite.tools.tmux._session_exists", return_value=False)
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_create_session(self, mock_run, mock_exists, mock_metadata):
+        mock_run.return_value = _make_run_result()
+
+        result = tmux_create("test")
+
+        assert result["name"] == "test"
+        assert result["tmux_session"] == "tsu-test"
+        assert result["status"] == "created"
+        assert "log_file" in result
+
+        calls = mock_run.call_args_list
+        assert calls[0] == call(
+            ["tmux", "new-session", "-d", "-s", "tsu-test", "-x", "200", "-y", "50"],
+            capture_output=True,
+            text=True,
+        )
+        assert calls[1].args[0][:4] == ["tmux", "pipe-pane", "-t", "tsu-test"]
+
+    @patch("tsugite.tools.tmux._session_exists", return_value=False)
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_create_with_command(self, mock_run, mock_exists, mock_metadata):
+        mock_run.return_value = _make_run_result()
+
+        tmux_create("test", command="htop")
+
+        new_session_call = mock_run.call_args_list[0]
+        assert "htop" in new_session_call.args[0]
+
+    @patch("tsugite.tools.tmux._session_exists", return_value=True)
+    def test_create_already_exists(self, mock_exists):
+        with pytest.raises(RuntimeError, match="already exists"):
+            tmux_create("test")
+
+    def test_create_invalid_name(self):
+        with pytest.raises(ValueError, match="Invalid session name"):
+            tmux_create("bad name")
+
+    @patch("tsugite.tools.tmux._session_exists", return_value=False)
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_create_saves_metadata(self, mock_run, mock_exists, mock_metadata):
+        mock_run.return_value = _make_run_result()
+
+        tmux_create("myproject", command="python3")
+
+        meta_path = mock_metadata / "tmux" / "sessions.json"
+        assert meta_path.exists()
+        data = json.loads(meta_path.read_text())
+        assert "myproject" in data
+        assert data["myproject"]["command"] == "python3"
+        assert data["myproject"]["prefixed_name"] == "tsu-myproject"
+
+    @patch("tsugite.tools.tmux._session_exists", return_value=False)
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_create_cleans_up_on_pipe_failure(self, mock_run, mock_exists, mock_metadata):
+        mock_run.side_effect = [
+            _make_run_result(),  # new-session succeeds
+            _make_run_result(returncode=1, stderr="pipe error"),  # pipe-pane fails
+            _make_run_result(),  # kill-session cleanup
+        ]
+
+        with pytest.raises(RuntimeError, match="Failed to set up logging"):
+            tmux_create("test")
+
+    @patch("tsugite.tools.tmux._session_exists", return_value=False)
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_create_pipe_pane_uses_shlex_quote(self, mock_run, mock_exists, mock_metadata):
+        mock_run.return_value = _make_run_result()
+
+        tmux_create("test")
+
+        pipe_call = mock_run.call_args_list[1]
+        pipe_arg = pipe_call.args[0][5]  # The -o argument value
+        assert pipe_arg.startswith("cat >> ")
+
+
+class TestTmuxRead:
+    @patch("tsugite.tools.tmux._session_exists", return_value=True)
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_read_pane(self, mock_run, mock_exists):
+        mock_run.return_value = _make_run_result(stdout="\x1b[32mhello\x1b[0m world\n")
+
+        result = tmux_read("test", lines=10)
+
+        assert result == "hello world\n"
+        mock_run.assert_called_once_with(
+            ["tmux", "capture-pane", "-t", "tsu-test", "-p", "-S", "-10"],
+            capture_output=True,
+            text=True,
+        )
+
+    def test_read_log(self, mock_metadata):
+        log_dir = mock_metadata / "tmux-logs"
+        log_file = log_dir / "test.log"
+        log_file.write_text("line1\nline2\nline3\n\x1b[31mline4\x1b[0m\n")
+
+        result = tmux_read("test", lines=2, source="log")
+
+        assert result == "line3\nline4\n"
+
+    @patch("tsugite.tools.tmux._session_exists", return_value=False)
+    def test_read_nonexistent_pane(self, mock_exists):
+        with pytest.raises(RuntimeError, match="not found"):
+            tmux_read("nonexistent")
+
+    def test_read_nonexistent_log(self, mock_metadata):
+        with pytest.raises(RuntimeError, match="No log file"):
+            tmux_read("nonexistent", source="log")
+
+    def test_read_invalid_source(self):
+        with pytest.raises(ValueError, match="Invalid source"):
+            tmux_read("test", source="invalid")
+
+    @patch("tsugite.tools.tmux._session_exists", return_value=True)
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_read_clamps_lines(self, mock_run, mock_exists):
+        mock_run.return_value = _make_run_result(stdout="text\n")
+
+        tmux_read("test", lines=99999)
+
+        args = mock_run.call_args.args[0]
+        assert "-5000" in args
+
+
+class TestTmuxSend:
+    @patch("tsugite.tools.tmux._session_exists", return_value=True)
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_send_with_enter(self, mock_run, mock_exists):
+        mock_run.return_value = _make_run_result()
+
+        result = tmux_send("test", "ls -la")
+
+        mock_run.assert_called_once_with(
+            ["tmux", "send-keys", "-t", "tsu-test", "ls -la", "Enter"],
+            capture_output=True,
+            text=True,
+        )
+        assert "command" in result
+
+    @patch("tsugite.tools.tmux._session_exists", return_value=True)
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_send_without_enter(self, mock_run, mock_exists):
+        mock_run.return_value = _make_run_result()
+
+        result = tmux_send("test", "q", enter=False)
+
+        mock_run.assert_called_once_with(
+            ["tmux", "send-keys", "-t", "tsu-test", "q"],
+            capture_output=True,
+            text=True,
+        )
+        assert "keys" in result
+
+    @patch("tsugite.tools.tmux._session_exists", return_value=False)
+    def test_send_nonexistent(self, mock_exists):
+        with pytest.raises(RuntimeError, match="not found"):
+            tmux_send("nonexistent", "hello")
+
+
+class TestListManagedSessions:
+    """Tests for the shared _list_managed_sessions helper used by tmux_list and get_tmux_sessions."""
+
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_filters_by_prefix(self, mock_run, mock_metadata):
+        mock_run.return_value = _make_run_result(
+            stdout="tsu-project1\tbash\nuser-session\tvim\ntsu-project2\tpython3\n"
+        )
+
+        meta_path = mock_metadata / "tmux" / "sessions.json"
+        meta_path.write_text(
+            json.dumps(
+                {
+                    "project1": {"command": "htop", "created_at": "2026-01-01T00:00:00", "log_file": "/tmp/p1.log"},
+                    "project2": {"command": None, "created_at": "2026-01-02T00:00:00", "log_file": "/tmp/p2.log"},
+                }
+            )
+        )
+
+        result = _list_managed_sessions()
+
+        assert len(result) == 2
+        names = [s["name"] for s in result]
+        assert "project1" in names
+        assert "project2" in names
+
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_idle_status_for_shell(self, mock_run, mock_metadata):
+        mock_run.return_value = _make_run_result(stdout="tsu-test\tbash\n")
+
+        result = _list_managed_sessions()
+
+        assert result[0]["status"] == "idle"
+
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_active_status_for_process(self, mock_run, mock_metadata):
+        mock_run.return_value = _make_run_result(stdout="tsu-test\tpython3\n")
+
+        result = _list_managed_sessions()
+
+        assert result[0]["status"] == "active: python3"
+
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_no_server(self, mock_run):
+        mock_run.return_value = _make_run_result(returncode=1, stderr="no server running")
+
+        assert _list_managed_sessions() == []
+
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_no_managed_sessions(self, mock_run, mock_metadata):
+        mock_run.return_value = _make_run_result(stdout="user-session\tbash\n")
+
+        assert _list_managed_sessions() == []
+
+
+class TestTmuxList:
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_list_delegates_to_shared_helper(self, mock_run, mock_metadata):
+        mock_run.return_value = _make_run_result(
+            stdout="tsu-project1\tbash\ntsu-project2\thtop\n"
+        )
+
+        result = tmux_list()
+
+        assert len(result) == 2
+        assert result[0]["status"] == "idle"
+        assert result[1]["status"] == "active: htop"
+
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_list_no_server(self, mock_run):
+        mock_run.return_value = _make_run_result(returncode=1)
+
+        assert tmux_list() == []
+
+
+class TestTmuxKill:
+    @patch("tsugite.tools.tmux._session_exists", return_value=True)
+    @patch("tsugite.tools.tmux.subprocess.run")
+    def test_kill_session(self, mock_run, mock_exists, mock_metadata):
+        mock_run.return_value = _make_run_result()
+
+        meta_path = mock_metadata / "tmux" / "sessions.json"
+        meta_path.write_text(json.dumps({"test": {"command": "htop"}}))
+
+        result = tmux_kill("test")
+
+        mock_run.assert_called_once_with(
+            ["tmux", "kill-session", "-t", "tsu-test"],
+            capture_output=True,
+            text=True,
+        )
+        assert "terminated" in result
+
+        data = json.loads(meta_path.read_text())
+        assert "test" not in data
+
+    @patch("tsugite.tools.tmux._session_exists", return_value=False)
+    def test_kill_nonexistent(self, mock_exists):
+        with pytest.raises(RuntimeError, match="not found"):
+            tmux_kill("nonexistent")
+
+
+class TestGetTmuxSessions:
+    @patch("tsugite.tools.tmux.shutil.which", return_value=None)
+    def test_no_tmux_installed(self, mock_which):
+        assert get_tmux_sessions() == []
+
+    @patch("tsugite.tools.tmux.subprocess.run")
+    @patch("tsugite.tools.tmux.shutil.which", return_value="/usr/bin/tmux")
+    def test_filters_prefix(self, mock_which, mock_run, mock_metadata):
+        mock_run.return_value = _make_run_result(stdout="tsu-myproject\tbash\nother-session\tvim\n")
+
+        result = get_tmux_sessions()
+
+        assert len(result) == 1
+        assert result[0]["name"] == "myproject"
+        assert "created_at" not in result[0]
+        assert "log_file" not in result[0]
+
+    @patch("tsugite.tools.tmux.subprocess.run")
+    @patch("tsugite.tools.tmux.shutil.which", return_value="/usr/bin/tmux")
+    def test_idle_status(self, mock_which, mock_run, mock_metadata):
+        mock_run.return_value = _make_run_result(stdout="tsu-test\tzsh\n")
+
+        result = get_tmux_sessions()
+
+        assert result[0]["status"] == "idle"
+
+    @patch("tsugite.tools.tmux.subprocess.run")
+    @patch("tsugite.tools.tmux.shutil.which", return_value="/usr/bin/tmux")
+    def test_active_status(self, mock_which, mock_run, mock_metadata):
+        mock_run.return_value = _make_run_result(stdout="tsu-test\thtop\n")
+
+        result = get_tmux_sessions()
+
+        assert result[0]["status"] == "active: htop"
+
+    @patch("tsugite.tools.tmux.subprocess.run")
+    @patch("tsugite.tools.tmux.shutil.which", return_value="/usr/bin/tmux")
+    def test_no_server_running(self, mock_which, mock_run):
+        mock_run.return_value = _make_run_result(returncode=1)
+
+        assert get_tmux_sessions() == []

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

@@ -6,6 +6,7 @@ the session storage system.
 
 import os
 import sys
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -76,6 +77,7 @@ def save_run_to_history(
     channel_metadata: Optional[dict] = None,
     duration_ms: Optional[int] = None,
     claude_code_session_id: Optional[str] = None,
+    claude_code_compacted: bool = False,
 ) -> Optional[str]:
     """Save a single agent run to history.
 
@@ -143,10 +145,12 @@ def save_run_to_history(
 
         functions_called = _extract_functions_called(execution_steps) if execution_steps else []
 
-        # Merge claude_code_session_id into metadata if present
+        # Merge claude_code session info into metadata if present
         metadata = dict(channel_metadata) if channel_metadata else {}
         if claude_code_session_id:
             metadata["claude_code_session_id"] = claude_code_session_id
+        if claude_code_compacted:
+            metadata["claude_code_compacted"] = True
 
         # Write accumulated hook execution records before the turn
         from tsugite.hooks import drain_all_executions
@@ -212,6 +216,57 @@ def _extract_functions_called(execution_steps: list) -> List[str]:
     return sorted(list(functions))
 
 
+@dataclass
+class ClaudeCodeSessionInfo:
+    """Info about the Claude Code session for a conversation."""
+
+    session_id: str
+    compacted: bool = False
+
+
+def get_claude_code_session_info(conversation_id: str) -> Optional["ClaudeCodeSessionInfo"]:
+    """Get the Claude Code session ID and compaction state from conversation history.
+
+    Returns None if the session was compacted by Tsugite (Claude Code session would
+    be stale) or if no session ID is found (e.g. non-claude_code model was used).
+    """
+    try:
+        from tsugite.history import SessionStorage, Turn
+        from tsugite.history.models import CompactionSummary
+
+        session_path = get_history_dir() / f"{conversation_id}.jsonl"
+        if not session_path.exists():
+            return None
+
+        storage = SessionStorage(session_path)
+        records = storage.load_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):
+                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 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
+
+
 def get_latest_conversation() -> Optional[str]:
     """Get the most recent conversation/session ID.
 

{tsugite_cli-0.8.0 → tsugite_cli-0.9.1}/tsugite/agent_runner/models.py

@@ -40,6 +40,7 @@ class AgentExecutionResult(BaseModel):
         default_factory=list
     )  # List of Attachment objects (using Any for Pydantic compatibility)
     claude_code_session_id: Optional[str] = None
+    claude_code_compacted: bool = False
     context_window: Optional[int] = None
 
     def __str__(self) -> str: