@archznn/crewloop-skills 0.2.0 → 0.4.0

package/servers/obsidian-mcp/tests/conftest.py

@@ -0,0 +1,39 @@
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.indexer.indexer import Indexer
+from obsidian_mcp.indexer.store import IndexStore
+from obsidian_mcp.vault.repository import VaultRepository
+
+
+@pytest.fixture
+def temp_vault():
+    with tempfile.TemporaryDirectory() as tmp:
+        yield Path(tmp)
+
+
+@pytest.fixture
+def config(temp_vault):
+    return Config(
+        vault_path=temp_vault,
+        index_dir=temp_vault / ".index",
+        bundle_path=temp_vault,
+    )
+
+
+@pytest.fixture
+def vault(config):
+    return VaultRepository(config)
+
+
+@pytest.fixture
+def store(config):
+    return IndexStore(config.index_dir / "index.db")
+
+
+@pytest.fixture
+def indexer(config, vault, store):
+    return Indexer(config, vault, store)

package/servers/obsidian-mcp/tests/test_async_tools.py

@@ -0,0 +1,87 @@
+import asyncio
+import threading
+import time
+
+import pytest
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.tools.registry import TOOLS, dispatch_async
+from obsidian_mcp.vault.repository import VaultRepository
+
+
+def test_dispatch_async_runs_sync_handler_in_thread(monkeypatch):
+    events = []
+
+    def slow_handler(arguments, config):
+        events.append(("start", threading.current_thread().name))
+        time.sleep(0.1)
+        events.append(("end", threading.current_thread().name))
+        return "slow-result"
+
+    monkeypatch.setitem(TOOLS, "slow_tool", {
+        "description": "Slow tool",
+        "input_schema": {"type": "object"},
+        "handler": slow_handler,
+    })
+
+    async def _run():
+        start = time.monotonic()
+        result = await dispatch_async("slow_tool", {}, Config())
+        elapsed = time.monotonic() - start
+        return result, elapsed
+
+    result, elapsed = asyncio.run(_run())
+    assert result == "slow-result"
+    assert elapsed >= 0.05
+    assert any("start" in e[0] for e in events)
+
+
+def test_dispatch_async_awaits_async_handler(monkeypatch):
+    async def async_handler(arguments, config):
+        await asyncio.sleep(0.01)
+        return "async-result"
+
+    monkeypatch.setitem(TOOLS, "async_tool", {
+        "description": "Async tool",
+        "input_schema": {"type": "object"},
+        "handler": async_handler,
+    })
+
+    async def _run():
+        return await dispatch_async("async_tool", {}, Config())
+
+    result = asyncio.run(_run())
+    assert result == "async-result"
+
+
+def test_dispatch_async_does_not_block_event_loop(monkeypatch):
+    async def background_task():
+        await asyncio.sleep(0.05)
+        return "background-done"
+
+    def slow_handler(arguments, config):
+        time.sleep(0.15)
+        return "done"
+
+    monkeypatch.setitem(TOOLS, "slow_tool2", {
+        "description": "Slow tool",
+        "input_schema": {"type": "object"},
+        "handler": slow_handler,
+    })
+
+    async def _run():
+        task = asyncio.create_task(background_task())
+        result = await dispatch_async("slow_tool2", {}, Config())
+        background_result = await task
+        return result, background_result
+
+    result, background_result = asyncio.run(_run())
+    assert result == "done"
+    assert background_result == "background-done"
+
+
+def test_dispatch_stays_synchronous(config):
+    VaultRepository(config)
+    from obsidian_mcp.tools.registry import dispatch
+    result = dispatch("create_note", {"path": "sync.md", "content": "hello"}, config)
+    assert result["status"] == "created"

package/servers/obsidian-mcp/tests/test_edge_cases.py

