@jairodri/huckleberry-cli 1.0.1 → 1.1.0

package/skills/claw-compactor/tests/test_observation_comprehensive.py

@@ -0,0 +1,261 @@
+"""Comprehensive tests for observation_compressor.py."""
+import json
+import sys
+import pytest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+
+from observation_compressor import (
+    parse_session_jsonl, extract_tool_interactions, compress_session,
+    format_observations_md, format_observations_xml, rule_extract_observations,
+    generate_observation_prompt, OBSERVATION_TYPES,
+)
+
+
+def _make_session(tmp_path, messages):
+    """Create a JSONL session file from message dicts."""
+    f = tmp_path / "test-session.jsonl"
+    lines = [json.dumps(m) for m in messages]
+    f.write_text("\n".join(lines) + "\n")
+    return f
+
+
+class TestParseSessionJsonl:
+    def test_valid_messages(self, tmp_path):
+        messages = [
+            {"role": "user", "content": "Hello"},
+            {"role": "assistant", "content": "Hi there"},
+        ]
+        f = _make_session(tmp_path, messages)
+        result = parse_session_jsonl(f)
+        assert len(result) == 2
+
+    def test_empty_file(self, tmp_path):
+        f = tmp_path / "empty.jsonl"
+        f.write_text("")
+        result = parse_session_jsonl(f)
+        assert result == []
+
+    def test_single_message(self, tmp_path):
+        f = _make_session(tmp_path, [{"role": "user", "content": "single"}])
+        result = parse_session_jsonl(f)
+        assert len(result) == 1
+
+    def test_mixed_valid_invalid(self, tmp_path):
+        f = tmp_path / "mixed.jsonl"
+        f.write_text('{"role":"user","content":"ok"}\nnot json\n{"role":"assistant","content":"yes"}\n')
+        result = parse_session_jsonl(f)
+        # Should skip bad lines
+        assert len(result) >= 1
+
+    def test_large_session(self, tmp_path):
+        messages = [{"role": "user", "content": f"Message {i}"} for i in range(500)]
+        f = _make_session(tmp_path, messages)
+        result = parse_session_jsonl(f)
+        assert len(result) == 500
+
+    def test_tool_call_messages(self, tmp_path):
+        messages = [
+            {"role": "user", "content": "Run a command"},
+            {"role": "assistant", "content": "", "tool_calls": [
+                {"function": {"name": "exec", "arguments": '{"command":"ls"}'}}
+            ]},
+            {"role": "tool", "content": "file1.txt\nfile2.txt", "name": "exec"},
+        ]
+        f = _make_session(tmp_path, messages)
+        result = parse_session_jsonl(f)
+        assert len(result) == 3
+
+
+class TestExtractToolInteractions:
+    def test_with_tool_calls(self):
+        messages = [
+            {"role": "user", "content": "check files"},
+            {"role": "assistant", "content": "", "tool_calls": [
+                {"function": {"name": "exec", "arguments": '{"command":"ls"}'}}
+            ]},
+            {"role": "tool", "content": "a.txt\nb.txt", "name": "exec"},
+        ]
+        result = extract_tool_interactions(messages)
+        assert len(result) > 0
+
+    def test_no_tool_calls(self):
+        messages = [
+            {"role": "user", "content": "hello"},
+            {"role": "assistant", "content": "hi"},
+        ]
+        result = extract_tool_interactions(messages)
+        assert isinstance(result, list)
+
+    def test_empty(self):
+        result = extract_tool_interactions([])
+        assert result == []
+
+    def test_only_user_messages(self):
+        messages = [{"role": "user", "content": f"msg {i}"} for i in range(5)]
+        result = extract_tool_interactions(messages)
+        assert isinstance(result, list)
+
+
+class TestRuleExtractObservations:
+    def test_basic_extraction(self):
+        interactions = [
+            {
+                "tool_name": "exec",
+                "arguments": {"command": "python3 setup.py install"},
+                "result": "Successfully installed package v2.0",
+            },
+        ]
+        result = rule_extract_observations(interactions)
+        assert len(result) > 0
+
+    def test_empty_interactions(self):
+        result = rule_extract_observations([])
+        assert result == []
+
+    def test_read_interaction(self):
+        interactions = [
+            {
+                "tool_name": "read",
+                "arguments": {"path": "/etc/config.yaml"},
+                "result": "key: value\nother: data",
+            },
+        ]
+        result = rule_extract_observations(interactions)
+        assert isinstance(result, list)
+
+    def test_multiple_interactions(self):
+        interactions = [
+            {"tool_name": "exec", "arguments": {"command": "git status"}, "result": "On branch main"},
+            {"tool_name": "exec", "arguments": {"command": "git push"}, "result": "Everything up to date"},
+            {"tool_name": "read", "arguments": {"path": "README.md"}, "result": "# Project\nDescription"},
+        ]
+        result = rule_extract_observations(interactions)
+        assert isinstance(result, list)
+
+
+class TestCompressSession:
+    def test_basic_session(self, tmp_path):
+        messages = [
+            {"role": "user", "content": "Hello, how are you?"},
+            {"role": "assistant", "content": "I'm doing well! Let me check something."},
+        ]
+        f = _make_session(tmp_path, messages)
+        result = compress_session(f)
+        assert isinstance(result, dict)
+        assert "original_tokens" in result or "observations" in result
+
+    def test_session_with_tools(self, tmp_path):
+        messages = [
+            {"role": "user", "content": "list files"},
+            {"role": "assistant", "content": "", "tool_calls": [
+                {"function": {"name": "exec", "arguments": '{"command":"ls -la"}'}}
+            ]},
+            {"role": "tool", "content": "total 42\ndrwxr-xr-x 5 user staff 160 Jan 1 00:00 .\n-rw-r--r-- 1 user staff 1234 Jan 1 00:00 test.py", "name": "exec"},
+            {"role": "assistant", "content": "I found 3 items in the directory."},
+        ]
+        f = _make_session(tmp_path, messages)
+        result = compress_session(f)
+        assert isinstance(result, dict)
+
+    def test_empty_session(self, tmp_path):
+        f = tmp_path / "empty.jsonl"
+        f.write_text("")
+        result = compress_session(f)
+        assert isinstance(result, dict)
+
+
+class TestFormatObservations:
+    def test_md_format(self):
+        obs = [{"type": "feature", "summary": "Added compression", "details": "rule-based"}]
+        result = format_observations_md(obs)
+        assert isinstance(result, str)
+        assert "compression" in result.lower() or "Added" in result
+
+    def test_xml_format(self):
+        obs = [{"type": "bugfix", "summary": "Fixed crash", "details": "null check"}]
+        result = format_observations_xml(obs)
+        assert isinstance(result, str)
+
+    def test_empty_observations_md(self):
+        result = format_observations_md([])
+        assert isinstance(result, str)
+
+    def test_empty_observations_xml(self):
+        result = format_observations_xml([])
+        assert isinstance(result, str)
+
+    def test_multiple_observations(self):
+        obs = [
+            {"type": "feature", "summary": "Feature A", "details": "details A"},
+            {"type": "decision", "summary": "Decision B", "details": "details B"},
+            {"type": "config", "summary": "Config C", "details": "details C"},
+        ]
+        md = format_observations_md(obs)
+        xml = format_observations_xml(obs)
+        assert len(md) > 0
+        assert len(xml) > 0
+
+    def test_unicode_observations(self):
+        obs = [{"type": "discovery", "summary": "发现中文支持", "details": "支持 UTF-8"}]
+        md = format_observations_md(obs)
+        assert "中文" in md
+
+
+class TestObservationTypes:
+    def test_all_types_defined(self):
+        assert "feature" in OBSERVATION_TYPES
+        assert "bugfix" in OBSERVATION_TYPES
+        assert "decision" in OBSERVATION_TYPES
+        assert "discovery" in OBSERVATION_TYPES
+        assert "config" in OBSERVATION_TYPES
+
+    def test_types_are_strings(self):
+        for t in OBSERVATION_TYPES:
+            assert isinstance(t, str)
+
+
+class TestGenerateObservationPrompt:
+    def test_generates_prompt(self):
+        segment = [
+            {"tool_name": "exec", "arguments": {"command": "ls"}, "result": "files"},
+        ]
+        result = generate_observation_prompt(segment)
+        assert isinstance(result, str)
+        assert len(result) > 0
+
+    def test_empty_segment(self):
+        result = generate_observation_prompt([])
+        assert isinstance(result, str)
+
+
+class TestCompressionRatio:
+    """Verify that observation compression achieves claimed ratios."""
+
+    def test_verbose_session_high_compression(self, tmp_path):
+        """Sessions with lots of tool output should compress heavily."""
+        # Create a session with verbose tool output
+        messages = []
+        for i in range(20):
+            messages.append({"role": "user", "content": f"Check item {i}"})
+            messages.append({
+                "role": "assistant", "content": "",
+                "tool_calls": [{"function": {"name": "exec", "arguments": json.dumps({"command": f"cat /var/log/item{i}.log"})}}]
+            })
+            messages.append({
+                "role": "tool", "name": "exec",
+                "content": f"LOG ENTRY {i}: " + "x" * 500 + f"\nSTATUS: OK\nTIME: 2026-01-01T00:00:{i:02d}Z"
+            })
+            messages.append({"role": "assistant", "content": f"Item {i} is OK."})
+
+        f = _make_session(tmp_path, messages)
+        original_size = f.stat().st_size
+        result = compress_session(f)
+
+        if result.get("observations"):
+            compressed = format_observations_md(result["observations"])
+            compressed_size = len(compressed.encode())
+            ratio = 1 - (compressed_size / original_size)
+            # Should achieve at least 80% compression on verbose output
+            assert ratio > 0.5, f"Compression ratio {ratio:.1%} too low"

