@geravant/sinain 1.0.1

package/sinain-memory/tests/test_tick_evaluator.py

@@ -0,0 +1,430 @@
+"""Tests for tick_evaluator.py + eval/schemas.py + eval/assertions.py + common retry."""
+
+import json
+from pathlib import Path
+from unittest.mock import patch, call
+
+from common import LLMError, call_llm_with_fallback
+from eval.schemas import validate, SCHEMA_REGISTRY
+from eval.assertions import (
+    assert_playbook_under_limit,
+    assert_curator_respected_directive,
+    assert_no_repeat_action,
+    assert_signal_confidence_threshold,
+    assert_insight_char_limit,
+    assert_skip_reason_specific,
+    assert_miner_references_sources,
+    assert_playbook_header_footer_intact,
+    assert_schema_valid,
+    run_tick_assertions,
+)
+from tick_evaluator import validate_tick_schemas, load_eval_config
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Schema validation tests
+# ═══════════════════════════════════════════════════════════════════════════
+
+class TestSchemaValidation:
+    def test_valid_signal_analyzer(self):
+        data = {"signals": [{"description": "signal1", "priority": "high"}], "recommendedAction": None, "idle": False}
+        errors = validate(data, SCHEMA_REGISTRY["signal_analyzer"])
+        assert errors == []
+
+    def test_valid_signal_with_action(self):
+        data = {
+            "signals": [{"description": "sig", "priority": "medium"}],
+            "recommendedAction": {"action": "sessions_spawn", "task": "debug", "confidence": 0.8},
+            "idle": False,
+        }
+        errors = validate(data, SCHEMA_REGISTRY["signal_analyzer"])
+        assert errors == []
+
+    def test_valid_signal_with_null_task(self):
+        data = {
+            "signals": [{"description": "idle detected", "priority": "low"}],
+            "recommendedAction": {"action": "skip", "task": None, "confidence": 0.9},
+            "idle": True,
+        }
+        errors = validate(data, SCHEMA_REGISTRY["signal_analyzer"])
+        assert errors == []
+
+    def test_invalid_signal_missing_required(self):
+        data = {"signals": [{"description": "sig", "priority": "high"}]}  # missing idle, recommendedAction
+        errors = validate(data, SCHEMA_REGISTRY["signal_analyzer"])
+        assert any("idle" in e for e in errors)
+
+    def test_valid_feedback_analyzer(self):
+        data = {
+            "feedbackScores": {"avg": 0.5, "high": ["a"], "low": ["b"]},
+            "effectiveness": {"outputs": 10, "positive": 7, "negative": 1, "neutral": 2, "rate": 0.7},
+            "curateDirective": "normal",
+            "interpretation": "Good patterns",
+        }
+        errors = validate(data, SCHEMA_REGISTRY["feedback_analyzer"])
+        assert errors == []
+
+    def test_invalid_directive_value(self):
+        data = {
+            "feedbackScores": {"avg": 0.5},
+            "effectiveness": {"outputs": 0, "positive": 0, "negative": 0, "neutral": 0, "rate": 0.0},
+            "curateDirective": "invalid_value",
+        }
+        errors = validate(data, SCHEMA_REGISTRY["feedback_analyzer"])
+        assert any("curateDirective" in e or "not in" in e for e in errors)
+
+    def test_valid_memory_miner(self):
+        data = {
+            "findings": "Found patterns",
+            "newPatterns": ["pattern1"],
+            "minedSources": ["2026-02-21.md"],
+        }
+        errors = validate(data, SCHEMA_REGISTRY["memory_miner"])
+        assert errors == []
+
+    def test_valid_playbook_curator(self):
+        data = {
+            "changes": {"added": ["new"], "pruned": ["old"], "promoted": []},
+            "staleItemActions": [],
+            "playbookLines": 25,
+        }
+        errors = validate(data, SCHEMA_REGISTRY["playbook_curator"])
+        assert errors == []
+
+    def test_valid_insight_skip(self):
+        data = {"skip": True, "skipReason": "No new patterns since last analysis"}
+        errors = validate(data, SCHEMA_REGISTRY["insight_synthesizer"])
+        assert errors == []
+
+    def test_valid_insight_output(self):
+        data = {
+            "skip": False,
+            "suggestion": "Try frame batching",
+            "insight": "Evening correlates with exploration",
+            "totalChars": 55,
+        }
+        errors = validate(data, SCHEMA_REGISTRY["insight_synthesizer"])
+        assert errors == []
+
+    def test_valid_insight_without_skip(self):
+        data = {
+            "suggestion": "Try frame batching",
+            "insight": "Evening correlates with exploration",
+            "totalChars": 55,
+        }
+        errors = validate(data, SCHEMA_REGISTRY["insight_synthesizer"])
+        assert errors == []
+
+    def test_confidence_out_of_range(self):
+        data = {
+            "signals": [],
+            "recommendedAction": {"action": "sessions_spawn", "task": "x", "confidence": 1.5},
+            "idle": False,
+        }
+        errors = validate(data, SCHEMA_REGISTRY["signal_analyzer"])
+        # oneOf fails because the object variant rejects confidence > 1.0
+        assert len(errors) > 0
+        assert any("oneOf" in e or "maximum" in e for e in errors)
+
+    def test_negative_playbook_lines(self):
+        data = {
+            "changes": {"added": [], "pruned": [], "promoted": []},
+            "playbookLines": -1,
+        }
+        errors = validate(data, SCHEMA_REGISTRY["playbook_curator"])
+        assert any("minimum" in e for e in errors)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Assertion tests
+# ═══════════════════════════════════════════════════════════════════════════
+
+class TestPlaybookUnderLimit:
+    def test_under_limit(self):
+        r = assert_playbook_under_limit({"playbookLines": 30})
+        assert r["passed"] is True
+
+    def test_at_limit(self):
+        r = assert_playbook_under_limit({"playbookLines": 50})
+        assert r["passed"] is True
+
+    def test_over_limit(self):
+        r = assert_playbook_under_limit({"playbookLines": 55})
+        assert r["passed"] is False
+
+    def test_custom_limit(self):
+        r = assert_playbook_under_limit({"playbookLines": 80}, limit=100)
+        assert r["passed"] is True
+
+
+class TestCuratorRespectedDirective:
+    def test_aggressive_prune_with_pruning(self):
+        r = assert_curator_respected_directive(
+            {"changes": {"added": [], "pruned": ["x"], "promoted": []}},
+            "aggressive_prune",
+        )
+        assert r["passed"] is True
+
+    def test_aggressive_prune_without_pruning(self):
+        r = assert_curator_respected_directive(
+            {"changes": {"added": ["new"], "pruned": [], "promoted": []}},
+            "aggressive_prune",
+        )
+        assert r["passed"] is False
+
+    def test_stability_conservative(self):
+        r = assert_curator_respected_directive(
+            {"changes": {"added": ["a"], "pruned": [], "promoted": []}},
+            "stability",
+        )
+        assert r["passed"] is True
+
+    def test_stability_too_aggressive(self):
+        r = assert_curator_respected_directive(
+            {"changes": {"added": [], "pruned": ["a", "b", "c", "d"], "promoted": []}},
+            "stability",
+        )
+        assert r["passed"] is False
+
+    def test_normal_anything_goes(self):
+        r = assert_curator_respected_directive(
+            {"changes": {"added": ["a", "b"], "pruned": ["c"], "promoted": []}},
+            "normal",
+        )
+        assert r["passed"] is True
+
+
+class TestNoRepeatAction:
+    def test_no_action(self):
+        r = assert_no_repeat_action({"recommendedAction": None}, [])
+        assert r["passed"] is True
+
+    def test_skip_action(self):
+        r = assert_no_repeat_action({"recommendedAction": {"action": "skip"}}, [])
+        assert r["passed"] is True
+
+    def test_distinct_action(self):
+        recent = [{"actionsConsidered": [{"chosen": True, "reason": "Research Flutter overlays"}]}]
+        r = assert_no_repeat_action(
+            {"recommendedAction": {"action": "sessions_spawn", "task": "Debug OCR backpressure"}},
+            recent,
+        )
+        assert r["passed"] is True
+
+    def test_repeated_action(self):
+        recent = [{"actionsConsidered": [{"chosen": True, "reason": "Debug OCR backpressure issue"}]}]
+        r = assert_no_repeat_action(
+            {"recommendedAction": {"action": "sessions_spawn", "task": "Debug OCR backpressure"}},
+            recent,
+        )
+        assert r["passed"] is False
+
+
+class TestSignalConfidenceThreshold:
+    def test_above_threshold(self):
+        r = assert_signal_confidence_threshold(
+            {"recommendedAction": {"action": "sessions_spawn", "confidence": 0.8}}
+        )
+        assert r["passed"] is True
+
+    def test_below_threshold(self):
+        r = assert_signal_confidence_threshold(
+            {"recommendedAction": {"action": "sessions_spawn", "confidence": 0.3}}
+        )
+        assert r["passed"] is False
+
+    def test_no_confidence(self):
+        r = assert_signal_confidence_threshold(
+            {"recommendedAction": {"action": "sessions_spawn"}}
+        )
+        assert r["passed"] is False
+
+    def test_no_action(self):
+        r = assert_signal_confidence_threshold({"recommendedAction": None})
+        assert r["passed"] is True
+
+
+class TestInsightCharLimit:
+    def test_under_limit(self):
+        r = assert_insight_char_limit({"suggestion": "short", "insight": "also short"})
+        assert r["passed"] is True
+
+    def test_over_limit(self):
+        r = assert_insight_char_limit({"suggestion": "x" * 300, "insight": "y" * 300})
+        assert r["passed"] is False
+
+    def test_skipped_output(self):
+        r = assert_insight_char_limit({"skip": True})
+        assert r["passed"] is True
+
+
+class TestSkipReasonSpecific:
+    def test_specific_reason(self):
+        r = assert_skip_reason_specific({
+            "skip": True,
+            "skipReason": "No new patterns detected in playbook since last tick; mining-index shows 2026-02-21 was already processed"
+        })
+        assert r["passed"] is True
+
+    def test_generic_reason(self):
+        r = assert_skip_reason_specific({"skip": True, "skipReason": "no new data"})
+        assert r["passed"] is False
+
+    def test_no_reason(self):
+        r = assert_skip_reason_specific({"skip": True})
+        assert r["passed"] is False
+
+    def test_not_skipped(self):
+        r = assert_skip_reason_specific({"skip": False})
+        assert r["passed"] is True
+
+
+class TestMinerReferencesSources:
+    def test_valid_sources(self):
+        r = assert_miner_references_sources(
+            {"minedSources": ["2026-02-21.md"]},
+            ["2026-02-21.md", "2026-02-20.md"],
+        )
+        assert r["passed"] is True
+
+    def test_unknown_sources(self):
+        r = assert_miner_references_sources(
+            {"minedSources": ["2026-02-21.md", "fake-file.md"]},
+            ["2026-02-21.md"],
+        )
+        assert r["passed"] is False
+
+    def test_no_sources(self):
+        r = assert_miner_references_sources({"minedSources": []}, [])
+        assert r["passed"] is True
+
+
+class TestPlaybookHeaderFooterIntact:
+    def test_both_present(self):
+        text = "<!-- mining-index: 2026-02-21 -->\nbody\n<!-- effectiveness: rate=0.5 -->"
+        r = assert_playbook_header_footer_intact(text)
+        assert r["passed"] is True
+
+    def test_missing_header(self):
+        r = assert_playbook_header_footer_intact("body\n<!-- effectiveness: rate=0.5 -->")
+        assert r["passed"] is False
+        assert "mining-index" in r["detail"]
+
+    def test_missing_footer(self):
+        r = assert_playbook_header_footer_intact("<!-- mining-index: 2026-02-21 -->\nbody")
+        assert r["passed"] is False
+        assert "effectiveness" in r["detail"]
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Integration: validate_tick_schemas
+# ═══════════════════════════════════════════════════════════════════════════
+
+class TestValidateTickSchemas:
+    def test_full_log_entry(self, sample_log_entry):
+        result = validate_tick_schemas(sample_log_entry)
+        assert result["total"] > 0
+        assert result["valid"] == result["total"]
+        assert result["failures"] == []
+
+    def test_empty_log_entry(self):
+        result = validate_tick_schemas({})
+        assert result["total"] == 0
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Integration: run_tick_assertions
+# ═══════════════════════════════════════════════════════════════════════════
+
+class TestRunTickAssertions:
+    def test_all_pass_on_good_entry(self, sample_log_entry):
+        playbook = "<!-- mining-index: 2026-02-21 -->\nbody\n<!-- effectiveness: rate=0.5 -->"
+        results = run_tick_assertions(sample_log_entry, [], playbook, ["2026-02-21.md"])
+        assert all(r["passed"] for r in results), [r for r in results if not r["passed"]]
+
+    def test_detects_failures(self):
+        bad_entry = {
+            "signals": [],
+            "recommendedAction": {"action": "sessions_spawn", "task": "x", "confidence": 0.2},
+            "playbookChanges": {
+                "changes": {"added": ["a", "b"], "pruned": [], "promoted": []},
+                "playbookLines": 55,
+            },
+            "curateDirective": "aggressive_prune",
+            "output": {"skip": True, "skipReason": "no new data"},
+        }
+        results = run_tick_assertions(bad_entry, [], "", [])
+        failed = [r for r in results if not r["passed"]]
+        failed_names = {r["name"] for r in failed}
+        assert "signal_confidence_threshold" in failed_names
+        assert "playbook_under_limit" in failed_names
+        assert "curator_respected_directive" in failed_names
+        assert "skip_reason_specific" in failed_names
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Config
+# ═══════════════════════════════════════════════════════════════════════════
+
+class TestLoadEvalConfig:
+    def test_defaults(self, tmp_path):
+        memory_dir = str(tmp_path)
+        config = load_eval_config(memory_dir)
+        assert config["level"] == "mechanical"
+        assert config["sampleRate"] == 0.2
+
+    def test_runtime_override(self, tmp_path):
+        override = {"level": "full", "changedAt": "2026-02-28T10:00:00Z"}
+        (tmp_path / "eval-config.json").write_text(json.dumps(override))
+        config = load_eval_config(str(tmp_path))
+        assert config["level"] == "full"
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# call_llm_with_fallback retry logic
+# ═══════════════════════════════════════════════════════════════════════════
+
+class TestCallLlmWithFallback:
+    @patch("common.time.sleep")
+    @patch("common.call_llm")
+    def test_succeeds_on_retry(self, mock_call, mock_sleep):
+        """First attempt fails with LLMError, second succeeds."""
+        mock_call.side_effect = [
+            LLMError("timeout"),
+            '{"changes": {"added": ["x"], "pruned": [], "promoted": []}}',
+        ]
+        result = call_llm_with_fallback("sys", "usr", script="playbook_curator", json_mode=True)
+        assert '"added": ["x"]' in result
+        assert mock_call.call_count == 2
+        mock_sleep.assert_called_once_with(1)  # 2^0 = 1s backoff
+
+    @patch("common.time.sleep")
+    @patch("common.call_llm")
+    def test_raises_after_all_retries_exhausted(self, mock_call, mock_sleep):
+        """Both attempts fail → raises the last LLMError."""
+        mock_call.side_effect = LLMError("persistent failure")
+        import pytest
+        with pytest.raises(LLMError, match="persistent failure"):
+            call_llm_with_fallback("sys", "usr", retries=1)
+        assert mock_call.call_count == 2
+
+    @patch("common.call_llm")
+    def test_succeeds_first_try_no_retry(self, mock_call):
+        """If first attempt succeeds, no retry or sleep happens."""
+        mock_call.return_value = '{"ok": true}'
+        result = call_llm_with_fallback("sys", "usr")
+        assert result == '{"ok": true}'
+        assert mock_call.call_count == 1
+
+    @patch("common.time.sleep")
+    @patch("common.call_llm")
+    def test_exponential_backoff(self, mock_call, mock_sleep):
+        """With retries=2, backoff should be 1s then 2s."""
+        mock_call.side_effect = [
+            LLMError("fail1"),
+            LLMError("fail2"),
+            "success",
+        ]
+        result = call_llm_with_fallback("sys", "usr", retries=2)
+        assert result == "success"
+        assert mock_sleep.call_args_list == [call(1), call(2)]

