codymaster 7.0.1 → 7.0.3

package/skills/cm-content-factory/tests/test_agent_dispatcher.py

@@ -0,0 +1,125 @@
+"""Tests for agent_dispatcher.py — Task queue, claiming, and stale detection."""
+import json
+import sys
+import time
+import pytest
+from pathlib import Path
+from datetime import datetime, timedelta
+
+SCRIPTS_DIR = Path(__file__).resolve().parent.parent / "scripts"
+sys.path.insert(0, str(SCRIPTS_DIR))
+
+
+class TestAgentDispatcher:
+    """Test AgentDispatcher class."""
+
+    def test_enqueue(self, tmp_path):
+        from agent_dispatcher import AgentDispatcher
+        d = AgentDispatcher(str(tmp_path))
+        task = d.enqueue("task-1", "write", {"topic": "SEO"})
+        assert task["id"] == "task-1"
+        assert task["status"] == "queued"
+        assert task["type"] == "write"
+
+    def test_no_duplicate_enqueue(self, tmp_path):
+        from agent_dispatcher import AgentDispatcher
+        d = AgentDispatcher(str(tmp_path))
+        d.enqueue("task-1", "write")
+        d.enqueue("task-1", "write")
+        q = d.get_queue()
+        assert q["total"] == 1
+
+    def test_claim_next(self, tmp_path):
+        from agent_dispatcher import AgentDispatcher
+        d = AgentDispatcher(str(tmp_path))
+        d.enqueue("task-1", "write")
+        task = d.claim_next("agent-1")
+        assert task is not None
+        assert task["status"] == "claimed"
+        assert task["claimed_by"] == "agent-1"
+
+    def test_claim_empty_queue_returns_none(self, tmp_path):
+        from agent_dispatcher import AgentDispatcher
+        d = AgentDispatcher(str(tmp_path))
+        assert d.claim_next("agent-1") is None
+
+    def test_claim_by_type(self, tmp_path):
+        from agent_dispatcher import AgentDispatcher
+        d = AgentDispatcher(str(tmp_path))
+        d.enqueue("task-1", "write")
+        d.enqueue("task-2", "audit")
+        task = d.claim_next("agent-1", task_type="audit")
+        assert task["id"] == "task-2"
+
+    def test_complete(self, tmp_path):
+        from agent_dispatcher import AgentDispatcher
+        d = AgentDispatcher(str(tmp_path))
+        d.enqueue("task-1", "write")
+        d.claim_next("agent-1")
+        d.complete("task-1", "agent-1", {"result": "ok"})
+        q = d.get_queue()
+        assert q["done"] == 1
+
+    def test_fail_with_retry(self, tmp_path):
+        from agent_dispatcher import AgentDispatcher
+        d = AgentDispatcher(str(tmp_path))
+        d.enqueue("task-1", "write")
+        d.claim_next("agent-1")
+        d.fail("task-1", "agent-1", "timeout")
+        q = d.get_queue()
+        task = next(t for t in q["tasks"] if t["id"] == "task-1")
+        assert task["status"] == "queued"  # requeued for retry
+        assert task["retries"] == 1
+
+    def test_fail_exceeds_max_retries(self, tmp_path):
+        from agent_dispatcher import AgentDispatcher
+        d = AgentDispatcher(str(tmp_path))
+        d.enqueue("task-1", "write")
+        for _ in range(3):
+            d.claim_next("agent-1")
+            d.fail("task-1", "agent-1", "error")
+        q = d.get_queue()
+        task = next(t for t in q["tasks"] if t["id"] == "task-1")
+        assert task["status"] == "failed"
+        assert task["retries"] == 3
+
+    def test_priority_ordering(self, tmp_path):
+        from agent_dispatcher import AgentDispatcher
+        d = AgentDispatcher(str(tmp_path))
+        d.enqueue("low", "write", priority=10)
+        d.enqueue("high", "write", priority=1)
+        d.enqueue("mid", "write", priority=5)
+        task = d.claim_next("agent-1")
+        assert task["id"] == "high"
+
+    def test_enqueue_batch(self, tmp_path):
+        from agent_dispatcher import AgentDispatcher
+        d = AgentDispatcher(str(tmp_path))
+        tasks = [
+            {"id": "b-1", "type": "write"},
+            {"id": "b-2", "type": "write"},
+            {"id": "b-3", "type": "audit"},
+        ]
+        added = d.enqueue_batch(tasks)
+        assert len(added) == 3
+        q = d.get_queue()
+        assert q["total"] == 3
+
+    def test_queue_summary(self, tmp_path):
+        from agent_dispatcher import AgentDispatcher
+        d = AgentDispatcher(str(tmp_path))
+        d.enqueue("t1", "write")
+        d.enqueue("t2", "write")
+        d.claim_next("agent-1")
+        q = d.get_queue()
+        assert q["queued"] == 1
+        assert q["claimed"] == 1
+
+    def test_reset(self, tmp_path):
+        from agent_dispatcher import AgentDispatcher
+        d = AgentDispatcher(str(tmp_path))
+        d.enqueue("t1", "write")
+        d.enqueue("t2", "write")
+        d.reset()
+        q = d.get_queue()
+        assert q["total"] == 0