package/skills/claw-compactor/tests/test_observation_compressor.py

@@ -0,0 +1,128 @@
+"""Tests for observation compressor."""
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+from observation_compressor import (
+    parse_session_jsonl, extract_tool_interactions,
+    generate_observation_prompt, compress_session,
+    format_observations_xml, rule_extract_observations,
+)
+
+
+@pytest.fixture
+def sample_jsonl(tmp_path):
+    """Create a sample .jsonl transcript in OpenClaw format."""
+    entries = [
+        {"type": "session", "id": "sess1", "timestamp": "2024-01-01T00:00:00Z", "cwd": "/tmp"},
+        {"type": "message", "id": "m1", "parentId": "", "timestamp": "2024-01-01T00:00:01Z",
+         "message": {"role": "user", "content": "Check the server status"}},
+        {"type": "message", "id": "m2", "parentId": "m1", "timestamp": "2024-01-01T00:00:02Z",
+         "message": {"role": "assistant", "content": [
+             {"type": "text", "text": "I'll check that."},
+             {"type": "toolCall", "toolName": "exec", "toolUseId": "tc1",
+              "input": {"command": "uptime"}},
+         ]}},
+        {"type": "message", "id": "m3", "parentId": "m2", "timestamp": "2024-01-01T00:00:03Z",
+         "message": {"role": "tool", "content": [
+             {"type": "toolResult", "toolUseId": "tc1",
+              "result": "up 42 days, load average: 0.5"}
+         ]}},
+        {"type": "message", "id": "m4", "parentId": "m3", "timestamp": "2024-01-01T00:00:04Z",
+         "message": {"role": "assistant", "content": [
+             {"type": "text", "text": "Server is up 42 days."},
+             {"type": "toolCall", "toolName": "read", "toolUseId": "tc2",
+              "input": {"path": "/etc/hostname"}},
+         ]}},
+        {"type": "message", "id": "m5", "parentId": "m4", "timestamp": "2024-01-01T00:00:05Z",
+         "message": {"role": "tool", "content": [
+             {"type": "toolResult", "toolUseId": "tc2",
+              "result": "gateway-prod"}
+         ]}},
+    ]
+    path = tmp_path / "session.jsonl"
+    path.write_text('\n'.join(json.dumps(e) for e in entries))
+    return path
+
+
+@pytest.fixture
+def empty_jsonl(tmp_path):
+    path = tmp_path / "empty.jsonl"
+    path.write_text("")
+    return path
+
+
+class TestParseSessionJsonl:
+    def test_basic(self, sample_jsonl):
+        messages = parse_session_jsonl(sample_jsonl)
+        assert len(messages) >= 3  # session_start + messages
+        roles = [m.get("role", m.get("type", "")) for m in messages]
+        assert "user" in roles or "session_start" in roles
+
+    def test_empty(self, empty_jsonl):
+        messages = parse_session_jsonl(empty_jsonl)
+        assert messages == []
+
+    def test_malformed_json(self, tmp_path):
+        path = tmp_path / "bad.jsonl"
+        path.write_text('not json\n{"type":"message","message":{"role":"user","content":"hi"}}\n{broken')
+        messages = parse_session_jsonl(path)
+        assert isinstance(messages, list)
+
+
+class TestExtractToolInteractions:
+    def test_basic(self, sample_jsonl):
+        messages = parse_session_jsonl(sample_jsonl)
+        interactions = extract_tool_interactions(messages)
+        assert isinstance(interactions, list)
+
+    def test_empty(self):
+        interactions = extract_tool_interactions([])
+        assert interactions == []
+
+
+class TestGenerateObservationPrompt:
+    def test_returns_string(self):
+        segment = [{"tool_name": "exec", "input_summary": "uptime", "output_summary": "42 days"}]
+        prompt = generate_observation_prompt(segment)
+        assert isinstance(prompt, str)
+        assert len(prompt) > 0
+
+
+class TestRuleExtractObservations:
+    def test_with_interactions(self):
+        interactions = [
+            {"tool_name": "exec", "input_summary": '{"command": "uptime"}',
+             "output_summary": "up 42 days", "output_size": 20, "assistant_text": "checking"},
+        ]
+        observations = rule_extract_observations(interactions)
+        assert isinstance(observations, list)
+
+    def test_empty(self):
+        observations = rule_extract_observations([])
+        assert isinstance(observations, list)
+
+
+class TestFormatObservationsXml:
+    def test_basic(self):
+        observations = [
+            {"type": "discovery", "title": "Server status",
+             "facts": ["Server up 42 days"], "narrative": "Checked server."}
+        ]
+        xml = format_observations_xml(observations)
+        assert "<observation>" in xml
+        assert "discovery" in xml
+
+
+class TestCompressSession:
+    def test_basic(self, sample_jsonl):
+        result = compress_session(sample_jsonl)
+        assert isinstance(result, dict)
+
+    def test_empty(self, empty_jsonl):
+        result = compress_session(empty_jsonl)
+        assert isinstance(result, dict)