@@ -0,0 +1,59 @@
+import os
+
+import pytest
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.indexer.indexer import Indexer
+from obsidian_mcp.indexer.store import IndexStore
+from obsidian_mcp.models import Note
+from obsidian_mcp.rag.engine import RAGEngine
+from obsidian_mcp.tools.registry import dispatch
+from obsidian_mcp.vault.repository import VaultRepository
+
+
+def test_config_bundle_path_from_env(monkeypatch, tmp_path):
+    monkeypatch.setenv("CREWLOOP_BUNDLE_PATH", str(tmp_path))
+    config = Config()
+    assert config.bundle_path == tmp_path.resolve()
+
+
+def test_vector_search_empty_vault(config, store):
+    engine = RAGEngine(config, store)
+    results = engine.search("anything", mode="vector")
+    assert results == []
+
+
+def test_text_search_empty_vault(config, store):
+    engine = RAGEngine(config, store)
+    results = engine.search("anything", mode="text")
+    assert results == []
+
+
+def test_graph_search_empty_vault(config, store):
+    engine = RAGEngine(config, store)
+    results = engine.search("anything", mode="graph")
+    assert results == []
+
+
+def test_related_notes_empty_vault(config, store):
+    engine = RAGEngine(config, store)
+    results = engine.related("missing.md")
+    assert results == []
+
+
+def test_list_notes_empty_vault(config):
+    VaultRepository(config)
+    result = dispatch("list_notes", {}, config)
+    assert result == "No notes found."
+
+
+def test_sync_from_bundle_empty_bundle(config, temp_vault):
+    VaultRepository(config)
+    result = dispatch("sync_from_bundle", {"force": True}, config)
+    assert result["status"] == "synced"
+    assert result["indexed_bundle_files"] == 0
+
+
+def test_learn_from_text_no_learning(config):
+    result = dispatch("learn_from_text", {"text": "Just a random sentence with no clear concept."}, config)
+    assert result["status"] == "no_learning_detected"

package/servers/obsidian-mcp/tests/test_indexer.py

@@ -0,0 +1,27 @@
+from obsidian_mcp.indexer.embeddings import chunk_text
+from obsidian_mcp.models import Note
+
+
+def test_chunk_text_character_based():
+    long_text = "word " * 200
+    chunks = chunk_text(long_text, chunk_size=50, overlap=10)
+    assert len(chunks) > 1
+    assert all(len(text) <= 80 for text, _, _ in chunks)
+
+
+def test_index_note(indexer, vault, store):
+    note = Note(path="test.md", title="Test", content="Hello world from MCP.")
+    vault.save(note)
+    indexer.index_note(note)
+    chunks = store.get_all_chunks()
+    assert any(c.note_path == "test.md" for c in chunks)
+
+
+def test_compute_backlinks(indexer, vault, store):
+    vault.save(Note(path="a.md", title="A", content="Link to [[b]]."))
+    vault.save(Note(path="b.md", title="B", content="Content."))
+    indexer.index_note(vault.read("a.md"))
+    indexer.index_note(vault.read("b.md"))
+    indexer.compute_backlinks()
+    edges = store.get_all_edges()
+    assert any(e.source == "b.md" and e.target == "a.md" and e.relation == "backlink" for e in edges)

package/servers/obsidian-mcp/tests/test_integration.py

@@ -0,0 +1,90 @@
+import time
+from pathlib import Path
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.indexer.indexer import Indexer
+from obsidian_mcp.indexer.store import IndexStore
+from obsidian_mcp.models import Note
+from obsidian_mcp.tools.registry import dispatch
+from obsidian_mcp.vault.repository import VaultRepository
+
+
+def test_end_to_end_workflow(tmp_path):
+    config = Config(
+        vault_path=tmp_path / "vault",
+        index_dir=tmp_path / ".index",
+        bundle_path=Path(__file__).resolve().parents[3],
+    )
+
+    # 1. Sync bundle as initial knowledge
+    result = dispatch("sync_from_bundle", {"force": True}, config)
+    assert result["status"] == "synced"
+    assert result["indexed_bundle_files"] > 0
+
+    # 2. Search existing knowledge
+    search = dispatch("search_notes", {"query": "orchestrator", "mode": "text"}, config)
+    assert "orchestrator" in search.lower() or "No results" not in search
+
+    # 3. Create a note with a link
+    dispatch(
+        "create_note",
+        {
+            "path": "projects/mcp-integration.md",
+            "title": "MCP Integration",
+            "content": "We integrated Obsidian via [[MCP]].",
+            "tags": ["integration"],
+        },
+        config,
+    )
+
+    # 4. Learn from new text
+    learn = dispatch(
+        "learn_from_text",
+        {"text": "Novo conceito: MCP Server conecta Obsidian local ao bundle LEA."},
+        config,
+    )
+    assert learn["status"] == "learned"
+    assert any("mcp-server" in p.lower() for p in learn["created_notes"])
+
+    # 5. Re-index and find related notes
+    vault = VaultRepository(config)
+    indexer = Indexer(config, vault, IndexStore(config.index_dir / "index.db"))
+    indexer.index_all()
+    indexer.compute_backlinks()
+
+    related = dispatch("get_related_notes", {"path": "projects/mcp-integration.md"}, config)
+    assert "mcp" in related.lower()
+
+    # 6. List notes
+    listed = dispatch("list_notes", {"folder": "concepts"}, config)
+    assert "mcp-server" in listed.lower()
+
+    # 7. Read generated concept note
+    concept_path = learn["created_notes"][0]
+    concept = dispatch("read_note", {"path": concept_path}, config)
+    assert "MCP Server" in concept
+
+
+def test_search_performance(tmp_path):
+    config = Config(
+        vault_path=tmp_path / "vault",
+        index_dir=tmp_path / ".index",
+        bundle_path=tmp_path,
+    )
+    vault = VaultRepository(config)
+    for i in range(1000):
+        vault.save(
+            Note(
+                path=f"notes/note-{i:04d}.md",
+                title=f"Note {i}",
+                content=f"This is note number {i} about topic {i % 10} and keyword {i}.",
+            )
+        )
+    indexer = Indexer(config, vault, IndexStore(config.index_dir / "index.db"))
+    indexer.index_all()
+
+    start = time.time()
+    result = dispatch("search_notes", {"query": "topic 5", "mode": "text", "limit": 10}, config)
+    elapsed = time.time() - start
+    assert elapsed < 2.0, f"search took {elapsed:.2f}s"
+    assert "note-" in result

