memstack-skill-loader 4.11.0__tar.gz → 4.12.0__tar.gz

{memstack_skill_loader-4.11.0/src/memstack_skill_loader.egg-info → memstack_skill_loader-4.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memstack-skill-loader
-Version: 4.11.0
+Version: 4.12.0
 Summary: MCP server that vector-indexes MemStack Pro skills for on-demand loading
 Requires-Python: >=3.10
 Requires-Dist: mcp>=1.0.0

{memstack_skill_loader-4.11.0 → memstack_skill_loader-4.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memstack-skill-loader"
-version = "4.11.0"
+version = "4.12.0"
 description = "MCP server that vector-indexes MemStack Pro skills for on-demand loading"
 requires-python = ">=3.10"
 dependencies = [

{memstack_skill_loader-4.11.0 → memstack_skill_loader-4.12.0}/src/memstack_skill_loader/__init__.py

@@ -1,3 +1,3 @@
 """MemStack Skill Loader — MCP server for semantic skill search."""
 
-__version__ = "4.11.0"
+__version__ = "4.12.0"

{memstack_skill_loader-4.11.0 → memstack_skill_loader-4.12.0}/src/memstack_skill_loader/memory_db.py

@@ -5,7 +5,7 @@ import json
 import os
 import sqlite3
 import sys
-from pathlib import Path
+from pathlib import Path, PureWindowsPath
 
 DB_PATH = Path.home() / ".memstack" / "memory.db"
 SCHEMA_VERSION = 1
@@ -107,6 +107,15 @@ def _init_tables(conn: sqlite3.Connection) -> None:
     cur.execute(
         "CREATE INDEX IF NOT EXISTS idx_procedural_category ON procedural_memory(category)"
     )
+    # Structural idempotency for insert_lesson (INSERT OR IGNORE): the same
+    # (project_dir, title, content) IS the same lesson. NOTE: SQLite treats NULLs
+    # as DISTINCT in a UNIQUE index, so two GLOBAL lessons (project_dir IS NULL)
+    # with identical title+content both insert and IGNORE will not suppress the
+    # second. Named-project lessons dedupe; globals do not. Intentional, not fixed.
+    cur.execute(
+        "CREATE UNIQUE INDEX IF NOT EXISTS idx_procedural_unique "
+        "ON procedural_memory(project_dir, title, content)"
+    )
 
     cur.execute(
         """
@@ -282,7 +291,7 @@ def insert_lesson(
             if created_at:
                 # Caller-supplied timestamp: bind it (never string-format it in).
                 cur = conn.execute(
-                    "INSERT INTO procedural_memory "
+                    "INSERT OR IGNORE INTO procedural_memory "
                     "(project_dir, category, title, content, stack_tags, created_at) "
                     "VALUES (?, ?, ?, ?, ?, ?)",
                     (pdir, category, title, content, tags_json, created_at),
@@ -291,11 +300,24 @@ def insert_lesson(
                 # Default path: omit created_at so the column DEFAULT
                 # (datetime('now')) applies. Byte-identical to prior behavior.
                 cur = conn.execute(
-                    "INSERT INTO procedural_memory "
+                    "INSERT OR IGNORE INTO procedural_memory "
                     "(project_dir, category, title, content, stack_tags) "
                     "VALUES (?, ?, ?, ?, ?)",
                     (pdir, category, title, content, tags_json),
                 )
+            if cur.rowcount == 0:
+                # idx_procedural_unique(project_dir, title, content) suppressed a
+                # duplicate. lastrowid is meaningless now, so do NOT index a phantom
+                # FTS row and do NOT commit. Return the EXISTING row's id: storing a
+                # lesson already stored is success, not failure (None would read as a
+                # failed insert). `IS` matches NULL-safely, though a NULL project_dir
+                # never reaches here (NULLs are distinct in the UNIQUE index).
+                existing = conn.execute(
+                    "SELECT id FROM procedural_memory "
+                    "WHERE project_dir IS ? AND title=? AND content=?",
+                    (pdir, title, content),
+                ).fetchone()
+                return existing[0] if existing else None
             row_id = cur.lastrowid
             _index_fts(conn, "procedural_memory", row_id,
                         f"{title} {content}", pdir or "")
@@ -673,6 +695,67 @@ def get_recent_project_dirs(limit: int = 10) -> list[str]:
         return []
 
 
+def resolve_project_dir_by_name(name: str) -> str | None:
+    """Resolve a project NAME to a stored ``project_dir`` path, or None.
+
+    The store keeps ``project_dir`` as absolute paths (e.g.
+    ``C:\\Projects\\adminstack``); callers such as the Diary only know the
+    project *name* (``adminstack``). This matches ``name`` case-insensitively
+    against the basename of every distinct ``project_dir`` the store already
+    knows, unioned across the five tables that carry the column. It assumes no
+    on-disk layout and never fabricates a path: a name the store has never seen
+    returns None, so the function works on any machine.
+
+    Basenames are split with ``PureWindowsPath``, not ``os.path.basename``: the
+    stored paths are Windows backslash paths, and ``os.path.basename`` does not
+    split on ``\\`` when this DB is read on a POSIX host. ``PureWindowsPath``
+    treats both ``\\`` and ``/`` as separators regardless of the running OS.
+
+    If a basename matches more than one distinct path (a collision), returns
+    None rather than guessing which project was meant.
+    """
+    try:
+        if name is None:
+            return None
+        if not isinstance(name, str):
+            name = str(name)
+        key = name.strip().lower()
+        if not key:
+            return None
+
+        conn = _get_conn()
+        try:
+            rows = conn.execute(
+                "SELECT DISTINCT project_dir FROM ("
+                "SELECT project_dir FROM context_facts "
+                "UNION SELECT project_dir FROM procedural_memory "
+                "UNION SELECT project_dir FROM session_summaries "
+                "UNION SELECT project_dir FROM temporal_events "
+                "UNION SELECT project_dir FROM failed_approaches"
+                ") WHERE project_dir IS NOT NULL"
+            ).fetchall()
+        finally:
+            conn.close()
+
+        matches = set()
+        for row in rows:
+            pdir = row[0]
+            if not pdir:
+                continue
+            if PureWindowsPath(pdir).name.lower() == key:
+                matches.add(pdir)
+
+        if len(matches) == 1:
+            return next(iter(matches))
+        return None  # 0 matches => miss; >1 => ambiguous collision, do not guess
+    except Exception as exc:
+        print(
+            f"[memstack-memory] resolve_project_dir_by_name failed: {exc}",
+            file=sys.stderr,
+        )
+        return None
+
+
 def _human_size(nbytes: int) -> str:
     for unit in ("B", "KB", "MB", "GB"):
         if nbytes < 1024:

{memstack_skill_loader-4.11.0 → memstack_skill_loader-4.12.0/src/memstack_skill_loader.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memstack-skill-loader
-Version: 4.11.0
+Version: 4.12.0
 Summary: MCP server that vector-indexes MemStack Pro skills for on-demand loading
 Requires-Python: >=3.10
 Requires-Dist: mcp>=1.0.0

memstack_skill_loader-4.12.0/tests/test_search_memory.py

@@ -0,0 +1,291 @@
+"""Unit tests for memory_db.search_memory (the user-facing memory_search MCP tool).
+
+Hermetic: the autouse ``isolated_memory_db`` fixture in tests/conftest.py
+redirects the memory DB to a per-test tmp file, so no test touches the real
+~/.memstack/memory.db. No network, no CLI.
+
+Regression coverage for the phrase-match bug: search_memory used to wrap the
+query as an FTS5 phrase (f'"{query}"'), so a multi-word query only matched an
+exact consecutive run of tokens. It now routes through _fts_or_query (the same
+sanitizer query_failed_approaches uses): OR of 3+ char tokens, punctuation
+stripped, empty -> [] before any MATCH.
+"""
+
+from memstack_skill_loader import memory_db
+
+
+def _seed(project_dir, summary, session_id="s1", event_type="note"):
+    """Insert one temporal_event; its summary is what lands in memory_fts."""
+    return memory_db.insert_event(project_dir, session_id, event_type, summary)
+
+
+# 1. Regression: multi-word query matches non-consecutive terms ---------------
+
+def test_multiword_matches_non_consecutive_terms():
+    pd = "C:/proj/alpha"
+    target = "authentication for the login endpoint using JWT"
+    _seed(pd, target)
+
+    results = memory_db.search_memory("jwt auth login", project_dir=pd)
+
+    # Phrase-match wrapping would have returned 0 here (terms aren't
+    # consecutive); OR-tokenization matches on jwt/login.
+    assert len(results) >= 1
+    assert any(r["content"] == target for r in results)
+
+
+# 2. Punctuation safety: raw special chars must not reach MATCH raw -----------
+
+def test_punctuation_queries_do_not_raise():
+    pd = "C:/proj/alpha"
+    _seed(pd, "jwt token for the login endpoint")
+
+    for q in ('auth: "login"', "jwt-token (login)", "C:/path/thing"):
+        result = memory_db.search_memory(q, project_dir=pd)
+        assert isinstance(result, list)  # no exception, always a list
+
+
+# 3. Empty / too-short query returns [] WITHOUT opening a connection ----------
+
+def test_empty_and_short_query_short_circuit(monkeypatch):
+    # If the guard fails to short-circuit, _get_conn would be called; the
+    # counter proves no MATCH was attempted (the counter is inspected outside
+    # the function, so search_memory's broad except cannot hide a miss).
+    calls = {"n": 0}
+
+    def tracking_conn():
+        calls["n"] += 1
+        raise AssertionError("search_memory should not open a connection here")
+
+    monkeypatch.setattr(memory_db, "_get_conn", tracking_conn)
+
+    assert memory_db.search_memory("") == []            # no tokens
+    assert memory_db.search_memory("a to") == []        # all tokens < 3 chars
+    assert calls["n"] == 0
+
+
+# 4. project_dir filter still scopes results ----------------------------------
+
+def test_project_dir_filter_scopes_results():
+    pd_a = "C:/proj/alpha"
+    pd_b = "C:/proj/beta"
+    _seed(pd_a, "deployment pipeline for alpha service")
+    _seed(pd_b, "deployment pipeline for beta service")
+
+    results = memory_db.search_memory("deployment pipeline", project_dir=pd_a)
+
+    assert len(results) >= 1
+    assert all(r["project_dir"] == pd_a for r in results)
+    assert not any("beta" in r["content"] for r in results)
+
+
+def test_no_project_dir_returns_all_projects():
+    pd_a = "C:/proj/alpha"
+    pd_b = "C:/proj/beta"
+    _seed(pd_a, "deployment pipeline for alpha service")
+    _seed(pd_b, "deployment pipeline for beta service")
+
+    results = memory_db.search_memory("deployment pipeline")  # no filter
+
+    dirs = {r["project_dir"] for r in results}
+    assert pd_a in dirs and pd_b in dirs
+
+
+# 5. Limit is capped at 500 ---------------------------------------------------
+
+def test_limit_capped_at_500(monkeypatch):
+    # Capture the params bound to the SELECT; LIMIT is the last one. A fake
+    # connection lets us read the capped value without seeding 500+ rows.
+    captured = {}
+
+    class _FakeCursor:
+        def fetchall(self):
+            return []
+
+    class _FakeConn:
+        def execute(self, sql, params=()):
+            captured["params"] = list(params)
+            return _FakeCursor()
+
+        def close(self):
+            pass
+
+    monkeypatch.setattr(memory_db, "_get_conn", lambda: _FakeConn())
+
+    memory_db.search_memory("alpha", limit=100_000)
+
+    assert captured["params"][-1] == 500  # capped down from 100000
+
+
+# 6. insert_lesson created_at parameter (additive, keyword-only) --------------
+
+def _lesson_created_at(project_dir, title):
+    """Read back the created_at for a specific lesson via get_lessons."""
+    for r in memory_db.get_lessons(project_dir=project_dir):
+        if r["title"] == title:
+            return r["created_at"]
+    return None
+
+
+def test_insert_lesson_without_created_at_applies_default():
+    pd = "C:/proj/lessons"
+    rid = memory_db.insert_lesson(
+        "default ts lesson", "body of the default-timestamp lesson", "lesson",
+        project_dir=pd,
+    )
+    assert isinstance(rid, int)
+    ts = _lesson_created_at(pd, "default ts lesson")
+    assert ts is not None and ts.strip() != ""  # column DEFAULT datetime('now') applied
+
+
+def test_insert_lesson_stores_explicit_created_at():
+    pd = "C:/proj/lessons"
+    rid = memory_db.insert_lesson(
+        "explicit ts lesson", "body of the explicit-timestamp lesson", "lesson",
+        project_dir=pd, created_at="2026-02-24 16:55:18",
+    )
+    assert isinstance(rid, int)
+    assert _lesson_created_at(pd, "explicit ts lesson") == "2026-02-24 16:55:18"
+
+
+def test_insert_lesson_explicit_created_at_is_searchable():
+    # Proves _index_fts fired on the explicit-timestamp INSERT path.
+    pd = "C:/proj/lessons"
+    memory_db.insert_lesson(
+        "searchable timestamped lesson",
+        "deployment pipeline runbook for the beta service",
+        "lesson",
+        project_dir=pd, created_at="2026-02-24 16:55:18",
+    )
+    results = memory_db.search_memory("deployment pipeline runbook", project_dir=pd)
+    assert any("deployment pipeline runbook" in r["content"] for r in results)
+
+
+# 7. resolve_project_dir_by_name -----------------------------------------------
+# Name (from the Diary) -> stored project_dir path, matched on basename across
+# all five project_dir-bearing tables. Each test seeds its own rows into the
+# clean per-test DB via the real writers.
+
+def test_resolve_exact_name_match():
+    pd = "C:\\Projects\\adminstack"
+    memory_db.insert_fact(pd, "status", "status", "ok")
+    assert memory_db.resolve_project_dir_by_name("adminstack") == pd
+
+
+def test_resolve_case_insensitive_match():
+    pd = "C:\\Projects\\adminstack"
+    memory_db.insert_fact(pd, "status", "status", "ok")
+    # Upper-cased query resolves to the path in its ORIGINAL stored casing.
+    assert memory_db.resolve_project_dir_by_name("ADMINSTACK") == pd
+
+
+def test_resolve_no_match_returns_none():
+    memory_db.insert_fact("C:\\Projects\\adminstack", "status", "status", "ok")
+    assert memory_db.resolve_project_dir_by_name("nonexistent-project") is None
+
+
+def test_resolve_none_empty_whitespace_return_none():
+    memory_db.insert_fact("C:\\Projects\\adminstack", "status", "status", "ok")
+    assert memory_db.resolve_project_dir_by_name(None) is None
+    assert memory_db.resolve_project_dir_by_name("") is None
+    assert memory_db.resolve_project_dir_by_name("   ") is None
+
+
+def test_resolve_non_string_returns_none_without_raising():
+    memory_db.insert_fact("C:\\Projects\\adminstack", "status", "status", "ok")
+    # Coerced with str(); no basename equals "123" or "12.5", so -> None, no raise.
+    assert memory_db.resolve_project_dir_by_name(123) is None
+    assert memory_db.resolve_project_dir_by_name(12.5) is None
+
+
+def test_resolve_basename_collision_returns_none():
+    # Two distinct paths sharing a basename: the lookup is ambiguous -> None,
+    # and must NOT silently pick either one.
+    memory_db.insert_fact("C:\\Projects\\adminstack", "status", "status", "a")
+    memory_db.insert_fact("D:\\Backup\\adminstack", "status", "status", "b")
+    assert memory_db.resolve_project_dir_by_name("adminstack") is None
+
+
+def test_resolve_null_project_dir_does_not_break_query():
+    # A global lesson stores project_dir=NULL in procedural_memory. The UNION
+    # must tolerate it and still resolve a real name.
+    memory_db.insert_lesson("global rule", "applies everywhere", "lesson")  # NULL pd
+    pd = "C:\\Projects\\memstack"
+    memory_db.insert_fact(pd, "status", "status", "ok")
+    assert memory_db.resolve_project_dir_by_name("memstack") == pd
+
+
+def test_resolve_matches_basename_only_not_path_substring():
+    # "Projects" is a parent path component, never a basename -> must not resolve.
+    memory_db.insert_fact("C:\\Projects\\adminstack", "status", "status", "ok")
+    assert memory_db.resolve_project_dir_by_name("Projects") is None
+    assert memory_db.resolve_project_dir_by_name("C:") is None
+
+
+# 8. insert_lesson idempotency (UNIQUE index + INSERT OR IGNORE) ---------------
+# A retried/repeated diary save must not duplicate a lesson. Dedup is keyed on
+# (project_dir, title, content); NULL project_dir is intentionally NOT deduped.
+
+def _procedural_count():
+    conn = memory_db._get_conn()
+    try:
+        return conn.execute("SELECT COUNT(*) FROM procedural_memory").fetchone()[0]
+    finally:
+        conn.close()
+
+
+def _fts_procedural_count():
+    conn = memory_db._get_conn()
+    try:
+        return conn.execute(
+            "SELECT COUNT(*) FROM memory_fts WHERE source_table='procedural_memory'"
+        ).fetchone()[0]
+    finally:
+        conn.close()
+
+
+def test_insert_lesson_same_triple_is_idempotent():
+    pd = "C:\\Projects\\adminstack"
+    id1 = memory_db.insert_lesson("t1", "body one", "lesson", project_dir=pd)
+    id2 = memory_db.insert_lesson("t1", "body one", "lesson", project_dir=pd)
+    assert id1 is not None
+    assert id2 == id1                 # same id both times, not None
+    assert _procedural_count() == 1   # exactly one row
+
+
+def test_insert_lesson_dup_does_not_duplicate_fts():
+    pd = "C:\\Projects\\adminstack"
+    memory_db.insert_lesson("t1", "body one", "lesson", project_dir=pd)
+    memory_db.insert_lesson("t1", "body one", "lesson", project_dir=pd)
+    assert _fts_procedural_count() == 1   # phantom FTS row NOT written
+
+
+def test_insert_lesson_same_title_different_content_two_rows():
+    pd = "C:\\Projects\\adminstack"
+    memory_db.insert_lesson("t1", "body one", "lesson", project_dir=pd)
+    memory_db.insert_lesson("t1", "body two", "lesson", project_dir=pd)
+    assert _procedural_count() == 2       # not over-deduping on title alone
+
+
+def test_insert_lesson_same_triple_different_project_two_rows():
+    memory_db.insert_lesson("t1", "body one", "lesson", project_dir="C:\\Projects\\a")
+    memory_db.insert_lesson("t1", "body one", "lesson", project_dir="C:\\Projects\\b")
+    assert _procedural_count() == 2       # project_dir is part of the key
+
+
+def test_insert_lesson_two_identical_globals_both_insert():
+    # Documented NULL behavior: NULLs are distinct in a UNIQUE index, so IGNORE
+    # does not suppress the second global lesson. This test encodes the caveat.
+    memory_db.insert_lesson("g", "same body", "lesson", global_=True)
+    memory_db.insert_lesson("g", "same body", "lesson", global_=True)
+    assert _procedural_count() == 2
+
+
+def test_insert_lesson_preexisting_row_still_dedupes():
+    # Insert once, then insert the identical triple: the second resolves to the
+    # existing row rather than adding a duplicate.
+    pd = "C:\\Projects\\adminstack"
+    first = memory_db.insert_lesson("t1", "body one", "lesson", project_dir=pd)
+    again = memory_db.insert_lesson("t1", "body one", "lesson", project_dir=pd)
+    assert again == first
+    assert _procedural_count() == 1

memstack_skill_loader-4.11.0/tests/test_search_memory.py

@@ -1,161 +0,0 @@
-"""Unit tests for memory_db.search_memory (the user-facing memory_search MCP tool).
-
-Hermetic: the autouse ``isolated_memory_db`` fixture in tests/conftest.py
-redirects the memory DB to a per-test tmp file, so no test touches the real
-~/.memstack/memory.db. No network, no CLI.
-
-Regression coverage for the phrase-match bug: search_memory used to wrap the
-query as an FTS5 phrase (f'"{query}"'), so a multi-word query only matched an
-exact consecutive run of tokens. It now routes through _fts_or_query (the same
-sanitizer query_failed_approaches uses): OR of 3+ char tokens, punctuation
-stripped, empty -> [] before any MATCH.
-"""
-
-from memstack_skill_loader import memory_db
-
-
-def _seed(project_dir, summary, session_id="s1", event_type="note"):
-    """Insert one temporal_event; its summary is what lands in memory_fts."""
-    return memory_db.insert_event(project_dir, session_id, event_type, summary)
-
-
-# 1. Regression: multi-word query matches non-consecutive terms ---------------
-
-def test_multiword_matches_non_consecutive_terms():
-    pd = "C:/proj/alpha"
-    target = "authentication for the login endpoint using JWT"
-    _seed(pd, target)
-
-    results = memory_db.search_memory("jwt auth login", project_dir=pd)
-
-    # Phrase-match wrapping would have returned 0 here (terms aren't
-    # consecutive); OR-tokenization matches on jwt/login.
-    assert len(results) >= 1
-    assert any(r["content"] == target for r in results)
-
-
-# 2. Punctuation safety: raw special chars must not reach MATCH raw -----------
-
-def test_punctuation_queries_do_not_raise():
-    pd = "C:/proj/alpha"
-    _seed(pd, "jwt token for the login endpoint")
-
-    for q in ('auth: "login"', "jwt-token (login)", "C:/path/thing"):
-        result = memory_db.search_memory(q, project_dir=pd)
-        assert isinstance(result, list)  # no exception, always a list
-
-
-# 3. Empty / too-short query returns [] WITHOUT opening a connection ----------
-
-def test_empty_and_short_query_short_circuit(monkeypatch):
-    # If the guard fails to short-circuit, _get_conn would be called; the
-    # counter proves no MATCH was attempted (the counter is inspected outside
-    # the function, so search_memory's broad except cannot hide a miss).
-    calls = {"n": 0}
-
-    def tracking_conn():
-        calls["n"] += 1
-        raise AssertionError("search_memory should not open a connection here")
-
-    monkeypatch.setattr(memory_db, "_get_conn", tracking_conn)
-
-    assert memory_db.search_memory("") == []            # no tokens
-    assert memory_db.search_memory("a to") == []        # all tokens < 3 chars
-    assert calls["n"] == 0
-
-
-# 4. project_dir filter still scopes results ----------------------------------
-
-def test_project_dir_filter_scopes_results():
-    pd_a = "C:/proj/alpha"
-    pd_b = "C:/proj/beta"
-    _seed(pd_a, "deployment pipeline for alpha service")
-    _seed(pd_b, "deployment pipeline for beta service")
-
-    results = memory_db.search_memory("deployment pipeline", project_dir=pd_a)
-
-    assert len(results) >= 1
-    assert all(r["project_dir"] == pd_a for r in results)
-    assert not any("beta" in r["content"] for r in results)
-
-
-def test_no_project_dir_returns_all_projects():
-    pd_a = "C:/proj/alpha"
-    pd_b = "C:/proj/beta"
-    _seed(pd_a, "deployment pipeline for alpha service")
-    _seed(pd_b, "deployment pipeline for beta service")
-
-    results = memory_db.search_memory("deployment pipeline")  # no filter
-
-    dirs = {r["project_dir"] for r in results}
-    assert pd_a in dirs and pd_b in dirs
-
-
-# 5. Limit is capped at 500 ---------------------------------------------------
-
-def test_limit_capped_at_500(monkeypatch):
-    # Capture the params bound to the SELECT; LIMIT is the last one. A fake
-    # connection lets us read the capped value without seeding 500+ rows.
-    captured = {}
-
-    class _FakeCursor:
-        def fetchall(self):
-            return []
-
-    class _FakeConn:
-        def execute(self, sql, params=()):
-            captured["params"] = list(params)
-            return _FakeCursor()
-
-        def close(self):
-            pass
-
-    monkeypatch.setattr(memory_db, "_get_conn", lambda: _FakeConn())
-
-    memory_db.search_memory("alpha", limit=100_000)
-
-    assert captured["params"][-1] == 500  # capped down from 100000
-
-
-# 6. insert_lesson created_at parameter (additive, keyword-only) --------------
-
-def _lesson_created_at(project_dir, title):
-    """Read back the created_at for a specific lesson via get_lessons."""
-    for r in memory_db.get_lessons(project_dir=project_dir):
-        if r["title"] == title:
-            return r["created_at"]
-    return None
-
-
-def test_insert_lesson_without_created_at_applies_default():
-    pd = "C:/proj/lessons"
-    rid = memory_db.insert_lesson(
-        "default ts lesson", "body of the default-timestamp lesson", "lesson",
-        project_dir=pd,
-    )
-    assert isinstance(rid, int)
-    ts = _lesson_created_at(pd, "default ts lesson")
-    assert ts is not None and ts.strip() != ""  # column DEFAULT datetime('now') applied
-
-
-def test_insert_lesson_stores_explicit_created_at():
-    pd = "C:/proj/lessons"
-    rid = memory_db.insert_lesson(
-        "explicit ts lesson", "body of the explicit-timestamp lesson", "lesson",
-        project_dir=pd, created_at="2026-02-24 16:55:18",
-    )
-    assert isinstance(rid, int)
-    assert _lesson_created_at(pd, "explicit ts lesson") == "2026-02-24 16:55:18"
-
-
-def test_insert_lesson_explicit_created_at_is_searchable():
-    # Proves _index_fts fired on the explicit-timestamp INSERT path.
-    pd = "C:/proj/lessons"
-    memory_db.insert_lesson(
-        "searchable timestamped lesson",
-        "deployment pipeline runbook for the beta service",
-        "lesson",
-        project_dir=pd, created_at="2026-02-24 16:55:18",
-    )
-    results = memory_db.search_memory("deployment pipeline runbook", project_dir=pd)
-    assert any("deployment pipeline runbook" in r["content"] for r in results)