package/skills/claw-compactor/tests/test_performance.py

@@ -0,0 +1,172 @@
+"""Performance benchmark — full pipeline on real workspace data.
+
+Runs each compression technique in sequence, measures token savings,
+and outputs a clear performance report.
+"""
+
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+from lib.tokens import estimate_tokens, using_tiktoken
+from lib.dictionary import build_codebook, compress_text, decompress_text
+from lib.tokenizer_optimizer import optimize_tokens
+from lib.rle import compress as rle_compress
+from compress_memory import rule_compress
+
+WORKSPACE = Path("/home/user/workspace")
+
+
+def _collect_md_files(workspace: Path) -> list:
+    """Collect all .md files in workspace (excluding skills internals)."""
+    files = []
+    for f in sorted(workspace.rglob("*.md")):
+        # Skip node_modules, .git, __pycache__, and deep skill code
+        rel = str(f.relative_to(workspace))
+        if any(skip in rel for skip in [
+            "node_modules", ".git", "__pycache__", ".pytest_cache",
+            "scripts/", "tests/", "references/"
+        ]):
+            continue
+        files.append(f)
+    return files
+
+
+def _read_all(files: list) -> dict:
+    """Read all files into {path: content} dict."""
+    contents = {}
+    for f in files:
+        try:
+            contents[str(f)] = f.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            pass
+    return contents
+
+
+class TestPerformanceBenchmark:
+    """Benchmark compression on real workspace data."""
+
+    @pytest.fixture(scope="class")
+    def workspace_data(self):
+        """Load real workspace files."""
+        if not WORKSPACE.exists():
+            pytest.skip("Workspace not available")
+        files = _collect_md_files(WORKSPACE)
+        if not files:
+            pytest.skip("No .md files found")
+        return _read_all(files)
+
+    def test_full_pipeline_benchmark(self, workspace_data):
+        """Run full pipeline on real workspace, report savings per technique."""
+        all_text = '\n\n'.join(workspace_data.values())
+
+        # Stage 0: Baseline
+        baseline_tokens = estimate_tokens(all_text)
+        assert baseline_tokens > 0, "Empty workspace"
+
+        # Stage 1: Rule engine compression
+        rule_compressed = rule_compress(all_text)
+        rule_tokens = estimate_tokens(rule_compressed)
+
+        # Stage 2: Dictionary compression
+        # Build codebook from rule-compressed texts for correct roundtrip
+        rule_texts = [rule_compress(t) for t in workspace_data.values()]
+        codebook = build_codebook(rule_texts, min_freq=3)
+        dict_compressed = compress_text(rule_compressed, codebook)
+        dict_tokens = estimate_tokens(dict_compressed)
+
+        # Stage 3: Tokenizer optimization
+        tok_optimized = optimize_tokens(dict_compressed, aggressive=True)
+        tok_tokens = estimate_tokens(tok_optimized)
+
+        # Stage 4: RLE
+        rle_result = rle_compress(tok_optimized, [str(WORKSPACE)])
+        rle_tokens = estimate_tokens(rle_result)
+
+        # Build report
+        stages = [
+            ("Baseline", baseline_tokens, baseline_tokens),
+            ("Rule Engine", baseline_tokens, rule_tokens),
+            ("Dictionary Encode", rule_tokens, dict_tokens),
+            ("Tokenizer Optimize", dict_tokens, tok_tokens),
+            ("RLE Patterns", tok_tokens, rle_tokens),
+        ]
+
+        report_lines = [
+            "",
+            "=== Compression Performance Report ===",
+            f"Files: {len(workspace_data)} | Tokenizer: {'tiktoken' if using_tiktoken() else 'heuristic'}",
+            "",
+            f"{'Technique':<22} | {'Before':>8} | {'After':>8} | {'Saved':>6} | {'%':>6}",
+            "-" * 22 + "-+-" + "-" * 8 + "-+-" + "-" * 8 + "-+-" + "-" * 6 + "-+-" + "-" * 6,
+        ]
+
+        for name, before, after in stages[1:]:
+            saved = before - after
+            pct = (saved / before * 100) if before > 0 else 0
+            report_lines.append(
+                f"{name:<22} | {before:>8,} | {after:>8,} | {saved:>6,} | {pct:>5.1f}%"
+            )
+
+        total_saved = baseline_tokens - rle_tokens
+        total_pct = (total_saved / baseline_tokens * 100) if baseline_tokens > 0 else 0
+        report_lines.extend([
+            "-" * 22 + "-+-" + "-" * 8 + "-+-" + "-" * 8 + "-+-" + "-" * 6 + "-+-" + "-" * 6,
+            f"{'TOTAL':<22} | {baseline_tokens:>8,} | {rle_tokens:>8,} | {total_saved:>6,} | {total_pct:>5.1f}%",
+            "",
+        ])
+
+        report = '\n'.join(report_lines)
+        print(report)
+
+        # Assertions
+        assert rule_tokens <= baseline_tokens, "Rule engine should not increase tokens"
+        assert total_pct > 5, f"Combined savings only {total_pct:.1f}%, expected > 5%"
+
+        # Verify dictionary roundtrip on the actual data
+        decompressed = decompress_text(dict_compressed, codebook)
+        assert decompressed == rule_compressed, "Dictionary roundtrip failed on real data!"
+
+    def test_per_file_breakdown(self, workspace_data):
+        """Show per-file compression potential."""
+        results = []
+        for path, content in workspace_data.items():
+            before = estimate_tokens(content)
+            after = estimate_tokens(rule_compress(content))
+            optimized = estimate_tokens(optimize_tokens(content, aggressive=True))
+            results.append({
+                "file": Path(path).name,
+                "original": before,
+                "rule": after,
+                "optimized": optimized,
+            })
+
+        results.sort(key=lambda r: r["original"], reverse=True)
+
+        print("\n=== Per-File Breakdown (top 10) ===")
+        print(f"{'File':<35} | {'Original':>8} | {'Rule':>8} | {'Optimized':>8} | {'Saved':>6}")
+        print("-" * 80)
+        for r in results[:10]:
+            saved = r["original"] - r["optimized"]
+            pct = (saved / r["original"] * 100) if r["original"] > 0 else 0
+            print(f"{r['file']:<35} | {r['original']:>8,} | {r['rule']:>8,} | {r['optimized']:>8,} | {pct:>5.1f}%")
+
+    def test_dictionary_codebook_quality(self, workspace_data):
+        """Verify codebook quality: entries should save more than they cost."""
+        texts = list(workspace_data.values())
+        cb = build_codebook(texts, min_freq=3)
+
+        if not cb:
+            pytest.skip("No codebook entries built")
+
+        print(f"\n=== Codebook Quality ({len(cb)} entries) ===")
+        print(f"{'Code':<6} | {'Phrase':<50} | {'Len':>4}")
+        print("-" * 65)
+        for code, phrase in sorted(cb.items()):
+            print(f"{code:<6} | {phrase[:50]:<50} | {len(phrase):>4}")
+
+        # Every entry should have phrase longer than code
+        for code, phrase in cb.items():
+            assert len(phrase) > len(code), f"Code {code} maps to shorter phrase '{phrase}'"