package/servers/obsidian-mcp/tests/test_learning.py

@@ -0,0 +1,34 @@
+from obsidian_mcp.learning.detector import LearningDetector
+from obsidian_mcp.learning.note_generator import NoteGenerator
+from obsidian_mcp.tools.registry import dispatch
+from obsidian_mcp.vault.repository import VaultRepository
+
+
+def test_detect_concept(config, vault):
+    detector = LearningDetector(config)
+    learnings = detector.detect("Novo conceito: Graph RAG será usado no projeto.")
+    assert any(l.type == "concept" and "Graph RAG" in l.title for l in learnings)
+
+
+def test_detect_decision(config, vault):
+    detector = LearningDetector(config)
+    learnings = detector.detect("Decidimos que o vault ficará em ~/.lea.")
+    assert any(l.type == "decision" for l in learnings)
+
+
+def test_note_generator(config, vault):
+    detector = LearningDetector(config)
+    learnings = detector.detect("Novo conceito: MCP Server.")
+    gen = NoteGenerator(config, vault)
+    note = gen.to_note(learnings[0])
+    assert note.path.startswith("concepts/")
+    assert note.frontmatter["auto_generated"] is True
+
+
+def test_learn_from_text_dedup(config):
+    VaultRepository(config)
+    text = "Novo conceito: Dedup Test no projeto."
+    first = dispatch("learn_from_text", {"text": text}, config)
+    assert first["status"] == "learned"
+    second = dispatch("learn_from_text", {"text": text}, config)
+    assert second["status"] == "duplicate"

package/servers/obsidian-mcp/tests/test_privacy.py

@@ -0,0 +1,31 @@
+import pytest
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.privacy.filter import PrivacyFilter
+
+
+def test_blocks_api_key():
+    f = PrivacyFilter()
+    assert not f.is_safe("API_KEY=sk-123")
+    with pytest.raises(ValueError):
+        f.validate("API_KEY=sk-123")
+
+
+def test_allows_safe_text():
+    f = PrivacyFilter()
+    assert f.is_safe("This is a normal note about MCP.")
+
+
+def test_blocks_email():
+    f = PrivacyFilter()
+    assert not f.is_safe("Contact me at user@example.com")
+
+
+def test_blocks_secret_key_prefix():
+    f = PrivacyFilter()
+    assert not f.is_safe("Key: sk-abc123def456ghi789")
+
+
+def test_allows_tokenization_word():
+    f = PrivacyFilter()
+    assert f.is_safe("This note discusses tokenization of text.")

package/servers/obsidian-mcp/tests/test_privacy_config.py

