cc-context-stats 1.3.0 → 1.5.0

package/src/claude_statusline/ui/waiting.py

@@ -0,0 +1,62 @@
+"""Rotating waiting text for active sessions."""
+
+from __future__ import annotations
+
+import time
+
+from claude_statusline.core.state import StateEntry
+
+WAITING_MESSAGES = [
+    "Thinking...",
+    "Cooking...",
+    "Crunching tokens...",
+    "Compiling plan...",
+    "Running steps...",
+    "Processing...",
+    "Working on it...",
+    "Analyzing...",
+]
+
+# Static message for reduced-motion mode
+STATIC_MESSAGE = "Working..."
+
+
+def get_waiting_text(cycle_index: int, reduced_motion: bool = False) -> str:
+    """Get the current waiting text based on the refresh cycle.
+
+    Messages rotate every 2 cycles (approximately every 4 seconds at 2s refresh).
+
+    Args:
+        cycle_index: The current watch-mode refresh counter
+        reduced_motion: If True, return a static message instead of rotating
+
+    Returns:
+        A waiting message string
+    """
+    if reduced_motion:
+        return STATIC_MESSAGE
+
+    # Rotate every 2 cycles to keep it readable
+    message_index = (cycle_index // 2) % len(WAITING_MESSAGES)
+    return WAITING_MESSAGES[message_index]
+
+
+def is_active(entries: list[StateEntry], timeout: int = 30) -> bool:
+    """Determine if the session is currently active.
+
+    A session is considered active if the most recent state entry
+    was recorded within `timeout` seconds of the current time.
+
+    Args:
+        entries: List of StateEntry objects (chronological order)
+        timeout: Seconds since last entry to consider session active (default: 30)
+
+    Returns:
+        True if the session appears to be actively running
+    """
+    if not entries:
+        return False
+
+    now = int(time.time())
+    last_timestamp = entries[-1].timestamp
+    return (now - last_timestamp) <= timeout

package/tests/bash/test_statusline_full.bats

@@ -107,3 +107,33 @@ teardown() {
     run bash "$SCRIPT" <<< "$input"
     [ "$status" -eq 0 ]
 }
+
+# Width truncation tests
+
+strip_ansi() {
+    printf '%s' "$1" | sed -e $'s/\033\[[0-9;]*m//g' -e 's/\\033\[[0-9;]*m//g'
+}
+
+@test "output fits within 80 columns" {
+    input='{"model":{"display_name":"Claude"},"workspace":{"current_dir":"/tmp/proj","project_dir":"/tmp/proj"},"context_window":{"context_window_size":200000,"current_usage":{"input_tokens":10000,"cache_creation_input_tokens":500,"cache_read_input_tokens":200}},"session_id":"aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"}'
+    result=$(COLUMNS=80 bash "$SCRIPT" <<< "$input")
+    visible=$(strip_ansi "$result")
+    len=$(printf '%s' "$visible" | wc -m | tr -d ' ')
+    [ "$len" -le 80 ]
+}
+
+@test "narrow terminal still shows model and directory" {
+    input='{"model":{"display_name":"Claude"},"workspace":{"current_dir":"/tmp/proj","project_dir":"/tmp/proj"},"context_window":{"context_window_size":200000,"current_usage":{"input_tokens":10000,"cache_creation_input_tokens":500,"cache_read_input_tokens":200}}}'
+    result=$(COLUMNS=40 bash "$SCRIPT" <<< "$input")
+    visible=$(strip_ansi "$result")
+    len=$(printf '%s' "$visible" | wc -m | tr -d ' ')
+    [ "$len" -le 40 ]
+    [[ "$visible" == *"Claude"* ]]
+    [[ "$visible" == *"proj"* ]]
+}
+
+@test "wide terminal shows session_id" {
+    input='{"model":{"display_name":"Claude"},"workspace":{"current_dir":"/tmp/proj","project_dir":"/tmp/proj"},"session_id":"test-wide-session-uuid"}'
+    result=$(COLUMNS=200 bash "$SCRIPT" <<< "$input")
+    [[ "$result" == *"test-wide-session-uuid"* ]]
+}

package/tests/node/statusline.test.js

@@ -5,14 +5,23 @@ const fs = require('fs');
 const SCRIPT_PATH = path.join(__dirname, '..', '..', 'scripts', 'statusline.js');
 const FIXTURES_DIR = path.join(__dirname, '..', 'fixtures', 'json');
 
+/**
+ * Strip ANSI escape sequences from a string
+ */
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
 /**
  * Run the statusline.js script with the given input data
  * @param {Object|string} inputData - JSON input or string
+ * @param {Object} [envOverrides] - Optional environment variable overrides
  * @returns {Promise<{stdout: string, stderr: string, code: number}>}
  */
-function runScript(inputData) {
+function runScript(inputData, envOverrides) {
     return new Promise((resolve, reject) => {
-        const child = spawn('node', [SCRIPT_PATH]);
+        const env = { ...process.env, ...envOverrides };
+        const child = spawn('node', [SCRIPT_PATH], { env });
         let stdout = '';
         let stderr = '';
 
@@ -186,7 +195,7 @@ describe('statusline.js', () => {
                 ...sampleInput,
                 session_id: 'test-session-abc123',
             };
-            const result = await runScript(inputWithSession);
+            const result = await runScript(inputWithSession, { COLUMNS: '200' });
             expect(result.code).toBe(0);
             expect(result.stdout).toContain('test-session-abc123');
         });
@@ -196,4 +205,36 @@ describe('statusline.js', () => {
             expect(result.code).toBe(0);
         });
     });
+
+    describe('Width truncation', () => {
+        test('output fits 80 columns', async () => {
+            const inputWithSession = {
+                ...sampleInput,
+                session_id: 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
+            };
+            const result = await runScript(inputWithSession, { COLUMNS: '80' });
+            expect(result.code).toBe(0);
+            const visible = stripAnsi(result.stdout);
+            expect(visible.length).toBeLessThanOrEqual(80);
+        });
+
+        test('narrow terminal drops parts', async () => {
+            const result = await runScript(sampleInput, { COLUMNS: '40' });
+            expect(result.code).toBe(0);
+            const visible = stripAnsi(result.stdout);
+            expect(visible.length).toBeLessThanOrEqual(40);
+            expect(visible).toContain('Claude 3.5 Sonnet');
+            expect(visible).toContain('myproject');
+        });
+
+        test('wide terminal shows all', async () => {
+            const inputWithSession = {
+                ...sampleInput,
+                session_id: 'test-wide-session-uuid',
+            };
+            const result = await runScript(inputWithSession, { COLUMNS: '200' });
+            expect(result.code).toBe(0);
+            expect(result.stdout).toContain('test-wide-session-uuid');
+        });
+    });
 });