package/skills/cm-content-factory/tests/test_memory.py

@@ -0,0 +1,128 @@
+"""Tests for memory.py — MemoryEngine 3-layer memory system."""
+import json
+import sys
+import pytest
+from pathlib import Path
+from datetime import datetime
+
+SCRIPTS_DIR = Path(__file__).resolve().parent.parent / "scripts"
+sys.path.insert(0, str(SCRIPTS_DIR))
+
+
+class TestMemoryEngineInit:
+    """Test MemoryEngine initialization."""
+
+    def test_creates_directory_structure(self, tmp_project):
+        """Should create semantic/, episodic/, working/ directories."""
+        from memory import MemoryEngine
+        _, config_path, _ = tmp_project
+        engine = MemoryEngine(str(config_path))
+
+        memory_dir = tmp_project[0] / "memory"
+        assert (memory_dir / "semantic").is_dir()
+        assert (memory_dir / "episodic").is_dir()
+        assert (memory_dir / "working").is_dir()
+
+    def test_creates_semantic_files(self, tmp_project):
+        """Should initialize default semantic memory files."""
+        from memory import MemoryEngine
+        _, config_path, _ = tmp_project
+        engine = MemoryEngine(str(config_path))
+
+        semantic_dir = tmp_project[0] / "memory" / "semantic"
+        assert (semantic_dir / "writing_patterns.json").exists()
+        assert (semantic_dir / "seo_patterns.json").exists()
+        assert (semantic_dir / "niche_knowledge.json").exists()
+        assert (semantic_dir / "mistakes.json").exists()
+
+    def test_creates_working_session(self, tmp_project):
+        """Should initialize current_session.json."""
+        from memory import MemoryEngine
+        _, config_path, _ = tmp_project
+        engine = MemoryEngine(str(config_path))
+
+        session_file = tmp_project[0] / "memory" / "working" / "current_session.json"
+        assert session_file.exists()
+
+
+class TestWritingPatterns:
+    """Test writing pattern add/update."""
+
+    def test_add_new_pattern(self, tmp_project):
+        """Should add a new pattern with default confidence 0.5."""
+        from memory import MemoryEngine
+        _, config_path, _ = tmp_project
+        engine = MemoryEngine(str(config_path))
+
+        engine.add_writing_pattern("test_pattern", {"description": "Use short sentences"})
+
+        data = engine.load_semantic("writing_patterns")
+        assert "test_pattern" in data["patterns"]
+        assert data["patterns"]["test_pattern"]["confidence"] == 0.5
+        assert data["patterns"]["test_pattern"]["applications"] == 1
+
+    def test_update_existing_pattern_increases_confidence(self, tmp_project):
+        """Applying same pattern again should increase confidence and applications."""
+        from memory import MemoryEngine
+        _, config_path, _ = tmp_project
+        engine = MemoryEngine(str(config_path))
+
+        engine.add_writing_pattern("p1", {"description": "Be concise"})
+        engine.add_writing_pattern("p1", {"description": "Be concise"})
+
+        data = engine.load_semantic("writing_patterns")
+        assert data["patterns"]["p1"]["applications"] == 2
+        assert data["patterns"]["p1"]["confidence"] == 0.55  # 0.5 + 0.05
+
+
+class TestWritingContext:
+    """Test get_writing_context() aggregation."""
+
+    def test_empty_context_returns_structure(self, tmp_project):
+        """Even with no data, should return proper dict structure."""
+        from memory import MemoryEngine
+        _, config_path, _ = tmp_project
+        engine = MemoryEngine(str(config_path))
+
+        ctx = engine.get_writing_context()
+        assert "style" in ctx
+        assert "top_patterns" in ctx
+        assert "avoid" in ctx
+        assert "seo_rules" in ctx
+        assert "domain_knowledge" in ctx
+
+    def test_context_includes_added_patterns(self, tmp_project):
+        """Added patterns should appear in top_patterns."""
+        from memory import MemoryEngine
+        _, config_path, _ = tmp_project
+        engine = MemoryEngine(str(config_path))
+
+        engine.add_writing_pattern("p1", {"description": "Short sentences"})
+        ctx = engine.get_writing_context()
+        assert len(ctx["top_patterns"]) >= 1
+
+
+class TestSessionLifecycle:
+    """Test session start/end cycle."""
+
+    def test_start_session_returns_id(self, tmp_project):
+        """start_session should return a session ID string."""
+        from memory import MemoryEngine
+        _, config_path, _ = tmp_project
+        engine = MemoryEngine(str(config_path))
+
+        sid = engine.start_session(phase="write")
+        assert sid.startswith("ses-")
+        assert len(sid) > 4
+
+    def test_start_session_creates_working_file(self, tmp_project):
+        """Should update current_session.json with new session data."""
+        from memory import MemoryEngine
+        _, config_path, _ = tmp_project
+        engine = MemoryEngine(str(config_path))
+
+        engine.start_session(phase="audit")
+        session_file = tmp_project[0] / "memory" / "working" / "current_session.json"
+        data = json.loads(session_file.read_text())
+        assert data["phase"] == "audit"
+        assert data["session_id"].startswith("ses-")