package/sinain-memory/tests/test_triple_extractor.py

@@ -0,0 +1,255 @@
+"""Tests for triple_extractor.py — 3-tier extraction."""
+
+import pytest
+from triplestore import TripleStore
+from triple_extractor import TripleExtractor, Triple, _make_slug
+
+
+@pytest.fixture
+def store(tmp_path):
+    s = TripleStore(str(tmp_path / "test.db"))
+    yield s
+    s.close()
+
+
+@pytest.fixture
+def extractor(store):
+    return TripleExtractor(store)
+
+
+@pytest.fixture
+def store_with_vocab(store):
+    """Store pre-populated with concept vocabulary."""
+    tx = store.begin_tx("setup")
+    store.assert_triple(tx, "concept:ocr", "name", "OCR")
+    store.assert_triple(tx, "concept:flutter", "name", "Flutter")
+    store.assert_triple(tx, "concept:react-native", "name", "React Native")
+    return store
+
+
+# ----- Slug generation -----
+
+class TestMakeSlug:
+    def test_basic(self):
+        assert _make_slug("Frame Batching") == "frame-batching"
+
+    def test_special_chars(self):
+        assert _make_slug("OCR pipeline (v2.0)") == "ocr-pipeline-v2-0"
+
+    def test_leading_trailing(self):
+        assert _make_slug("  --hello--  ") == "hello"
+
+    def test_max_length(self):
+        long = "a" * 100
+        assert len(_make_slug(long)) <= 80
+
+    def test_empty(self):
+        assert _make_slug("") == ""
+        assert _make_slug("---") == ""
+
+
+# ----- Tier 1: Signal extraction -----
+
+class TestExtractSignal:
+    def test_basic_signal(self, extractor):
+        data = {
+            "sessionSummary": "Debugging OCR pipeline",
+            "idle": False,
+            "signals": [
+                {"description": "OCR pipeline backpressure", "priority": "high"}
+            ],
+            "recommendedAction": {"action": "sessions_spawn", "task": "Debug", "confidence": 0.8},
+            "output": {"suggestion": "Try frame batching", "insight": "Evening pattern"},
+        }
+        triples = extractor.extract_signal(data, "2026-03-01T10:00:00Z")
+
+        # Check entity creation
+        entity_attrs = {t.attribute for t in triples if t.entity_id == "signal:2026-03-01T10:00:00Z"}
+        assert "summary" in entity_attrs
+        assert "description" in entity_attrs
+        assert "priority" in entity_attrs
+        assert "action" in entity_attrs
+        assert "suggestion" in entity_attrs
+
+    def test_signal_with_playbook_changes(self, extractor):
+        data = {
+            "signals": [],
+            "playbookChanges": {
+                "changes": {"added": ["Use frame batching for OCR"], "pruned": [], "promoted": []}
+            },
+        }
+        triples = extractor.extract_signal(data, "2026-03-01")
+        pattern_triples = [t for t in triples if t.entity_id.startswith("pattern:")]
+        assert len(pattern_triples) > 0
+        assert any(t.attribute == "text" and "frame batching" in t.value.lower() for t in pattern_triples)
+
+    def test_signal_empty(self, extractor):
+        triples = extractor.extract_signal({"signals": []}, "2026-03-01")
+        assert isinstance(triples, list)
+
+    def test_signal_concepts_extracted(self, extractor):
+        data = {"signals": [{"description": "OCR Pipeline stall detected", "priority": "high"}]}
+        triples = extractor.extract_signal(data, "2026-03-01")
+        concept_triples = [t for t in triples if t.entity_id.startswith("concept:")]
+        assert len(concept_triples) > 0  # "OCR" or "Pipeline" should be extracted
+
+    def test_signal_concept_refs(self, extractor):
+        data = {"signals": [{"description": "React Native bridge crash", "priority": "high"}]}
+        triples = extractor.extract_signal(data, "2026-03-01")
+        ref_triples = [t for t in triples if t.value_type == "ref" and t.attribute == "related_to"]
+        assert len(ref_triples) > 0
+
+
+# ----- Tier 1: Session extraction -----
+
+class TestExtractSession:
+    def test_basic_session(self, extractor):
+        data = {
+            "ts": "2026-03-01T09:00:00Z",
+            "summary": "Implemented OCR batch processing",
+            "toolsUsed": ["Read", "Edit", "Bash"],
+            "durationMs": 120000,
+        }
+        triples = extractor.extract_session(data)
+
+        # Check session entity
+        session_triples = [t for t in triples if t.entity_id.startswith("session:")]
+        assert any(t.attribute == "summary" for t in session_triples)
+        assert any(t.attribute == "duration_ms" for t in session_triples)
+
+        # Check tool refs
+        tool_triples = [t for t in triples if t.entity_id.startswith("tool:")]
+        assert len(tool_triples) >= 3
+
+    def test_session_tool_refs(self, extractor):
+        data = {
+            "ts": "2026-03-01",
+            "toolsUsed": ["Bash"],
+        }
+        triples = extractor.extract_session(data)
+        ref_triples = [t for t in triples if t.value_type == "ref" and t.attribute == "used_tool"]
+        assert len(ref_triples) == 1
+
+
+# ----- Tier 1: Mining extraction -----
+
+class TestExtractMining:
+    def test_new_patterns(self, extractor):
+        data = {
+            "newPatterns": ["Frame dropping improves OCR accuracy", "Use batch processing"],
+            "preferences": ["User prefers minimal configs"],
+            "contradictions": [],
+        }
+        triples = extractor.extract_mining(data)
+        pattern_triples = [t for t in triples if t.attribute == "text"]
+        assert len(pattern_triples) >= 2
+
+    def test_mining_preferences(self, extractor):
+        data = {"newPatterns": [], "preferences": ["User likes concise output"]}
+        triples = extractor.extract_mining(data)
+        pref_triples = [t for t in triples if t.attribute == "pattern_type" and t.value == "preference"]
+        assert len(pref_triples) == 1
+
+    def test_mining_contradictions(self, extractor):
+        data = {"newPatterns": [], "contradictions": ["Playbook says X but observation shows Y"]}
+        triples = extractor.extract_mining(data)
+        contra = [t for t in triples if t.attribute == "pattern_type" and t.value == "contradiction"]
+        assert len(contra) == 1
+
+    def test_mining_empty(self, extractor):
+        triples = extractor.extract_mining({"newPatterns": [], "preferences": [], "contradictions": []})
+        assert triples == []
+
+
+# ----- Tier 2: Playbook extraction (regex) -----
+
+class TestExtractPlaybook:
+    def test_patterns_with_scores(self, extractor):
+        text = (
+            "## Established Patterns\n"
+            "- OCR pipeline stalls when queue depth > 10 (score: 0.8)\n"
+            "- Use frame batching for throughput (score: 0.6)\n"
+            "- Spawn research agent for new frameworks\n"
+        )
+        triples = extractor.extract_playbook(text)
+        text_triples = [t for t in triples if t.attribute == "text"]
+        assert len(text_triples) >= 3
+
+        score_triples = [t for t in triples if t.attribute == "score"]
+        assert len(score_triples) == 2
+        assert any(t.value == "0.8" for t in score_triples)
+
+    def test_skips_comments_and_metadata(self, extractor):
+        text = "- <!-- mining-index: 2026-02-21 -->\n- [since: 2026-02-18] stale entry\n- Real pattern here\n"
+        triples = extractor.extract_playbook(text)
+        text_triples = [t for t in triples if t.attribute == "text"]
+        # Should only get "Real pattern here"
+        assert any("Real pattern" in t.value for t in text_triples)
+        assert not any("mining-index" in t.value for t in text_triples)
+
+    def test_playbook_source_tagged(self, extractor):
+        text = "- Use batch processing\n"
+        triples = extractor.extract_playbook(text)
+        source_triples = [t for t in triples if t.attribute == "source"]
+        assert any(t.value == "playbook" for t in source_triples)
+
+
+# ----- Tier 2: Module extraction -----
+
+class TestExtractModule:
+    def test_module_manifest_and_patterns(self, extractor):
+        manifest = {
+            "name": "React Native Dev",
+            "description": "RN development patterns",
+            "version": "1.0.0",
+        }
+        patterns_text = "## Established\n- Use Hermes engine for Android\n- Enable Fast Refresh\n"
+        triples = extractor.extract_module("react-native-dev", manifest, patterns_text)
+
+        module_triples = [t for t in triples if t.entity_id == "module:react-native-dev"]
+        assert any(t.attribute == "name" and t.value == "React Native Dev" for t in module_triples)
+        assert any(t.attribute == "description" for t in module_triples)
+
+        # Patterns should link back to module
+        belongs_triples = [t for t in triples if t.attribute == "belongs_to" and t.value == "module:react-native-dev"]
+        assert len(belongs_triples) >= 2
+
+
+# ----- Concept extraction -----
+
+class TestExtractConcepts:
+    def test_vocab_cache_match(self, store_with_vocab):
+        extractor = TripleExtractor(store_with_vocab)
+        triples = extractor.extract_concepts("Working on OCR pipeline improvements")
+        concept_ids = {t.entity_id for t in triples}
+        assert "concept:ocr" in concept_ids
+
+    def test_regex_capitalized_phrases(self, extractor):
+        # Multi-word capitalized phrases get captured (including leading caps)
+        triples = extractor.extract_concepts("Debugging React Native bridge issues")
+        concept_ids = {t.entity_id for t in triples}
+        # "Debugging React Native" is captured as one phrase since all words are capitalized
+        assert any("react-native" in cid for cid in concept_ids)
+
+    def test_regex_acronyms(self, extractor):
+        triples = extractor.extract_concepts("The API uses JSON over HTTP")
+        concept_ids = {t.entity_id for t in triples}
+        assert any("api" in cid for cid in concept_ids)
+        assert any("json" in cid for cid in concept_ids)
+        assert any("http" in cid for cid in concept_ids)
+
+    def test_regex_technical_terms(self, extractor):
+        triples = extractor.extract_concepts("Check the frame-batching pipeline and error-handling logic")
+        concept_ids = {t.entity_id for t in triples}
+        assert "concept:frame-batching" in concept_ids
+        assert "concept:error-handling" in concept_ids
+
+    def test_short_text_no_llm(self, extractor):
+        # Short text should not trigger LLM fallback
+        triples = extractor.extract_concepts("Hello")
+        # Should return empty or just regex matches, no LLM call
+        assert isinstance(triples, list)
+
+    def test_empty_text(self, extractor):
+        triples = extractor.extract_concepts("")
+        assert triples == []