elliot-stack 1.0.39 → 1.0.40

package/skills/estack-read-claude-session-history/scripts/tests/test_modes.py

@@ -1,323 +0,0 @@
-"""End-to-end CLI tests via subprocess.run.
-
-Exercises mode dispatch + argument parsing. Library-level behavior is
-covered by the unit tests in test_paths/parser/tools/search/subagents.
-"""
-
-import json
-import os
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest
-
-
-def _run_cli(cli_path, *args, env_overrides=None):
-    env = dict(os.environ)
-    env["PYTHONIOENCODING"] = "utf-8"
-    if env_overrides:
-        env.update(env_overrides)
-    return subprocess.run(
-        [sys.executable, str(cli_path), *args],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        env=env,
-    )
-
-
-def test_help(cli_path):
-    r = _run_cli(cli_path, "--help")
-    assert r.returncode == 0
-    assert "--mode" in r.stdout
-
-
-def test_last_mode(cli_path, fixtures_dir):
-    r = _run_cli(cli_path, "--file", str(fixtures_dir / "basic-session.jsonl"), "--mode", "last")
-    assert r.returncode == 0
-    assert "Here is help" in r.stdout
-
-
-def test_advisor_mode(cli_path, fixtures_dir):
-    r = _run_cli(cli_path, "--file", str(fixtures_dir / "with-advisor.jsonl"), "--mode", "advisor")
-    assert r.returncode == 0
-    assert "advisor" in r.stdout.lower()
-
-
-def test_pre_compact_mode(cli_path, fixtures_dir):
-    r = _run_cli(cli_path, "--file", str(fixtures_dir / "with-compact.jsonl"), "--mode", "pre-compact")
-    assert r.returncode == 0
-    assert "Pre-compact" in r.stdout or "First answer" in r.stdout
-
-
-def test_debug_mode(cli_path, fixtures_dir):
-    r = _run_cli(cli_path, "--file", str(fixtures_dir / "basic-session.jsonl"), "--mode", "debug")
-    assert r.returncode == 0
-    assert "Entry type distribution" in r.stdout
-
-
-def test_brief_mode(cli_path, fixtures_dir):
-    r = _run_cli(cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"), "--mode", "brief")
-    assert r.returncode == 0
-    body = r.stdout
-    # 6 lines expected
-    assert "intent:" in body
-    assert "last:" in body
-    assert "edits:" in body
-    assert "tools:" in body
-    assert "subagents:" in body
-
-
-def test_brief_with_include_subagents(cli_path, fixtures_dir):
-    r = _run_cli(
-        cli_path, "--file", str(fixtures_dir / "subagent-parent.jsonl"),
-        "--mode", "brief", "--include-subagents",
-    )
-    assert r.returncode == 0
-    assert "subagent" in r.stdout.lower()
-    assert "Found it" in r.stdout
-
-
-def test_changelog(cli_path, fixtures_dir):
-    r = _run_cli(cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"), "--mode", "changelog")
-    assert r.returncode == 0
-    assert "Bash" in r.stdout
-    assert "Read" in r.stdout
-
-
-def test_file_edits(cli_path, fixtures_dir):
-    r = _run_cli(cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"), "--mode", "file-edits")
-    assert r.returncode == 0
-    assert "foo.py" in r.stdout
-    assert "bar.py" in r.stdout
-
-
-def test_tool_calls(cli_path, fixtures_dir):
-    r = _run_cli(cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"), "--mode", "tool-calls")
-    assert r.returncode == 0
-    assert "Bash" in r.stdout
-
-
-def test_tool_calls_filter(cli_path, fixtures_dir):
-    r = _run_cli(
-        cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"),
-        "--mode", "tool-calls", "--tool", "Bash",
-    )
-    assert r.returncode == 0
-    assert "Bash" in r.stdout
-    assert "Glob" not in r.stdout
-
-
-def test_tool_usage_file(cli_path, fixtures_dir):
-    r = _run_cli(cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"), "--mode", "tool-usage")
-    assert r.returncode == 0
-    assert "Tool calls" in r.stdout
-    assert "Bash" in r.stdout
-    assert "Skill" in r.stdout
-    # Skill calls are sub-tallied by the actual skill name (input.skill).
-    assert "using-superpowers" in r.stdout
-
-
-def test_tool_usage_skill_filter(cli_path, fixtures_dir):
-    r = _run_cli(
-        cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"),
-        "--mode", "tool-usage", "--tool", "Skill",
-    )
-    assert r.returncode == 0
-    assert "Skill" in r.stdout
-    assert "using-superpowers" in r.stdout
-    # Filtering to Skill must drop every other tool.
-    assert "Bash" not in r.stdout
-    assert "Glob" not in r.stdout
-
-
-def test_tool_usage_json(cli_path, fixtures_dir):
-    r = _run_cli(
-        cli_path, "--file", str(fixtures_dir / "tool-zoo.jsonl"),
-        "--mode", "tool-usage", "--format", "json",
-    )
-    assert r.returncode == 0
-    data = json.loads(r.stdout)
-    assert data["total"] == 9
-    assert data["sessions"] == 1
-    tools = {t["tool"]: t["count"] for t in data["tools"]}
-    assert tools["Skill"] == 1
-    assert tools["Bash"] == 1
-    skills = {s["skill"]: s["count"] for s in data["skills"]}
-    assert skills == {"using-superpowers": 1}
-
-
-def test_tool_usage_scope_aggregates(cli_path, fixtures_dir, tmp_path):
-    # Two sessions in one project → counts add up across files.
-    fake_root = tmp_path / "projects"
-    fake_proj = fake_root / "C--fake-proj"
-    fake_proj.mkdir(parents=True)
-    shutil.copy(fixtures_dir / "tool-zoo.jsonl", fake_proj / "a.jsonl")
-    shutil.copy(fixtures_dir / "tool-zoo.jsonl", fake_proj / "b.jsonl")
-    r = _run_cli(
-        cli_path, "--root", str(fake_root), "--cwd", "C:\\fake\\proj",
-        "--mode", "tool-usage", "--format", "json",
-    )
-    assert r.returncode == 0
-    data = json.loads(r.stdout)
-    assert data["sessions"] == 2
-    assert data["total"] == 18
-    skills = {s["skill"]: s["count"] for s in data["skills"]}
-    assert skills == {"using-superpowers": 2}
-
-
-def test_tool_usage_missing_file(cli_path, tmp_path):
-    r = _run_cli(cli_path, "--file", str(tmp_path / "nope.jsonl"), "--mode", "tool-usage")
-    assert r.returncode == 1
-
-
-def test_tool_usage_until_keeps_in_window_calls(cli_path, fixtures_dir, tmp_path):
-    # The tool-zoo calls are stamped 2026-05-01T10:00:0x. Copy the fixture, then
-    # bump its mtime far past --until. A naive mtime filter would drop the file
-    # and report zero; per-call timestamp filtering must still count the calls.
-    import os
-    fake_root = tmp_path / "projects"
-    fake_proj = fake_root / "C--fake-proj"
-    fake_proj.mkdir(parents=True)
-    target = fake_proj / "a.jsonl"
-    shutil.copy(fixtures_dir / "tool-zoo.jsonl", target)
-    future = 1_900_000_000  # ~2030, well after the --until bound below
-    os.utime(target, (future, future))
-    r = _run_cli(
-        cli_path, "--root", str(fake_root), "--cwd", "C:\\fake\\proj",
-        "--mode", "tool-usage", "--until", "2026-05-02", "--format", "json",
-    )
-    assert r.returncode == 0
-    data = json.loads(r.stdout)
-    assert data["total"] == 9, data  # all 9 calls are inside the window
-    assert data["sessions"] == 1
-
-
-def test_tool_usage_exclude_current_drops_session(cli_path, fixtures_dir, tmp_path):
-    fake_root = tmp_path / "projects"
-    fake_proj = fake_root / "C--fake-proj"
-    fake_proj.mkdir(parents=True)
-    shutil.copy(fixtures_dir / "tool-zoo.jsonl", fake_proj / "cur.jsonl")
-    shutil.copy(fixtures_dir / "tool-zoo.jsonl", fake_proj / "other.jsonl")
-    # Without exclusion: 2 sessions, 18 calls. Excluding "cur" leaves 1 session, 9.
-    r = _run_cli(
-        cli_path, "--root", str(fake_root), "--cwd", "C:\\fake\\proj",
-        "--mode", "tool-usage", "--exclude-current", "--format", "json",
-        env_overrides={"CLAUDE_SESSION_ID": "cur"},
-    )
-    assert r.returncode == 0
-    data = json.loads(r.stdout)
-    assert data["sessions"] == 1
-    assert data["total"] == 9
-
-
-def test_tool_usage_include_subagents(cli_path, fixtures_dir):
-    # Parent calls: Skill(commit) + Agent. Subagent calls: Skill(estack-repo-search) + Bash.
-    # --include-subagents must fold the subagent's calls in, without counting the
-    # subagent as its own session.
-    parent = fixtures_dir / "tool-usage-parent.jsonl"
-    without = json.loads(_run_cli(
-        cli_path, "--file", str(parent), "--mode", "tool-usage", "--format", "json",
-    ).stdout)
-    assert without["total"] == 2
-    assert without["sessions"] == 1
-    assert {s["skill"] for s in without["skills"]} == {"commit"}
-
-    with_sub = json.loads(_run_cli(
-        cli_path, "--file", str(parent), "--mode", "tool-usage",
-        "--include-subagents", "--format", "json",
-    ).stdout)
-    assert with_sub["total"] == 4  # +Skill(estack-repo-search) +Bash
-    assert with_sub["sessions"] == 1  # subagent is not a separate session
-    assert {s["skill"] for s in with_sub["skills"]} == {"commit", "estack-repo-search"}
-
-
-def test_subagent_list(cli_path, fixtures_dir):
-    r = _run_cli(
-        cli_path, "--file", str(fixtures_dir / "subagent-parent.jsonl"),
-        "--mode", "subagent-list",
-    )
-    assert r.returncode == 0
-    assert "agent-xyz123" in r.stdout
-
-
-def test_subagent_finals(cli_path, fixtures_dir):
-    r = _run_cli(
-        cli_path, "--file", str(fixtures_dir / "subagent-parent.jsonl"),
-        "--mode", "subagent-finals",
-    )
-    assert r.returncode == 0
-    assert "Found it" in r.stdout
-
-
-def test_diff_mode(cli_path, fixtures_dir):
-    r = _run_cli(
-        cli_path, "--mode", "diff",
-        "--file-a", str(fixtures_dir / "basic-session.jsonl"),
-        "--file-b", str(fixtures_dir / "with-thinking.jsonl"),
-    )
-    assert r.returncode == 0
-    assert "A>" in r.stdout
-    assert "B>" in r.stdout
-
-
-def test_lookup_no_match(cli_path, fixtures_dir, tmp_path):
-    # Point --root at an empty dir so lookup definitely misses
-    r = _run_cli(cli_path, "--root", str(tmp_path), "--mode", "lookup", "--uuid", "nope")
-    assert r.returncode == 1
-
-
-def test_list_legacy_format(cli_path, fixtures_dir, tmp_path):
-    # Build a fake project root + cwd that matches encoding
-    fake_root = tmp_path / "projects"
-    fake_proj = fake_root / "C--fake-proj"
-    fake_proj.mkdir(parents=True)
-    shutil.copy(fixtures_dir / "basic-session.jsonl", fake_proj / "abc.jsonl")
-    r = _run_cli(cli_path, "--root", str(fake_root), "--cwd", "C:\\fake\\proj", "--list")
-    assert r.returncode == 0
-    assert "abc.jsonl" in r.stdout
-
-
-def test_exclude_current(cli_path, fixtures_dir, tmp_path):
-    fake_root = tmp_path / "projects"
-    fake_proj = fake_root / "C--fake-proj"
-    fake_proj.mkdir(parents=True)
-    shutil.copy(fixtures_dir / "basic-session.jsonl", fake_proj / "abc.jsonl")
-    shutil.copy(fixtures_dir / "tool-zoo.jsonl", fake_proj / "def.jsonl")
-    r = _run_cli(
-        cli_path, "--root", str(fake_root), "--cwd", "C:\\fake\\proj",
-        "--mode", "list", "--exclude-current",
-        env_overrides={"CLAUDE_SESSION_ID": "abc"},
-    )
-    assert r.returncode == 0
-    assert "def" in r.stdout
-    assert "abc" not in r.stdout
-
-
-def test_dump_large_file_degrades(cli_path, fixtures_dir, tmp_path):
-    # Build a 6MB padded fixture by writing many valid lines
-    big = tmp_path / "big.jsonl"
-    line = '{"type":"user","timestamp":"2026-05-01T10:00:00Z","message":{"role":"user","content":"'
-    pad = "x" * 1000 + '"}}\n'
-    with open(big, "w", encoding="utf-8") as f:
-        # Each line ~1KB → write ~7000 to hit 6MB+
-        for _ in range(7000):
-            f.write(line + pad)
-    r = _run_cli(cli_path, "--file", str(big), "--mode", "dump")
-    assert r.returncode == 0
-    assert "degraded" in r.stderr.lower()
-
-
-def test_dump_large_file_force(cli_path, tmp_path):
-    big = tmp_path / "big.jsonl"
-    line = '{"type":"user","timestamp":"2026-05-01T10:00:00Z","message":{"role":"user","content":"'
-    pad = "x" * 1000 + '"}}\n'
-    with open(big, "w", encoding="utf-8") as f:
-        for _ in range(7000):
-            f.write(line + pad)
-    r = _run_cli(cli_path, "--file", str(big), "--mode", "dump", "--force-dump")
-    assert r.returncode == 0
-    # No degrade note when forced
-    assert "degraded" not in r.stderr.lower()

package/skills/estack-read-claude-session-history/scripts/tests/test_parser.py

@@ -1,204 +0,0 @@
-"""Tests for lib.parser."""
-
-import json
-from datetime import datetime, timedelta
-from pathlib import Path
-
-import pytest
-
-from lib import parser as PR
-
-
-def _load(fixtures_dir, name):
-    return PR.parse_lines(fixtures_dir / name)
-
-
-def test_parse_basic(fixtures_dir):
-    lines = _load(fixtures_dir, "basic-session.jsonl")
-    assert len(lines) == 2
-    assert lines[0]["type"] == "user"
-
-
-def test_get_messages_basic(fixtures_dir):
-    lines = _load(fixtures_dir, "basic-session.jsonl")
-    msgs = PR.get_messages(lines)
-    assert len(msgs) == 2
-    assert msgs[0]["role"] == "user"
-    assert msgs[1]["role"] == "assistant"
-
-
-def test_compact_marker_single(fixtures_dir):
-    lines = _load(fixtures_dir, "with-compact.jsonl")
-    msgs = PR.get_messages(lines)
-    compact = [m for m in msgs if m["is_compact"]]
-    assert len(compact) == 1
-
-
-def test_compact_marker_multiple(fixtures_dir):
-    lines = _load(fixtures_dir, "multi-compact.jsonl")
-    msgs = PR.get_messages(lines)
-    compact = [m for m in msgs if m["is_compact"]]
-    assert len(compact) == 2
-
-
-def test_compact_marker_absent(fixtures_dir):
-    lines = _load(fixtures_dir, "basic-session.jsonl")
-    msgs = PR.get_messages(lines)
-    assert all(not m["is_compact"] for m in msgs)
-
-
-def test_extract_text_blocks_string():
-    assert PR.extract_text_blocks("hello") == ["hello"]
-
-
-def test_extract_text_blocks_empty_string():
-    assert PR.extract_text_blocks("") == []
-    assert PR.extract_text_blocks("   ") == []
-
-
-def test_extract_text_blocks_array():
-    blocks = [{"type": "text", "text": "hi"}, {"type": "tool_use", "name": "X"}]
-    assert PR.extract_text_blocks(blocks) == ["hi"]
-
-
-def test_extract_text_blocks_with_thinking():
-    blocks = [
-        {"type": "thinking", "thinking": "reasoning..."},
-        {"type": "text", "text": "answer"},
-    ]
-    out = PR.extract_text_blocks(blocks, include_thinking=True)
-    assert any("THINKING" in t for t in out)
-    assert "answer" in out
-
-
-def test_extract_text_blocks_with_tool_use():
-    blocks = [{"type": "tool_use", "name": "Bash", "input": {"command": "ls"}}]
-    out = PR.extract_text_blocks(blocks, include_tool_use=True)
-    assert any("TOOL_USE Bash" in t for t in out)
-
-
-def test_extract_advisor():
-    blocks = [{"type": "advisor_tool_result", "content": {"text": "advice"}}]
-    out = PR.extract_text_blocks(blocks)
-    assert any("[ADVISOR]" in t for t in out)
-    assert any("advice" in t for t in out)
-
-
-def test_classify_entry_user():
-    obj = {"type": "user", "message": {"role": "user", "content": "hi"}}
-    assert PR.classify_entry(obj) == "user"
-
-
-def test_classify_entry_compact():
-    obj = {
-        "type": "user",
-        "message": {"role": "user", "content": PR.COMPACT_MARKER + " more"},
-    }
-    assert PR.classify_entry(obj) == "compact"
-
-
-def test_classify_entry_assistant():
-    obj = {"type": "assistant", "message": {"role": "assistant", "content": []}}
-    assert PR.classify_entry(obj) == "assistant"
-
-
-def test_classify_entry_noise():
-    obj = {"type": "ai-title", "aiTitle": "X"}
-    assert PR.classify_entry(obj) == "title"
-
-
-def test_all_noise_fixture_yields_no_messages(fixtures_dir):
-    lines = _load(fixtures_dir, "all-noise.jsonl")
-    msgs = PR.get_messages(lines)
-    assert msgs == []
-
-
-def test_filter_by_role(fixtures_dir):
-    lines = _load(fixtures_dir, "basic-session.jsonl")
-    msgs = PR.get_messages(lines)
-    user_only = PR.filter_by_role(msgs, "user")
-    assert all(m["role"] == "user" for m in user_only)
-    assert len(user_only) == 1
-
-
-def test_filter_by_time(fixtures_dir):
-    lines = _load(fixtures_dir, "time-spread.jsonl")
-    msgs = PR.get_messages(lines)
-    since = datetime(2026, 5, 1)
-    filtered = PR.filter_by_time(msgs, since=since, until=None)
-    assert all(
-        PR._parse_timestamp(m["timestamp"]).replace(tzinfo=None) >= since
-        for m in filtered if m["timestamp"]
-    )
-
-
-def test_filter_by_time_until_is_exclusive():
-    # Half-open [since, until): a message stamped exactly at `until` is excluded.
-    # Derive the bound from the parser so the test is timezone-independent.
-    msgs = [{"timestamp": "2026-05-01T10:00:00Z"}]
-    at = PR._parse_timestamp(msgs[0]["timestamp"])
-    assert PR.filter_by_time(msgs, since=None, until=at) == []
-    assert PR.filter_by_time(msgs, since=None, until=at + timedelta(seconds=1)) == msgs
-
-
-def test_truncated_line_dropped(fixtures_dir, capsys):
-    # Should not raise, and warning should be on stderr
-    lines = _load(fixtures_dir, "truncated.jsonl")
-    # 2 valid + 1 truncated = 2 valid records
-    assert len(lines) == 2
-
-
-def test_unicode_roundtrip(fixtures_dir):
-    lines = _load(fixtures_dir, "unicode.jsonl")
-    msgs = PR.get_messages(lines)
-    user_text = msgs[0]["texts"][0]
-    assert "🌍" in user_text or "你好" in user_text
-
-
-def test_infer_status_clean(fixtures_dir):
-    lines = _load(fixtures_dir, "basic-session.jsonl")
-    mtime = (fixtures_dir / "basic-session.jsonl").stat().st_mtime
-    status = PR.infer_status(lines, mtime, current_session_id=None, session_uuid=None)
-    assert status == "clean"
-
-
-def test_infer_status_pending_user(fixtures_dir):
-    lines = _load(fixtures_dir, "pending-user.jsonl")
-    mtime = (fixtures_dir / "pending-user.jsonl").stat().st_mtime
-    status = PR.infer_status(lines, mtime, current_session_id=None, session_uuid=None)
-    assert status == "pending-user"
-
-
-def test_infer_status_interrupted(fixtures_dir):
-    lines = _load(fixtures_dir, "interrupted.jsonl")
-    mtime = (fixtures_dir / "interrupted.jsonl").stat().st_mtime
-    status = PR.infer_status(lines, mtime, current_session_id=None, session_uuid=None)
-    assert status == "interrupted"
-
-
-def test_infer_status_active(fixtures_dir):
-    import time
-    # Touch the fixture to make it fresh, then set CLAUDE_SESSION_ID to its stem
-    f = fixtures_dir / "basic-session.jsonl"
-    mtime = time.time()
-    lines = _load(fixtures_dir, "basic-session.jsonl")
-    status = PR.infer_status(
-        lines, mtime, current_session_id="basic-session", session_uuid="basic-session"
-    )
-    assert status == "active"
-
-
-def test_session_summary_fields(fixtures_dir):
-    s = PR.session_summary(fixtures_dir / "tool-zoo.jsonl")
-    assert s["exists"]
-    assert s["msg_count"] > 0
-    assert "Bash" in s["tool_counts"]
-    assert "Read" in s["tool_counts"]
-
-
-def test_parse_lines_cache(fixtures_dir):
-    f = fixtures_dir / "basic-session.jsonl"
-    a = PR.parse_lines(f)
-    b = PR.parse_lines(f)
-    # Same object thanks to cache
-    assert a is b

package/skills/estack-read-claude-session-history/scripts/tests/test_paths.py

@@ -1,133 +0,0 @@
-"""Tests for lib.paths."""
-
-import os
-from datetime import datetime, timedelta
-from pathlib import Path
-
-import pytest
-
-from lib import paths as P
-
-
-def test_encode_cwd_basic():
-    assert P.encode_cwd("C:\\Users\\foo\\bar") == "C--Users-foo-bar"
-
-
-def test_encode_cwd_spaces():
-    assert P.encode_cwd("C:\\Users\\2supe\\Other Claude Code") == "C--Users-2supe-Other-Claude-Code"
-
-
-def test_encode_cwd_mixed_slashes():
-    assert P.encode_cwd("C:/Users/foo bar") == "C--Users-foo-bar"
-
-
-def test_decode_project_name_strips_prefix():
-    enc = "C--Users-elliot-Other-Claude-Code-Personal-Brand-Project"
-    decoded = P.decode_project_name(enc)
-    assert "Other" in decoded
-    assert "Personal" in decoded
-    assert "C--Users" not in decoded
-
-
-def test_decode_project_name_fallback_when_unparseable():
-    decoded = P.decode_project_name("totally-weird-thing")
-    assert decoded  # Non-empty, falls back gracefully
-
-
-def test_resolve_root_live():
-    assert P.resolve_root("live").name == "projects"
-
-
-def test_resolve_root_mirror():
-    r = P.resolve_root("mirror")
-    assert "mirror" in str(r)
-    assert r.name == "projects"
-
-
-def test_resolve_root_unknown_relative_raises():
-    with pytest.raises(ValueError):
-        P.resolve_root("not-a-known-root")
-
-
-def test_resolve_root_absolute_passes_through(tmp_path: Path):
-    r = P.resolve_root(str(tmp_path))
-    assert r == tmp_path
-
-
-def test_current_session_id_unset(monkeypatch):
-    monkeypatch.delenv("CLAUDE_SESSION_ID", raising=False)
-    assert P.current_session_id() is None
-
-
-def test_current_session_id_set(monkeypatch):
-    monkeypatch.setenv("CLAUDE_SESSION_ID", "abc-123")
-    assert P.current_session_id() == "abc-123"
-
-
-def test_parse_timespec_relative():
-    now = datetime.now()
-    delta = now - P.parse_timespec("1h")
-    assert timedelta(seconds=3590) <= delta <= timedelta(seconds=3610)
-
-
-def test_parse_timespec_iso_date():
-    assert P.parse_timespec("2026-05-01") == datetime(2026, 5, 1)
-
-
-def test_parse_timespec_yesterday():
-    y = P.parse_timespec("yesterday")
-    assert y.hour == 0
-    assert y.minute == 0
-
-
-def test_parse_timespec_invalid():
-    with pytest.raises(ValueError):
-        P.parse_timespec("not-a-time")
-
-
-def test_list_transcripts_empty(tmp_path: Path):
-    assert P.list_transcripts(tmp_path) == []
-
-
-def test_list_transcripts_excludes_agent_prefix(tmp_path: Path):
-    (tmp_path / "real.jsonl").write_text("{}\n")
-    (tmp_path / "agent-foo.jsonl").write_text("{}\n")
-    files = P.list_transcripts(tmp_path)
-    names = [f.name for f in files]
-    assert "real.jsonl" in names
-    assert "agent-foo.jsonl" not in names
-
-
-def test_list_transcripts_time_filter(tmp_path: Path):
-    old = tmp_path / "old.jsonl"
-    new = tmp_path / "new.jsonl"
-    old.write_text("{}\n")
-    new.write_text("{}\n")
-    # Backdate old
-    past = datetime.now() - timedelta(days=10)
-    os.utime(old, (past.timestamp(), past.timestamp()))
-
-    since = datetime.now() - timedelta(days=5)
-    files = P.list_transcripts(tmp_path, since=since)
-    assert [f.name for f in files] == ["new.jsonl"]
-
-
-def test_list_projects_empty(tmp_path: Path):
-    assert P.list_projects(tmp_path) == []
-
-
-def test_list_subagents_returns_empty_when_no_dir(tmp_path: Path):
-    f = tmp_path / "session.jsonl"
-    f.write_text("{}\n")
-    assert P.list_subagents(f) == []
-
-
-def test_list_subagents_finds_agent_files(tmp_path: Path):
-    f = tmp_path / "session.jsonl"
-    f.write_text("{}\n")
-    sub_dir = tmp_path / "session" / "subagents"
-    sub_dir.mkdir(parents=True)
-    (sub_dir / "agent-x.jsonl").write_text("{}\n")
-    (sub_dir / "agent-y.jsonl").write_text("{}\n")
-    subs = P.list_subagents(f)
-    assert len(subs) == 2