package/skills/cm-content-factory/tests/test_pipeline.py

@@ -0,0 +1,107 @@
+"""Tests for pipeline.py — Config loading, validation, hooks, and phase execution."""
+import json
+import sys
+import pytest
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+SCRIPTS_DIR = Path(__file__).resolve().parent.parent / "scripts"
+sys.path.insert(0, str(SCRIPTS_DIR))
+
+
+class TestValidateConfig:
+    """Test validate_config() function."""
+
+    def test_valid_config_passes(self, minimal_config):
+        """Happy path: valid config returns True."""
+        from pipeline import validate_config
+        assert validate_config(minimal_config) is True
+
+    def test_missing_niche_fails(self, minimal_config):
+        """Missing top-level 'niche' key should fail."""
+        from pipeline import validate_config
+        del minimal_config["niche"]
+        assert validate_config(minimal_config) is False
+
+    def test_missing_brand_name_fails(self, bad_config_missing_brand):
+        """Missing brand.name should fail."""
+        from pipeline import validate_config
+        assert validate_config(bad_config_missing_brand) is False
+
+    def test_missing_sources_type_fails(self, minimal_config):
+        """Missing sources.type should fail."""
+        from pipeline import validate_config
+        del minimal_config["sources"]["type"]
+        assert validate_config(minimal_config) is False
+
+    def test_missing_output_content_dir_fails(self, minimal_config):
+        """Missing output.content_dir should fail."""
+        from pipeline import validate_config
+        del minimal_config["output"]["content_dir"]
+        assert validate_config(minimal_config) is False
+
+    def test_empty_config_fails(self):
+        """Empty dict should fail."""
+        from pipeline import validate_config
+        assert validate_config({}) is False
+
+    def test_missing_content_article_types_fails(self, minimal_config):
+        """Missing content.article_types should fail."""
+        from pipeline import validate_config
+        del minimal_config["content"]["article_types"]
+        assert validate_config(minimal_config) is False
+
+
+class TestFireHooks:
+    """Test fire_hooks() function."""
+
+    def test_no_hooks_returns_silently(self, minimal_config):
+        """Config without hooks should not raise."""
+        from pipeline import fire_hooks
+        # Should not raise
+        fire_hooks(minimal_config, "pre_write")
+
+    def test_empty_hooks_returns_silently(self):
+        """Config with empty hooks dict should not raise."""
+        from pipeline import fire_hooks
+        config = {"extensions": {"hooks": {}}}
+        fire_hooks(config, "pre_write")
+
+    def test_nonexistent_hook_name_returns_silently(self):
+        """Requesting a hook name that doesn't exist should not raise."""
+        from pipeline import fire_hooks
+        config = {"extensions": {"hooks": {"post_write": ["some_script.py"]}}}
+        fire_hooks(config, "pre_audit")  # Different hook name
+
+
+class TestLoadConfig:
+    """Test load_config() function."""
+
+    def test_load_valid_config(self, tmp_project):
+        """Should load and return config dict from file."""
+        tmp_path, config_path, expected_config = tmp_project
+        from pipeline import load_config, CONFIG_FILE
+
+        # Monkey-patch CONFIG_FILE to our temp file
+        import pipeline
+        original = pipeline.CONFIG_FILE
+        pipeline.CONFIG_FILE = config_path
+        try:
+            result = load_config()
+            assert result["niche"] == "test-niche"
+            assert result["brand"]["name"] == "Test Brand"
+        finally:
+            pipeline.CONFIG_FILE = original
+
+    def test_load_missing_config_exits(self, tmp_path):
+        """Should sys.exit(1) when config file doesn't exist."""
+        import pipeline
+        original = pipeline.CONFIG_FILE
+        pipeline.CONFIG_FILE = tmp_path / "nonexistent.json"
+        try:
+            with pytest.raises(SystemExit) as exc_info:
+                from pipeline import load_config
+                load_config()
+            assert exc_info.value.code == 1
+        finally:
+            pipeline.CONFIG_FILE = original