package/skills/claw-compactor/tests/test_pipeline.py

@@ -0,0 +1,109 @@
+"""Tests for the full pipeline mode."""
+import argparse
+import json
+import sys
+import pytest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+from mem_compress import cmd_full, _count_tokens_in_workspace
+
+
+class TestFullPipeline:
+    """Test the full pipeline command."""
+
+    def _make_workspace(self, tmp_path):
+        """Create a minimal workspace with memory files."""
+        mem = tmp_path / "memory"
+        mem.mkdir()
+        (tmp_path / "MEMORY.md").write_text(
+            "# Memory\n\n## Decisions\n- Use Python for scripts\n- Use pytest for testing\n\n"
+            "## Notes\n- Hello world\n- Hello world\n\n## Empty Section\n\n"
+        )
+        (tmp_path / "TOOLS.md").write_text(
+            "# Tools\n| Name | Version |\n|------|--------|\n| Python | 3.11 |\n| Node | 20 |\n"
+        )
+        (mem / "2026-01-01.md").write_text("# Jan 1\n- Did some stuff\n- More stuff\n")
+        return tmp_path
+
+    def test_full_pipeline_runs(self, tmp_path, capsys, monkeypatch):
+        ws = self._make_workspace(tmp_path)
+        # Prevent observe from scanning real sessions directory
+        monkeypatch.setattr("os.path.expanduser", lambda p: str(tmp_path / "fake_home") if ".openclaw" in p else p)
+        args = argparse.Namespace(json=False, since=None)
+        result = cmd_full(ws, args)
+        assert result == 0
+        out = capsys.readouterr().out
+        assert "Tokens saved:" in out
+        assert "Before:" in out
+        assert "After:" in out
+
+    def test_full_pipeline_completes_without_error(self, tmp_path, monkeypatch):
+        ws = self._make_workspace(tmp_path)
+        monkeypatch.setattr("os.path.expanduser", lambda p: str(tmp_path / "fake_home") if ".openclaw" in p else p)
+        args = argparse.Namespace(json=False, since=None)
+        result = cmd_full(ws, args)
+        assert result == 0
+
+    def test_full_pipeline_preserves_files(self, tmp_path, monkeypatch):
+        ws = self._make_workspace(tmp_path)
+        monkeypatch.setattr("os.path.expanduser", lambda p: str(tmp_path / "fake_home") if ".openclaw" in p else p)
+        args = argparse.Namespace(json=False, since=None)
+        cmd_full(ws, args)
+        assert (ws / "MEMORY.md").exists()
+        assert (ws / "TOOLS.md").exists()
+
+
+class TestObserveCommand:
+    """Test the observe command with mock sessions."""
+
+    def test_observe_no_sessions_dir(self, tmp_path, capsys):
+        from mem_compress import cmd_observe
+        args = argparse.Namespace(json=False, since=None)
+        # Patch sessions dir to nonexistent path
+        import mem_compress
+        import os
+        old_expand = os.path.expanduser
+        def mock_expand(p):
+            if ".openclaw/agents/main/sessions" in p:
+                return str(tmp_path / "nonexistent")
+            return old_expand(p)
+        
+        with pytest.MonkeyPatch.context() as mp:
+            mp.setattr(os.path, "expanduser", mock_expand)
+            result = cmd_observe(tmp_path, args)
+        # Should return 1 or handle gracefully
+        assert result in (0, 1)
+
+    def test_observe_with_empty_sessions(self, tmp_path, capsys):
+        from mem_compress import cmd_observe
+        sessions = tmp_path / "sessions"
+        sessions.mkdir()
+        # Point observe to tmp workspace with sessions subdir
+        args = argparse.Namespace(json=False, since=None)
+        
+        import mem_compress
+        import os
+        old_expand = os.path.expanduser
+        def mock_expand(p):
+            if ".openclaw/agents/main/sessions" in p:
+                return str(tmp_path / "nonexistent")
+            return old_expand(p)
+        
+        with pytest.MonkeyPatch.context() as mp:
+            mp.setattr(os.path, "expanduser", mock_expand)
+            # Create sessions dir under workspace
+            (tmp_path / "sessions").mkdir(exist_ok=True)
+            result = cmd_observe(tmp_path, args)
+
+    def test_observe_tracker_persistence(self, tmp_path):
+        """Test that .observed-sessions.json is maintained."""
+        from mem_compress import cmd_observe
+        mem = tmp_path / "memory"
+        mem.mkdir()
+        tracker = mem / ".observed-sessions.json"
+        tracker.write_text(json.dumps({"old-session.jsonl": "2026-01-01T00:00:00"}))
+        
+        # Read it back
+        data = json.loads(tracker.read_text())
+        assert "old-session.jsonl" in data