cc-context-stats 1.7.0 → 1.8.1

package/tests/python/test_explain.py

@@ -1,177 +0,0 @@
-"""Tests for the context-stats explain command."""
-
-import json
-import subprocess
-import sys
-from pathlib import Path
-
-PROJECT_ROOT = Path(__file__).parent.parent.parent
-FIXTURES_DIR = PROJECT_ROOT / "tests" / "fixtures" / "json"
-
-
-class TestExplainCommand:
-    """Tests for `context-stats explain`."""
-
-    def _run_explain(self, input_data, extra_args=None):
-        """Run context-stats explain with JSON input and return stdout."""
-        cmd = [sys.executable, "-m", "claude_statusline.cli.context_stats", "explain"]
-        if extra_args:
-            cmd.extend(extra_args)
-        result = subprocess.run(
-            cmd,
-            input=json.dumps(input_data),
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
-        return result
-
-    def test_explain_shows_model(self):
-        data = {"model": {"display_name": "Opus 4.5", "id": "claude-opus-4-5"}}
-        result = self._run_explain(data)
-        assert result.returncode == 0
-        assert "Opus 4.5" in result.stdout
-        assert "claude-opus-4-5" in result.stdout
-
-    def test_explain_shows_workspace(self):
-        data = {
-            "workspace": {
-                "current_dir": "/home/user/project",
-                "project_dir": "/home/user/project",
-            }
-        }
-        result = self._run_explain(data)
-        assert result.returncode == 0
-        assert "/home/user/project" in result.stdout
-
-    def test_explain_shows_context_window(self):
-        data = {
-            "context_window": {
-                "context_window_size": 200000,
-                "current_usage": {
-                    "input_tokens": 50000,
-                    "cache_creation_input_tokens": 10000,
-                    "cache_read_input_tokens": 20000,
-                },
-            }
-        }
-        result = self._run_explain(data)
-        assert result.returncode == 0
-        assert "200,000" in result.stdout
-        assert "50,000" in result.stdout
-        assert "context_used" in result.stdout
-
-    def test_explain_shows_cost(self):
-        data = {
-            "cost": {
-                "total_cost_usd": 0.1234,
-                "total_lines_added": 100,
-                "total_lines_removed": 50,
-            }
-        }
-        result = self._run_explain(data)
-        assert result.returncode == 0
-        assert "$0.1234" in result.stdout
-
-    def test_explain_shows_session(self):
-        data = {"session_id": "abc-123", "version": "2.0.0"}
-        result = self._run_explain(data)
-        assert result.returncode == 0
-        assert "abc-123" in result.stdout
-        assert "2.0.0" in result.stdout
-
-    def test_explain_shows_absent_fields(self):
-        data = {}
-        result = self._run_explain(data)
-        assert result.returncode == 0
-        assert "(absent)" in result.stdout
-
-    def test_explain_shows_raw_json(self):
-        data = {"model": {"display_name": "Test"}}
-        result = self._run_explain(data)
-        assert result.returncode == 0
-        assert "Raw JSON" in result.stdout
-        assert '"display_name": "Test"' in result.stdout
-
-    def test_explain_shows_config(self):
-        data = {}
-        result = self._run_explain(data)
-        assert result.returncode == 0
-        assert "Active Config" in result.stdout
-
-    def test_explain_with_full_fixture(self):
-        with open(FIXTURES_DIR / "valid_full.json") as f:
-            data = json.load(f)
-        result = self._run_explain(data)
-        assert result.returncode == 0
-        assert "Opus 4.5" in result.stdout
-        assert "test-session-123" in result.stdout
-
-    def test_explain_invalid_json_fails(self):
-        result = subprocess.run(
-            [sys.executable, "-m", "claude_statusline.cli.context_stats", "explain"],
-            input="not valid json",
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
-        assert result.returncode == 1
-        assert "invalid JSON" in result.stderr
-
-    def test_explain_shows_derived_free_tokens(self):
-        data = {
-            "context_window": {
-                "context_window_size": 200000,
-                "current_usage": {
-                    "input_tokens": 50000,
-                    "cache_creation_input_tokens": 10000,
-                    "cache_read_input_tokens": 20000,
-                },
-            }
-        }
-        result = self._run_explain(data)
-        assert result.returncode == 0
-        # 200000 - (50000+10000+20000) = 120000
-        assert "120,000" in result.stdout
-        assert "60.0%" in result.stdout
-
-    def test_explain_no_color_flag(self):
-        data = {"model": {"display_name": "Test"}}
-        result = subprocess.run(
-            [sys.executable, "-m", "claude_statusline.cli.context_stats", "explain", "--no-color"],
-            input=json.dumps(data),
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
-        assert result.returncode == 0
-        assert "Test" in result.stdout
-        # No ANSI escape codes when --no-color is passed
-        assert "\x1b[" not in result.stdout
-
-    def test_explain_shows_vim_mode(self):
-        data = {"vim": {"mode": "NORMAL"}}
-        result = self._run_explain(data)
-        assert result.returncode == 0
-        assert "NORMAL" in result.stdout
-        assert "Extensions" in result.stdout
-
-    def test_explain_shows_agent(self):
-        data = {"agent": {"name": "my-agent"}}
-        result = self._run_explain(data)
-        assert result.returncode == 0
-        assert "my-agent" in result.stdout
-        assert "Extensions" in result.stdout
-
-    def test_explain_shows_output_style(self):
-        data = {"output_style": {"name": "concise"}}
-        result = self._run_explain(data)
-        assert result.returncode == 0
-        assert "concise" in result.stdout
-        assert "Extensions" in result.stdout
-
-    def test_explain_no_extensions_section_when_absent(self):
-        data = {"model": {"display_name": "Test"}}
-        result = self._run_explain(data)
-        assert result.returncode == 0
-        assert "Extensions" not in result.stdout

package/tests/python/test_icons.py

@@ -1,152 +0,0 @@
-"""Tests for activity tier detection."""
-
-import time
-
-from claude_statusline.core.state import StateEntry
-from claude_statusline.graphs.statistics import detect_spike
-from claude_statusline.ui.icons import (
-    ActivityTier,
-    get_activity_tier,
-    get_tier_label,
-)
-
-
-def _make_entry(
-    timestamp: int = 0,
-    current_input: int = 1000,
-    cache_creation: int = 0,
-    cache_read: int = 0,
-    context_window_size: int = 200_000,
-) -> StateEntry:
-    """Helper to create a StateEntry for testing."""
-    return StateEntry(
-        timestamp=timestamp,
-        total_input_tokens=current_input,
-        total_output_tokens=0,
-        current_input_tokens=current_input,
-        current_output_tokens=0,
-        cache_creation=cache_creation,
-        cache_read=cache_read,
-        cost_usd=0.0,
-        lines_added=0,
-        lines_removed=0,
-        session_id="test",
-        model_id="test-model",
-        workspace_project_dir="/tmp/test",
-        context_window_size=context_window_size,
-    )
-
-
-class TestDetectSpike:
-    """Tests for spike detection logic."""
-
-    def test_empty_deltas(self):
-        assert detect_spike([], 200_000) is False
-
-    def test_no_spike_small_delta(self):
-        deltas = [1000, 1200, 1100, 900, 1000]
-        assert detect_spike(deltas, 200_000) is False
-
-    def test_spike_absolute_threshold(self):
-        """Delta > 15% of context window is a spike."""
-        deltas = [1000, 1200, 1100, 900, 35_000]
-        assert detect_spike(deltas, 200_000) is True
-
-    def test_spike_relative_threshold(self):
-        """Delta > 3x rolling average is a spike."""
-        deltas = [100, 100, 100, 100, 500]
-        assert detect_spike(deltas, 200_000) is True
-
-    def test_no_spike_when_all_similar(self):
-        deltas = [1000, 1000, 1000, 1000, 1000]
-        assert detect_spike(deltas, 200_000) is False
-
-    def test_single_delta_no_spike(self):
-        """Single delta can't be a relative spike (no average to compare)."""
-        deltas = [1000]
-        assert detect_spike(deltas, 200_000) is False
-
-    def test_spike_with_zero_context_window(self):
-        """Only relative threshold applies when context_window is 0."""
-        deltas = [100, 100, 100, 100, 500]
-        assert detect_spike(deltas, 0) is True
-
-
-class TestActivityTier:
-    """Tests for activity tier determination."""
-
-    def test_idle_with_no_entries(self):
-        assert get_activity_tier([], 200_000) == ActivityTier.IDLE
-
-    def test_idle_with_single_entry(self):
-        entry = _make_entry(timestamp=int(time.time()))
-        assert get_activity_tier([entry], 200_000) == ActivityTier.IDLE
-
-    def test_idle_when_stale(self):
-        """Entries older than 30s should be idle."""
-        old_time = int(time.time()) - 60
-        entries = [
-            _make_entry(timestamp=old_time, current_input=1000),
-            _make_entry(timestamp=old_time + 5, current_input=2000),
-        ]
-        assert get_activity_tier(entries, 200_000) == ActivityTier.IDLE
-
-    def test_low_activity(self):
-        """Small delta (<2% of window) = low."""
-        now = int(time.time())
-        entries = [
-            _make_entry(timestamp=now - 5, current_input=1000),
-            _make_entry(timestamp=now, current_input=2000),  # delta=1000, 0.5% of 200k
-        ]
-        assert get_activity_tier(entries, 200_000) == ActivityTier.LOW
-
-    def test_medium_activity(self):
-        """Delta 2-5% of window = medium."""
-        now = int(time.time())
-        entries = [
-            _make_entry(timestamp=now - 5, current_input=1000),
-            _make_entry(timestamp=now, current_input=7000),  # delta=6000, 3% of 200k
-        ]
-        assert get_activity_tier(entries, 200_000) == ActivityTier.MEDIUM
-
-    def test_high_activity(self):
-        """Delta 5-15% of window = high."""
-        now = int(time.time())
-        entries = [
-            _make_entry(timestamp=now - 5, current_input=1000),
-            _make_entry(timestamp=now, current_input=21000),  # delta=20000, 10% of 200k
-        ]
-        assert get_activity_tier(entries, 200_000) == ActivityTier.HIGH
-
-    def test_spike_activity(self):
-        """Delta > 15% of window = spike."""
-        now = int(time.time())
-        entries = [
-            _make_entry(timestamp=now - 5, current_input=1000),
-            _make_entry(timestamp=now, current_input=41000),  # delta=40000, 20% of 200k
-        ]
-        assert get_activity_tier(entries, 200_000) == ActivityTier.SPIKE
-
-    def test_zero_delta_is_idle(self):
-        """No token change = idle (even if recent)."""
-        now = int(time.time())
-        entries = [
-            _make_entry(timestamp=now - 5, current_input=1000),
-            _make_entry(timestamp=now, current_input=1000),  # delta=0
-        ]
-        assert get_activity_tier(entries, 200_000) == ActivityTier.IDLE
-
-
-class TestGetTierLabel:
-    """Tests for tier labels."""
-
-    def test_all_tiers_have_labels(self):
-        for tier in ActivityTier:
-            label = get_tier_label(tier)
-            assert len(label) > 0
-
-    def test_idle_label(self):
-        assert get_tier_label(ActivityTier.IDLE) == "Idle"
-
-    def test_spike_label(self):
-        assert get_tier_label(ActivityTier.SPIKE) == "Spike!"

package/tests/python/test_layout.py

@@ -1,127 +0,0 @@
-"""Tests for layout helpers (visible_width, get_terminal_width, fit_to_width)."""
-
-from unittest.mock import patch
-
-from claude_statusline.formatters.layout import (
-    fit_to_width,
-    get_terminal_width,
-    visible_width,
-)
-
-
-class TestVisibleWidth:
-    """Tests for visible_width()."""
-
-    def test_plain_text(self):
-        assert visible_width("hello") == 5
-
-    def test_ansi_colored_string(self):
-        s = "\033[0;32mgreen\033[0m"
-        assert visible_width(s) == 5
-
-    def test_multiple_ansi_codes(self):
-        s = "\033[2m[\033[0m\033[0;34mdir\033[0m"
-        assert visible_width(s) == 4  # [dir
-
-    def test_empty_string(self):
-        assert visible_width("") == 0
-
-    def test_unicode_icons(self):
-        assert visible_width("\u25cb") == 1  # ○
-        assert visible_width("\u26a1") == 1  # ⚡
-
-    def test_ansi_with_semicolons(self):
-        s = "\033[1;31;42mtext\033[0m"
-        assert visible_width(s) == 4
-
-
-class TestGetTerminalWidth:
-    """Tests for get_terminal_width()."""
-
-    def test_fallback_to_200_when_no_columns_env(self):
-        """When COLUMNS is not set and shutil returns 80, use 200 (Claude Code subprocess)."""
-        with (
-            patch("claude_statusline.formatters.layout.shutil.get_terminal_size") as mock,
-            patch.dict("os.environ", {}, clear=False),
-        ):
-            # Remove COLUMNS if present
-            import os
-
-            os.environ.pop("COLUMNS", None)
-            mock.return_value = type("Size", (), {"columns": 80})()
-            assert get_terminal_width() == 200
-
-    def test_respects_columns_env_80(self):
-        """When COLUMNS=80 is explicitly set, trust it."""
-        with (
-            patch("claude_statusline.formatters.layout.shutil.get_terminal_size") as mock,
-            patch.dict("os.environ", {"COLUMNS": "80"}),
-        ):
-            mock.return_value = type("Size", (), {"columns": 80})()
-            assert get_terminal_width() == 80
-
-    def test_custom_width(self):
-        with patch("claude_statusline.formatters.layout.shutil.get_terminal_size") as mock:
-            mock.return_value = type("Size", (), {"columns": 120})()
-            assert get_terminal_width() == 120
-
-
-class TestFitToWidth:
-    """Tests for fit_to_width()."""
-
-    def test_all_parts_fit(self):
-        parts = ["base", " | git", " | ctx"]
-        result = fit_to_width(parts, 80)
-        assert result == "base | git | ctx"
-
-    def test_drops_lowest_priority(self):
-        parts = ["base", " | git", " | ctx", " session-uuid-here"]
-        result = fit_to_width(parts, 25)
-        assert "base" in result
-        assert "session-uuid-here" not in result
-
-    def test_base_always_included(self):
-        parts = ["very-long-base-string-that-exceeds-width"]
-        result = fit_to_width(parts, 10)
-        assert result == "very-long-base-string-that-exceeds-width"
-
-    def test_empty_parts_skipped(self):
-        parts = ["base", "", " | ctx", "", " session"]
-        result = fit_to_width(parts, 30)
-        assert result == "base | ctx session"
-
-    def test_exact_boundary(self):
-        parts = ["12345", "67890"]
-        result = fit_to_width(parts, 10)
-        assert result == "1234567890"
-
-    def test_one_char_over_boundary(self):
-        parts = ["12345", "678901"]
-        result = fit_to_width(parts, 10)
-        assert result == "12345"
-
-    def test_empty_parts_list(self):
-        assert fit_to_width([], 80) == ""
-
-    def test_realistic_ansi_strings(self):
-        base = "\033[2m[Claude]\033[0m \033[0;34mdir\033[0m"
-        git = " | \033[0;35mmain\033[0m"
-        ctx = " | \033[0;32m150.0k free (75.0%)\033[0m"
-        session = " \033[2mtest-session-uuid-1234\033[0m"
-
-        # base=[Claude] dir = 12, git= | main = 7, ctx= | 150.0k free (75.0%) = 22,
-        # session= test-session-uuid-1234 = 23 => total = 64
-        result = fit_to_width([base, git, ctx, session], 80)
-        assert visible_width(result) == 64
-
-        # With tight width, session should be dropped
-        result = fit_to_width([base, git, ctx, session], 50)
-        assert "test-session-uuid-1234" not in result
-        assert visible_width(result) <= 50
-
-    def test_priority_order_preserved(self):
-        parts = ["base", " A", " B", " C", " D"]
-        # base=4, A=2, B=2, C=2, D=2 => total 12
-        # max_width=8 => base + A + B fits (8), C dropped, D dropped
-        result = fit_to_width(parts, 8)
-        assert result == "base A B"

package/tests/python/test_state_rotation_validation.py

@@ -1,232 +0,0 @@
-"""Tests for state file rotation and session ID validation."""
-
-import re
-import subprocess
-import sys
-
-import pytest
-
-from claude_statusline.core.state import StateFile, _validate_session_id
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _make_csv_line(index: int) -> str:
-    """Generate a deterministic CSV state line for a given index."""
-    return (
-        f"{1710288000 + index},100,200,300,400,500,600,0.01,"
-        f"10,5,sess-{index},model,/tmp/proj,200000"
-    )
-
-
-# ---------------------------------------------------------------------------
-# State File Rotation
-# ---------------------------------------------------------------------------
-
-
-class TestStateFileRotation:
-    """Tests for _maybe_rotate() in StateFile."""
-
-    def test_below_threshold_no_rotation(self, tmp_path, monkeypatch):
-        """File with fewer than 10,000 lines is not rotated."""
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile("test-session")
-        # Write 9,999 lines
-        lines = [_make_csv_line(i) + "\n" for i in range(9_999)]
-        sf.file_path.write_text("".join(lines))
-
-        sf._maybe_rotate()
-
-        result_lines = sf.file_path.read_text().splitlines()
-        assert len(result_lines) == 9_999
-
-    def test_at_threshold_no_rotation(self, tmp_path, monkeypatch):
-        """File with exactly 10,000 lines is not rotated."""
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile("test-session")
-        lines = [_make_csv_line(i) + "\n" for i in range(10_000)]
-        sf.file_path.write_text("".join(lines))
-
-        sf._maybe_rotate()
-
-        result_lines = sf.file_path.read_text().splitlines()
-        assert len(result_lines) == 10_000
-
-    def test_exceeds_threshold_truncates_to_5000(self, tmp_path, monkeypatch):
-        """File with 10,001 lines is truncated to 5,000."""
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile("test-session")
-        lines = [_make_csv_line(i) + "\n" for i in range(10_001)]
-        sf.file_path.write_text("".join(lines))
-
-        sf._maybe_rotate()
-
-        result_lines = sf.file_path.read_text().splitlines()
-        assert len(result_lines) == 5_000
-
-    def test_retained_lines_are_most_recent(self, tmp_path, monkeypatch):
-        """After rotation, the retained lines are the last 5,000 of the original."""
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile("test-session")
-        total = 10_001
-        lines = [_make_csv_line(i) + "\n" for i in range(total)]
-        sf.file_path.write_text("".join(lines))
-
-        sf._maybe_rotate()
-
-        result_lines = sf.file_path.read_text().splitlines()
-        # First retained line should be the one at index (total - 5000) = 5001
-        assert f"sess-{total - 5000}" in result_lines[0]
-        # Last retained line should be the last original line
-        assert f"sess-{total - 1}" in result_lines[-1]
-
-    def test_rotation_via_append_entry(self, tmp_path, monkeypatch):
-        """append_entry triggers rotation when threshold is exceeded."""
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile("test-session")
-        # Write exactly 10,000 lines (at threshold, no rotation yet)
-        lines = [_make_csv_line(i) + "\n" for i in range(10_000)]
-        sf.file_path.write_text("".join(lines))
-
-        # Import StateEntry to create a valid entry
-        from claude_statusline.core.state import StateEntry
-
-        entry = StateEntry(
-            timestamp=1710298000,
-            total_input_tokens=100,
-            total_output_tokens=200,
-            current_input_tokens=300,
-            current_output_tokens=400,
-            cache_creation=500,
-            cache_read=600,
-            cost_usd=0.01,
-            lines_added=10,
-            lines_removed=5,
-            session_id="test-session",
-            model_id="model",
-            workspace_project_dir="/tmp/proj",
-            context_window_size=200000,
-        )
-        sf.append_entry(entry)
-
-        # Now file had 10,001 lines -> should have been rotated to 5,000
-        result_lines = sf.file_path.read_text().splitlines()
-        assert len(result_lines) == 5_000
-
-    def test_no_temp_files_left_after_rotation(self, tmp_path, monkeypatch):
-        """No .tmp files remain after successful rotation."""
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile("test-session")
-        lines = [_make_csv_line(i) + "\n" for i in range(10_001)]
-        sf.file_path.write_text("".join(lines))
-
-        sf._maybe_rotate()
-
-        tmp_files = list(tmp_path.glob("*.tmp"))
-        assert tmp_files == []
-
-
-# ---------------------------------------------------------------------------
-# Session ID Validation
-# ---------------------------------------------------------------------------
-
-
-class TestSessionIdValidation:
-    """Tests for _validate_session_id and StateFile constructor validation."""
-
-    def test_reject_forward_slash(self):
-        with pytest.raises(ValueError, match="/"):
-            _validate_session_id("../../etc/passwd")
-
-    def test_reject_backslash(self):
-        with pytest.raises(ValueError, match=re.escape("\\")):
-            _validate_session_id("..\\..\\etc\\passwd")
-
-    def test_reject_dot_dot(self):
-        with pytest.raises(ValueError, match=r"\.\."):
-            _validate_session_id("..hidden")
-
-    def test_reject_null_byte(self):
-        with pytest.raises(ValueError):
-            _validate_session_id("session\0id")
-
-    def test_accept_valid_uuid(self):
-        _validate_session_id("abc-123-def-456")  # Should not raise
-
-    def test_accept_hyphens_underscores(self):
-        _validate_session_id("my_session-id_123")  # Should not raise
-
-    def test_accept_alphanumeric(self):
-        _validate_session_id("abcdef1234567890")  # Should not raise
-
-    def test_statefile_rejects_invalid_session(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        with pytest.raises(ValueError):
-            StateFile("../../etc/passwd")
-
-    def test_statefile_accepts_none_session(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile(None)  # Should not raise
-        assert sf.session_id is None
-
-    def test_statefile_accepts_valid_session(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile("valid-session-123")  # Should not raise
-        assert sf.session_id == "valid-session-123"
-
-
-# ---------------------------------------------------------------------------
-# CLI Session ID Rejection (subprocess test)
-# ---------------------------------------------------------------------------
-
-
-class TestCliSessionIdRejection:
-    """Test that context-stats CLI rejects invalid session IDs."""
-
-    def test_cli_rejects_path_traversal(self):
-        result = subprocess.run(
-            [sys.executable, "-m", "claude_statusline.cli.context_stats", "../../etc/passwd"],
-            capture_output=True,
-            text=True,
-        )
-        assert result.returncode != 0
-        assert "Invalid session_id" in result.stderr
-
-    def test_cli_rejects_backslash(self):
-        result = subprocess.run(
-            [sys.executable, "-m", "claude_statusline.cli.context_stats", "test\\bad"],
-            capture_output=True,
-            text=True,
-        )
-        assert result.returncode != 0
-        assert "Invalid session_id" in result.stderr