package/tests/python/test_icons.py

@@ -0,0 +1,152 @@
+"""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

@@ -0,0 +1,110 @@
+"""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_80(self):
+        with patch("claude_statusline.formatters.layout.shutil.get_terminal_size") as mock:
+            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_statusline.py

@@ -1,24 +1,42 @@
 """Tests for statusline.py script."""
 
 import json
+import os
+import re
 import subprocess
 import sys
 from pathlib import Path
 
 SCRIPT_PATH = Path(__file__).parent.parent.parent / "scripts" / "statusline.py"
 
+_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
 
-def run_script(input_data: dict) -> tuple[str, int]:
+
+def strip_ansi(s: str) -> str:
+    """Strip ANSI escape sequences from a string."""
+    return _ANSI_RE.sub("", s)
+
+
+def run_script(input_data: dict, env_overrides: dict | None = None) -> tuple[str, int]:
     """Run the statusline.py script with the given input.
 
+    Args:
+        input_data: JSON-serializable dict to pass as stdin.
+        env_overrides: Optional dict of environment variable overrides.
+
     Returns:
         Tuple of (stdout, return_code)
     """
+    env = os.environ.copy()
+    env["PYTHONUTF8"] = "1"
+    if env_overrides:
+        env.update(env_overrides)
     result = subprocess.run(
         [sys.executable, str(SCRIPT_PATH)],
         input=json.dumps(input_data),
         capture_output=True,
         text=True,
+        env=env,
     )
     return result.stdout.strip(), result.returncode
 