package/skills/cm-content-factory/tests/test_research.py

@@ -0,0 +1,56 @@
+"""Tests for research.py — ResearchEngine initialization and query generation."""
+import json
+import sys
+import pytest
+from pathlib import Path
+
+SCRIPTS_DIR = Path(__file__).resolve().parent.parent / "scripts"
+sys.path.insert(0, str(SCRIPTS_DIR))
+
+
+class TestResearchEngineInit:
+    """Test ResearchEngine initialization."""
+
+    def test_loads_config(self, tmp_project):
+        """Should load config from file path."""
+        from research import ResearchEngine
+        _, config_path, config = tmp_project
+        engine = ResearchEngine(str(config_path))
+        assert engine.config["niche"] == "test-niche"
+
+    def test_sets_project_root(self, tmp_project):
+        """Should derive project_root from config path."""
+        from research import ResearchEngine
+        _, config_path, _ = tmp_project
+        engine = ResearchEngine(str(config_path))
+        assert engine.project_root == tmp_project[0]
+
+
+class TestGenerateQueries:
+    """Test _generate_queries() method."""
+
+    def test_returns_list(self, tmp_project):
+        """Should return a list of query strings."""
+        from research import ResearchEngine
+        _, config_path, _ = tmp_project
+        engine = ResearchEngine(str(config_path))
+        queries = engine._generate_queries("massage therapy benefits")
+        assert isinstance(queries, list)
+        assert len(queries) > 0
+
+    def test_queries_contain_topic(self, tmp_project):
+        """At least one query should contain the topic words."""
+        from research import ResearchEngine
+        _, config_path, _ = tmp_project
+        engine = ResearchEngine(str(config_path))
+        queries = engine._generate_queries("acupuncture")
+        assert any("acupuncture" in q.lower() for q in queries)
+
+    def test_queries_contain_niche(self, tmp_project):
+        """Queries should incorporate niche context."""
+        from research import ResearchEngine
+        _, config_path, _ = tmp_project
+        engine = ResearchEngine(str(config_path))
+        queries = engine._generate_queries("benefits")
+        # Should generate meaningful queries, not just empty strings
+        assert all(len(q) > 0 for q in queries)