@@ -0,0 +1,44 @@
+import pytest
+
+from obsidian_mcp.config import Config, PrivacyConfig
+from obsidian_mcp.privacy.filter import PrivacyFilter
+
+
+def test_privacy_filter_disabled_via_config():
+    config = Config(privacy={"enabled": False})
+    f = PrivacyFilter(config)
+    assert f.is_safe("API_KEY=secret")
+    f.validate("API_KEY=secret")  # no exception
+
+
+def test_privacy_filter_allow_list_bypass():
+    config = Config(privacy={"allowed_strings": ["user@example.com"]})
+    f = PrivacyFilter(config)
+    assert f.is_safe("Contact user@example.com please")
+    f.validate("Contact user@example.com please")
+
+
+def test_privacy_filter_toggle_emails():
+    config = Config(privacy={"block_emails": False})
+    f = PrivacyFilter(config)
+    assert f.is_safe("user@example.com")
+
+
+def test_privacy_filter_toggle_credit_cards():
+    config = Config(privacy={"block_credit_cards": False})
+    f = PrivacyFilter(config)
+    assert f.is_safe("1234 5678 9012 3456")
+
+
+def test_privacy_filter_default_still_blocks():
+    f = PrivacyFilter()
+    assert not f.is_safe("API_KEY=secret")
+    assert not f.is_safe("user@example.com")
+    with pytest.raises(ValueError):
+        f.validate("API_KEY=secret")
+
+
+def test_privacy_config_object():
+    config = Config(privacy=PrivacyConfig(enabled=False))
+    f = PrivacyFilter(config)
+    assert f.is_safe("anything")

package/servers/obsidian-mcp/tests/test_rag.py

@@ -0,0 +1,64 @@
+from obsidian_mcp.indexer.indexer import Indexer
+from obsidian_mcp.models import Note
+from obsidian_mcp.rag.engine import RAGEngine
+
+
+def test_text_search(indexer, vault, config, store):
+    note = Note(path="search.md", title="Search", content="Obsidian vault local second brain.")
+    vault.save(note)
+    indexer.index_note(note)
+    engine = RAGEngine(config, store)
+    results = engine.search("Obsidian", mode="text")
+    assert any(r.note_path == "search.md" for r in results)
+
+
+def test_related_notes(indexer, vault, config, store):
+    vault.save(Note(path="a.md", title="A", content="See [[b]]."))
+    vault.save(Note(path="b.md", title="B", content="Content."))
+    indexer.index_note(vault.read("a.md"))
+    indexer.index_note(vault.read("b.md"))
+    indexer.compute_backlinks()
+    engine = RAGEngine(config, store)
+    results = engine.related("a.md")
+    assert any(r.note_path == "b.md" for r in results)
+
+
+def test_graph_search(indexer, vault, config, store):
+    vault.save(Note(path="a.md", title="A", content="See [[b]]."))
+    vault.save(Note(path="b.md", title="B", content="Content."))
+    indexer.index_note(vault.read("a.md"))
+    indexer.index_note(vault.read("b.md"))
+    indexer.compute_backlinks()
+    engine = RAGEngine(config, store)
+    results = engine.search("b", mode="graph")
+    assert any(r.note_path == "b.md" for r in results)
+
+
+def test_vector_search_fallback(config, vault, store):
+    vault.save(Note(path="v.md", title="V", content="MCP local second brain"))
+    indexer = Indexer(config, vault, store)
+    indexer.index_all()
+    engine = RAGEngine(config, store)
+    results = engine.search("MCP", mode="vector")
+    assert any(r.note_path == "v.md" for r in results)
+
+
+def test_vector_search_fallback_ranks_matching_note(config, vault, store):
+    vault.save(Note(path="a.md", title="A", content="MCP local second brain"))
+    vault.save(Note(path="b.md", title="B", content="Another note about servers and embedding"))
+    indexer = Indexer(config, vault, store)
+    indexer.index_all()
+    engine = RAGEngine(config, store)
+    results = engine.search("MCP server", mode="vector")
+    assert results[0].note_path == "a.md"
+
+
+def test_hybrid_search_normalizes_scores(config, vault, store):
+    vault.save(Note(path="a.md", title="A", content="MCP local second brain"))
+    vault.save(Note(path="b.md", title="B", content="Another note about servers and embedding"))
+    indexer = Indexer(config, vault, store)
+    indexer.index_all()
+    engine = RAGEngine(config, store)
+    results = engine.search("MCP", mode="hybrid")
+    assert results
+    assert all(0.0 <= r.score <= 1.0 for r in results)