@@ -32,7 +50,7 @@ class TestStatuslineScript:
 
     def test_script_is_python(self):
         """Script should have Python shebang."""
-        content = SCRIPT_PATH.read_text()
+        content = SCRIPT_PATH.read_text(encoding="utf-8")
         assert content.startswith("#!/usr/bin/env python3")
 
     def test_outputs_model_name(self, sample_input):
@@ -68,22 +86,28 @@ class TestStatuslineScript:
 
     def test_handles_invalid_json(self):
         """Should handle invalid JSON gracefully."""
+        env = os.environ.copy()
+        env["PYTHONUTF8"] = "1"
         result = subprocess.run(
             [sys.executable, str(SCRIPT_PATH)],
             input="invalid json",
             capture_output=True,
             text=True,
+            env=env,
         )
         assert result.returncode == 0
         assert "Claude" in result.stdout
 
     def test_handles_empty_input(self):
         """Should handle empty input gracefully."""
+        env = os.environ.copy()
+        env["PYTHONUTF8"] = "1"
         result = subprocess.run(
             [sys.executable, str(SCRIPT_PATH)],
             input="",
             capture_output=True,
             text=True,
+            env=env,
         )
         assert result.returncode == 0
 
@@ -141,7 +165,7 @@ class TestSessionDisplay:
     def test_shows_session_id_by_default(self, sample_input):
         """Should show session_id by default (show_session=true)."""
         sample_input["session_id"] = "test-session-12345"
-        output, code = run_script(sample_input)
+        output, code = run_script(sample_input, {"COLUMNS": "200"})
         assert code == 0
         assert "test-session-12345" in output
 
@@ -152,3 +176,38 @@ class TestSessionDisplay:
             del sample_input["session_id"]
         output, code = run_script(sample_input)
         assert code == 0
+
+
+class TestWidthTruncation:
+    """Tests for width truncation to fit terminal width."""
+
+    def test_output_fits_80_columns(self, sample_input):
+        """Output should fit within 80 columns."""
+        sample_input["session_id"] = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+        output, code = run_script(sample_input, {"COLUMNS": "80"})
+        assert code == 0
+        visible = strip_ansi(output)
+        assert len(visible) <= 80
+
+    def test_output_fits_narrow_terminal(self, sample_input):
+        """Output should fit within 40 columns and still show model+dir."""
+        output, code = run_script(sample_input, {"COLUMNS": "40"})
+        assert code == 0
+        visible = strip_ansi(output)
+        assert len(visible) <= 40
+        assert "Claude 3.5 Sonnet" in visible
+        assert "myproject" in visible
+
+    def test_wide_terminal_shows_all(self, sample_input):
+        """Wide terminal should show session_id."""
+        sample_input["session_id"] = "test-wide-session-uuid"
+        output, code = run_script(sample_input, {"COLUMNS": "200"})
+        assert code == 0
+        assert "test-wide-session-uuid" in output
+
+    def test_full_input_truncated(self, valid_full_input):
+        """Full input with all features should fit within 80 columns."""
+        output, code = run_script(valid_full_input, {"COLUMNS": "80"})
+        assert code == 0
+        visible = strip_ansi(output)
+        assert len(visible) <= 80

package/tests/python/test_waiting.py