package/skills/cm-content-factory/tests/test_state_manager.py

@@ -0,0 +1,131 @@
+"""Tests for state_manager.py — State persistence, events, and thread safety."""
+import json
+import sys
+import pytest
+from pathlib import Path
+
+SCRIPTS_DIR = Path(__file__).resolve().parent.parent / "scripts"
+sys.path.insert(0, str(SCRIPTS_DIR))
+
+
+class TestStateManager:
+    """Test StateManager class."""
+
+    def test_default_state(self, tmp_path):
+        from state_manager import StateManager
+        sm = StateManager(str(tmp_path))
+        state = sm.load()
+        assert state["status"] == "idle"
+        assert state["version"] == "2.0"
+        assert len(state["pipeline"]["phases"]) == 6
+
+    def test_save_and_load(self, tmp_path):
+        from state_manager import StateManager
+        sm = StateManager(str(tmp_path))
+        sm.update_phase("extract", "running", progress=0.5)
+        state = sm.load()
+        assert state["pipeline"]["phases"]["extract"]["status"] == "running"
+        assert state["pipeline"]["phases"]["extract"]["progress"] == 0.5
+
+    def test_phase_lifecycle(self, tmp_path):
+        from state_manager import StateManager
+        sm = StateManager(str(tmp_path))
+        sm.update_phase("write", "running", progress=0.0)
+        sm.update_phase("write", "running", progress=0.5)
+        sm.update_phase("write", "done", progress=1.0)
+        state = sm.load()
+        p = state["pipeline"]["phases"]["write"]
+        assert p["status"] == "done"
+        assert p["progress"] == 1.0
+        assert p["started_at"] is not None
+        assert p["finished_at"] is not None
+
+    def test_add_task(self, tmp_path):
+        from state_manager import StateManager
+        sm = StateManager(str(tmp_path))
+        sm.add_task("task-1", "running", {"topic": "SEO"})
+        state = sm.load()
+        assert len(state["tasks"]) == 1
+        assert state["tasks"][0]["id"] == "task-1"
+        assert state["tasks"][0]["meta"]["topic"] == "SEO"
+
+    def test_update_existing_task(self, tmp_path):
+        from state_manager import StateManager
+        sm = StateManager(str(tmp_path))
+        sm.add_task("task-1", "running")
+        sm.add_task("task-1", "done", {"result": "ok"})
+        state = sm.load()
+        assert len(state["tasks"]) == 1
+        assert state["tasks"][0]["status"] == "done"
+
+    def test_update_tokens(self, tmp_path):
+        from state_manager import StateManager
+        sm = StateManager(str(tmp_path))
+        sm.update_tokens("gemini", input_tokens=100, output_tokens=50, cost_usd=0.001)
+        sm.update_tokens("gemini", input_tokens=200, output_tokens=100, cost_usd=0.002)
+        state = sm.load()
+        assert state["tokens"]["total_input"] == 300
+        assert state["tokens"]["total_output"] == 150
+        assert state["tokens"]["total_cost_usd"] == 0.003
+        assert state["tokens"]["providers"]["gemini"]["requests"] == 2
+
+    def test_budget_check(self, tmp_path):
+        from state_manager import StateManager
+        sm = StateManager(str(tmp_path))
+        sm.set_budget(0.01)
+        assert sm.check_budget() is True
+        sm.update_tokens("gemini", cost_usd=0.011)
+        assert sm.check_budget() is False
+
+    def test_add_error(self, tmp_path):
+        from state_manager import StateManager
+        sm = StateManager(str(tmp_path))
+        sm.add_error("write", "API timeout")
+        state = sm.load()
+        assert len(state["errors"]) == 1
+        assert state["errors"][0]["message"] == "API timeout"
+
+    def test_event_logging(self, tmp_path):
+        from state_manager import StateManager
+        sm = StateManager(str(tmp_path))
+        sm.log_event("info", "test event", {"key": "val"})
+        sm.log_event("error", "test error")
+        events = sm.get_recent_events(10)
+        assert len(events) == 2
+        assert events[0]["level"] == "info"
+        assert events[1]["level"] == "error"
+
+    def test_reset(self, tmp_path):
+        from state_manager import StateManager
+        sm = StateManager(str(tmp_path))
+        sm.update_phase("write", "done", progress=1.0)
+        sm.add_task("t1", "done")
+        sm.reset()
+        state = sm.load()
+        assert state["status"] == "idle"
+        assert len(state["tasks"]) == 0
+
+    def test_get_snapshot(self, tmp_path):
+        from state_manager import StateManager
+        sm = StateManager(str(tmp_path))
+        sm.log_event("info", "snapshot test")
+        snap = sm.get_snapshot()
+        assert "recent_events" in snap
+        assert len(snap["recent_events"]) >= 1
+
+    def test_overall_status_completed(self, tmp_path):
+        from state_manager import StateManager
+        sm = StateManager(str(tmp_path))
+        for phase in ["extract", "plan", "write", "audit", "seo", "publish"]:
+            sm.update_phase(phase, "done", progress=1.0)
+        state = sm.load()
+        assert state["status"] == "completed"
+
+    def test_overall_status_error(self, tmp_path):
+        from state_manager import StateManager
+        sm = StateManager(str(tmp_path))
+        sm.update_phase("extract", "done")
+        sm.update_phase("plan", "failed", error="Network error")
+        state = sm.load()
+        assert state["status"] == "error"
+        assert len(state["errors"]) == 1