package/servers/obsidian-mcp/tests/test_read_raw.py

@@ -0,0 +1,37 @@
+import pytest
+
+from obsidian_mcp.tools.registry import dispatch
+from obsidian_mcp.vault.repository import VaultRepository
+
+
+def test_read_note_returns_exact_file_content(config, temp_vault):
+    VaultRepository(config)
+    raw = "---\ntitle: Exact Note\ntags:\n  - alpha\n  - beta\n---\n\n# Exact Note\n\nKeep the frontmatter exactly as written."
+    (temp_vault / "exact.md").write_text(raw, encoding="utf-8")
+    result = dispatch("read_note", {"path": "exact.md"}, config)
+    assert result == raw
+
+
+def test_read_note_does_not_inject_title_or_tags(config, temp_vault):
+    VaultRepository(config)
+    raw = "Plain body without title or tags."
+    (temp_vault / "plain.md").write_text(raw, encoding="utf-8")
+    result = dispatch("read_note", {"path": "plain.md"}, config)
+    assert result == raw
+    assert "# " not in result
+    assert "**Tags:**" not in result
+
+
+def test_read_note_non_utf8_replacement(config, vault, temp_vault):
+    VaultRepository(config)
+    path = temp_vault / "binary.md"
+    path.write_bytes(b"\xff\xfeHello\xfa world")
+    result = dispatch("read_note", {"path": "binary.md"}, config)
+    assert "Hello" in result
+    assert "world" in result
+
+
+def test_read_note_missing_raises(config):
+    VaultRepository(config)
+    with pytest.raises(FileNotFoundError):
+        dispatch("read_note", {"path": "missing.md"}, config)

package/servers/obsidian-mcp/tests/test_tfidf_fallback.py

@@ -0,0 +1,54 @@
+from obsidian_mcp.indexer.indexer import Indexer
+from obsidian_mcp.models import Chunk, Note
+from obsidian_mcp.rag.engine import RAGEngine
+from obsidian_mcp.rag.vector_search import TfidfIndex
+
+
+def test_tfidf_index_fits_on_corpus():
+    index = TfidfIndex()
+    chunks = [
+        Chunk(id="c1", note_path="a.md", text="MCP local second brain"),
+        Chunk(id="c2", note_path="b.md", text="Another note about servers"),
+    ]
+    index.fit(chunks)
+    results = index.query("MCP", top_k=10)
+    assert any(doc_id == "c1" for doc_id, _ in results)
+
+
+def test_tfidf_index_query_empty_corpus():
+    index = TfidfIndex()
+    index.fit([])
+    assert index.query("anything") == []
+
+
+def test_vector_search_builds_corpus_fitted_index(config, vault, store):
+    vault.save(Note(path="a.md", title="A", content="MCP local second brain"))
+    indexer = Indexer(config, vault, store)
+    indexer.index_all()
+    engine = RAGEngine(config, store)
+    assert engine.vector_search._tfidf_index is None
+    results = engine.search("MCP", mode="vector")
+    assert results
+    assert engine.vector_search._tfidf_index is not None
+    assert engine.vector_search._tfidf_chunk_count > 0
+
+
+def test_vector_search_reuses_fitted_index(config, vault, store):
+    vault.save(Note(path="a.md", title="A", content="MCP local second brain"))
+    indexer = Indexer(config, vault, store)
+    indexer.index_all()
+    engine = RAGEngine(config, store)
+    engine.search("MCP", mode="vector")
+    first_index = engine.vector_search._tfidf_index
+    engine.search("local", mode="vector")
+    assert engine.vector_search._tfidf_index is first_index
+
+
+def test_vector_search_ranks_matching_note_highest(config, vault, store):
+    vault.save(Note(path="a.md", title="A", content="MCP local second brain"))
+    vault.save(Note(path="b.md", title="B", content="Another note about servers and embedding"))
+    indexer = Indexer(config, vault, store)
+    indexer.index_all()
+    engine = RAGEngine(config, store)
+    results = engine.search("MCP server", mode="vector")
+    assert results[0].note_path == "a.md"

package/servers/obsidian-mcp/tests/test_tools.py