@@ -0,0 +1,127 @@
+"""Tests for rotating waiting text and activity detection."""
+
+import time
+
+from claude_statusline.core.state import StateEntry
+from claude_statusline.ui.waiting import (
+    STATIC_MESSAGE,
+    WAITING_MESSAGES,
+    get_waiting_text,
+    is_active,
+)
+
+
+def _make_entry(timestamp: int = 0) -> StateEntry:
+    """Helper to create a StateEntry for testing."""
+    return StateEntry(
+        timestamp=timestamp,
+        total_input_tokens=1000,
+        total_output_tokens=0,
+        current_input_tokens=1000,
+        current_output_tokens=0,
+        cache_creation=0,
+        cache_read=0,
+        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=200_000,
+    )
+
+
+class TestGetWaitingText:
+    """Tests for rotating waiting text."""
+
+    def test_returns_string(self):
+        text = get_waiting_text(0)
+        assert isinstance(text, str)
+        assert len(text) > 0
+
+    def test_rotates_every_two_cycles(self):
+        """Messages should change every 2 cycles."""
+        text_0 = get_waiting_text(0)
+        text_1 = get_waiting_text(1)
+        text_2 = get_waiting_text(2)
+
+        # Cycle 0 and 1 should be the same (same message index)
+        assert text_0 == text_1
+        # Cycle 2 should be different (next message)
+        assert text_0 != text_2
+
+    def test_wraps_around(self):
+        """Should cycle back to the first message."""
+        total_messages = len(WAITING_MESSAGES)
+        # After going through all messages (2 cycles each), should wrap
+        first = get_waiting_text(0)
+        wrapped = get_waiting_text(total_messages * 2)
+        assert first == wrapped
+
+    def test_all_messages_reachable(self):
+        """Every message should appear at some cycle."""
+        seen = set()
+        for i in range(len(WAITING_MESSAGES) * 2):
+            seen.add(get_waiting_text(i))
+        assert seen == set(WAITING_MESSAGES)
+
+    def test_reduced_motion_returns_static(self):
+        """With reduced_motion=True, always return static message."""
+        for i in range(10):
+            text = get_waiting_text(i, reduced_motion=True)
+            assert text == STATIC_MESSAGE
+
+    def test_reduced_motion_consistent(self):
+        """Static message should be the same regardless of cycle."""
+        texts = {get_waiting_text(i, reduced_motion=True) for i in range(20)}
+        assert len(texts) == 1
+
+
+class TestIsActive:
+    """Tests for session activity detection."""
+
+    def test_empty_entries(self):
+        assert is_active([]) is False
+
+    def test_recent_entry_is_active(self):
+        """Entry within timeout is active."""
+        entry = _make_entry(timestamp=int(time.time()) - 5)
+        assert is_active([entry]) is True
+
+    def test_old_entry_is_not_active(self):
+        """Entry older than timeout is not active."""
+        entry = _make_entry(timestamp=int(time.time()) - 60)
+        assert is_active([entry]) is False
+
+    def test_exactly_at_timeout_is_active(self):
+        """Entry exactly at timeout boundary is still active."""
+        entry = _make_entry(timestamp=int(time.time()) - 30)
+        assert is_active([entry], timeout=30) is True
+
+    def test_just_past_timeout_is_not_active(self):
+        """Entry just past timeout boundary is not active."""
+        entry = _make_entry(timestamp=int(time.time()) - 31)
+        assert is_active([entry], timeout=30) is False
+
+    def test_custom_timeout(self):
+        """Custom timeout should be respected."""
+        entry = _make_entry(timestamp=int(time.time()) - 10)
+        assert is_active([entry], timeout=5) is False
+        assert is_active([entry], timeout=15) is True
+
+    def test_uses_last_entry(self):
+        """Should check the most recent (last) entry, not the first."""
+        old_entry = _make_entry(timestamp=int(time.time()) - 120)
+        recent_entry = _make_entry(timestamp=int(time.time()) - 5)
+        assert is_active([old_entry, recent_entry]) is True
+
+    def test_old_entries_with_recent_last(self):
+        """Multiple old entries don't matter if last one is recent."""
+        now = int(time.time())
+        entries = [
+            _make_entry(timestamp=now - 300),
+            _make_entry(timestamp=now - 200),
+            _make_entry(timestamp=now - 100),
+            _make_entry(timestamp=now - 2),
+        ]
+        assert is_active(entries) is True