package/skills/cm-content-factory/tests/test_token_manager.py

@@ -0,0 +1,110 @@
+"""Tests for token_manager.py — Token tracking, budget, circuit breaker, and rate limiting."""
+import json
+import sys
+import pytest
+from pathlib import Path
+
+SCRIPTS_DIR = Path(__file__).resolve().parent.parent / "scripts"
+sys.path.insert(0, str(SCRIPTS_DIR))
+
+
+class TestTokenManager:
+    """Test TokenManager class."""
+
+    def test_estimate_cost_gemini(self):
+        from token_manager import TokenManager
+        tm = TokenManager()
+        cost = tm.estimate_cost("gemini", 1_000_000, 1_000_000)
+        assert cost == 0.75  # 0.15 + 0.60
+
+    def test_estimate_cost_unknown_provider(self):
+        from token_manager import TokenManager
+        tm = TokenManager()
+        cost = tm.estimate_cost("unknown", 1_000_000, 1_000_000)
+        assert cost == 4.0  # fallback 1.0 + 3.0
+
+    def test_record_usage(self, tmp_path):
+        from token_manager import TokenManager
+        tm = TokenManager(str(tmp_path))
+        cost = tm.record_usage("gemini", input_tokens=1000, output_tokens=500, task_id="test-1")
+        assert cost > 0
+        s = tm.get_summary()
+        assert s["total_input_tokens"] == 1000
+        assert s["total_output_tokens"] == 500
+        assert s["total_requests"] == 1
+        assert s["providers"]["gemini"]["requests"] == 1
+
+    def test_multiple_providers(self, tmp_path):
+        from token_manager import TokenManager
+        tm = TokenManager(str(tmp_path))
+        tm.record_usage("gemini", input_tokens=1000, output_tokens=500)
+        tm.record_usage("claude-sonnet", input_tokens=2000, output_tokens=1000)
+        s = tm.get_summary()
+        assert len(s["providers"]) == 2
+        assert s["total_input_tokens"] == 3000
+
+    def test_budget_within(self, tmp_path):
+        from token_manager import TokenManager
+        tm = TokenManager(str(tmp_path), budget_usd=10.0)
+        tm.record_usage("gemini", input_tokens=1000, output_tokens=500)
+        assert tm.check_budget() is True
+
+    def test_budget_exceeded(self, tmp_path):
+        from token_manager import TokenManager
+        tm = TokenManager(str(tmp_path), budget_usd=0.0001)
+        tm.record_usage("gemini", input_tokens=100000, output_tokens=50000)
+        assert tm.check_budget() is False
+
+    def test_budget_status(self, tmp_path):
+        from token_manager import TokenManager
+        tm = TokenManager(str(tmp_path), budget_usd=1.0)
+        tm.record_usage("gemini", input_tokens=1000, output_tokens=500)
+        status = tm.get_budget_status()
+        assert status["limit_usd"] == 1.0
+        assert status["within_budget"] is True
+        assert status["percentage_used"] >= 0
+
+    def test_circuit_breaker_closed(self, tmp_path):
+        from token_manager import TokenManager
+        tm = TokenManager(str(tmp_path))
+        assert tm.is_circuit_open("gemini") is False
+
+    def test_circuit_breaker_opens(self, tmp_path):
+        from token_manager import TokenManager
+        tm = TokenManager(str(tmp_path))
+        for _ in range(5):
+            tm.record_usage("gemini", input_tokens=100, output_tokens=50, success=False)
+        assert tm.is_circuit_open("gemini") is True
+
+    def test_circuit_breaker_resets_on_success(self, tmp_path):
+        from token_manager import TokenManager
+        tm = TokenManager(str(tmp_path))
+        for _ in range(3):
+            tm.record_usage("gemini", input_tokens=100, output_tokens=50, success=False)
+        tm.record_usage("gemini", input_tokens=100, output_tokens=50, success=True)
+        assert tm.is_circuit_open("gemini") is False
+
+    def test_backoff_seconds(self, tmp_path):
+        from token_manager import TokenManager
+        tm = TokenManager(str(tmp_path))
+        assert tm.get_backoff_seconds("gemini") == 0.0
+        tm.record_usage("gemini", success=False)
+        assert tm.get_backoff_seconds("gemini") == 2.0
+        tm.record_usage("gemini", success=False)
+        assert tm.get_backoff_seconds("gemini") == 4.0
+
+    def test_reset(self, tmp_path):
+        from token_manager import TokenManager
+        tm = TokenManager(str(tmp_path))
+        tm.record_usage("gemini", input_tokens=1000, output_tokens=500)
+        tm.reset()
+        s = tm.get_summary()
+        assert s["total_input_tokens"] == 0
+        assert len(s["providers"]) == 0
+
+    def test_failure_tracking(self, tmp_path):
+        from token_manager import TokenManager
+        tm = TokenManager(str(tmp_path))
+        tm.record_usage("gemini", input_tokens=100, success=False)
+        s = tm.get_summary()
+        assert s["providers"]["gemini"]["failures"] == 1