@@ -0,0 +1,108 @@
+import pytest
+
+from obsidian_mcp.indexer.indexer import Indexer
+from obsidian_mcp.indexer.store import IndexStore
+from obsidian_mcp.models import Note
+from obsidian_mcp.tools.registry import dispatch
+from obsidian_mcp.vault.repository import VaultRepository
+
+
+def test_tool_create_and_read(config):
+    VaultRepository(config)
+    result = dispatch("create_note", {"path": "t.md", "content": "Hello"}, config)
+    assert result["status"] == "created"
+    text = dispatch("read_note", {"path": "t.md"}, config)
+    assert "Hello" in text
+
+
+def test_tool_create_note_adds_extension(config):
+    VaultRepository(config)
+    result = dispatch("create_note", {"path": "no-extension", "content": "body"}, config)
+    assert result["path"] == "no-extension.md"
+    text = dispatch("read_note", {"path": "no-extension.md"}, config)
+    assert "body" in text
+
+
+def test_tool_create_note_title_from_path(config):
+    VaultRepository(config)
+    dispatch("create_note", {"path": "my-great-note.md", "content": "body"}, config)
+    text = dispatch("read_note", {"path": "my-great-note.md"}, config)
+    assert "My Great Note" in text
+
+
+def test_tool_read_note_returns_raw_content(config, temp_vault):
+    VaultRepository(config)
+    dispatch(
+        "create_note",
+        {"path": "fm.md", "title": "FM", "content": "body", "tags": ["a", "b"]},
+        config,
+    )
+    raw = (temp_vault / "fm.md").read_text(encoding="utf-8")
+    text = dispatch("read_note", {"path": "fm.md"}, config)
+    assert text == raw
+    assert "body" in text
+    assert "FM" in text
+
+
+def test_tool_search(config):
+    vault = VaultRepository(config)
+    vault.save(Note(path="s.md", title="S", content="MCP server local"))
+    indexer = Indexer(config, vault, IndexStore(config.index_dir / "index.db"))
+    indexer.index_all()
+    text = dispatch("search_notes", {"query": "MCP", "mode": "text"}, config)
+    assert "s.md" in text
+
+
+def test_tool_privacy_blocks(config):
+    with pytest.raises(ValueError):
+        dispatch("create_note", {"path": "bad.md", "content": "API_KEY=secret"}, config)
+
+
+def test_tool_update_and_delete(config):
+    VaultRepository(config)
+    dispatch("create_note", {"path": "u.md", "content": "Original", "tags": ["a"]}, config)
+    dispatch("update_note", {"path": "u.md", "append": "More", "tags": ["b"]}, config)
+    text = dispatch("read_note", {"path": "u.md"}, config)
+    assert "Original" in text
+    assert "More" in text
+    assert "b" in text
+    dispatch("delete_note", {"path": "u.md"}, config)
+    with pytest.raises(FileNotFoundError):
+        dispatch("read_note", {"path": "u.md"}, config)
+
+
+def test_tool_list_and_related(config):
+    vault = VaultRepository(config)
+    vault.save(Note(path="x.md", title="X", content="Link to [[y]]."))
+    vault.save(Note(path="y.md", title="Y", content="Content."))
+    indexer = Indexer(config, vault, IndexStore(config.index_dir / "index.db"))
+    indexer.index_all()
+    indexer.compute_backlinks()
+    listed = dispatch("list_notes", {}, config)
+    assert "x.md" in listed
+    related = dispatch("get_related_notes", {"path": "x.md"}, config)
+    assert "y.md" in related
+
+
+def test_tool_sync_from_bundle(config, temp_vault):
+    (temp_vault / "skills" / "orchestrator").mkdir(parents=True)
+    (temp_vault / "skills" / "orchestrator" / "SKILL.md").write_text("# Orchestrator\n")
+    (temp_vault / "README.md").write_text("# Bundle\n")
+    result = dispatch("sync_from_bundle", {"force": True}, config)
+    assert result["status"] == "synced"
+    assert result["indexed_bundle_files"] > 0
+
+
+def test_tool_path_traversal_blocked(config):
+    with pytest.raises(ValueError):
+        dispatch("create_note", {"path": "../outside.md", "content": "x"}, config)
+
+
+def test_tool_learn_from_text(config):
+    result = dispatch(
+        "learn_from_text",
+        {"text": "Novo conceito: Observability no projeto LEA."},
+        config,
+    )
+    assert result["status"] == "learned"
+    assert any("observability" in p.lower() for p in result["created_notes"])