memstack-skill-loader 4.17.0__tar.gz → 4.18.1__tar.gz

{memstack_skill_loader-4.17.0/src/memstack_skill_loader.egg-info → memstack_skill_loader-4.18.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memstack-skill-loader
-Version: 4.17.0
+Version: 4.18.1
 Summary: MCP server that vector-indexes MemStack Pro skills for on-demand loading
 Project-URL: Homepage, https://memstack.pro
 Project-URL: Documentation, https://memstack.pro/docs

{memstack_skill_loader-4.17.0 → memstack_skill_loader-4.18.1}/pyproject.toml

@@ -1,51 +1,51 @@
-[build-system]
-requires = ["setuptools>=68.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "memstack-skill-loader"
-version = "4.17.0"
-description = "MCP server that vector-indexes MemStack Pro skills for on-demand loading"
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = [
-    # Upper bound is load-bearing: mcp 2.0.0 (2026-07-28) removed the
-    # Server.list_tools()/call_tool() decorator API that server.py is built on.
-    # Do not relax without porting server.py to the 2.x API first.
-    "mcp>=1.0.0,<2.0.0",
-    "lancedb>=0.6.0",
-    "sentence-transformers>=2.2.0",
-    "pyarrow>=14.0.0",
-    "httpx>=0.24.0",
-    "aiohttp>=3.9",
-]
-
-[project.urls]
-Homepage = "https://memstack.pro"
-Documentation = "https://memstack.pro/docs"
-
-[project.optional-dependencies]
-# setuptools is a TEST dependency here, not only a build dependency. The
-# packaging guard in tests/test_wheel_contents.py builds a wheel and inspects
-# it, and it fails rather than skips when the backend is absent, because a skip
-# is a silent pass. Python 3.12+ venvs no longer ship setuptools, so a bare venv
-# needs:  pip install -e ".[dev]"
-dev = ["setuptools>=68"]
-
-[project.scripts]
-memstack-index = "memstack_skill_loader.indexer:main"
-
-[tool.setuptools.packages.find]
-where = ["src"]
-
-[tool.setuptools.package-data]
-memstack_skill_loader = ["dashboard.html", "skill_descriptions.json"]
-
-[tool.pytest.ini_options]
-# Test the WORKING TREE, not whatever is installed. This package is installed
-# non-editable, so without this the suite imported memstack_skill_loader from
-# site-packages and silently graded a stale copy: a source change could be
-# green here and still be broken, and a new test could fail against code that
-# was already fixed. pythonpath puts src/ ahead of site-packages for the whole
-# suite, so `python -m pytest` needs no PYTHONPATH prefix to be correct.
-pythonpath = ["src"]
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "memstack-skill-loader"
+version = "4.18.1"
+description = "MCP server that vector-indexes MemStack Pro skills for on-demand loading"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    # Upper bound is load-bearing: mcp 2.0.0 (2026-07-28) removed the
+    # Server.list_tools()/call_tool() decorator API that server.py is built on.
+    # Do not relax without porting server.py to the 2.x API first.
+    "mcp>=1.0.0,<2.0.0",
+    "lancedb>=0.6.0",
+    "sentence-transformers>=2.2.0",
+    "pyarrow>=14.0.0",
+    "httpx>=0.24.0",
+    "aiohttp>=3.9",
+]
+
+[project.urls]
+Homepage = "https://memstack.pro"
+Documentation = "https://memstack.pro/docs"
+
+[project.optional-dependencies]
+# setuptools is a TEST dependency here, not only a build dependency. The
+# packaging guard in tests/test_wheel_contents.py builds a wheel and inspects
+# it, and it fails rather than skips when the backend is absent, because a skip
+# is a silent pass. Python 3.12+ venvs no longer ship setuptools, so a bare venv
+# needs:  pip install -e ".[dev]"
+dev = ["setuptools>=68"]
+
+[project.scripts]
+memstack-index = "memstack_skill_loader.indexer:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+memstack_skill_loader = ["dashboard.html", "skill_descriptions.json"]
+
+[tool.pytest.ini_options]
+# Test the WORKING TREE, not whatever is installed. This package is installed
+# non-editable, so without this the suite imported memstack_skill_loader from
+# site-packages and silently graded a stale copy: a source change could be
+# green here and still be broken, and a new test could fail against code that
+# was already fixed. pythonpath puts src/ ahead of site-packages for the whole
+# suite, so `python -m pytest` needs no PYTHONPATH prefix to be correct.
+pythonpath = ["src"]

{memstack_skill_loader-4.17.0 → memstack_skill_loader-4.18.1}/src/memstack_skill_loader/__init__.py

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

{memstack_skill_loader-4.17.0 → memstack_skill_loader-4.18.1}/src/memstack_skill_loader/diary_ingest.py

@@ -6,6 +6,10 @@ module by path, exactly like the devlog-webhook:
 
     python -m memstack_skill_loader.diary_ingest "<markdown-backup-path>"
 
+Pass ``--project NAME`` to override the derived project entirely. That is the
+escape hatch for a project whose real name looks like another project's name
+plus a suffix, which the derivation's third rung would otherwise shorten.
+
 Each fact line is stored through :class:`MemoryStore` with ``source_type='diary'``
 and ``source_ref`` set to the diary file path, canonicalized to an absolute
 forward-slash path so the same file re-ingested from any cwd/arg form dedupes.
@@ -18,10 +22,16 @@ already safe on disk before this starts.
 
 What changed from "always exits 0": the exit code now classifies the outcome,
 and every run over a diary that HAS a FACTS block prints one stdout summary
-(N ingested, M duplicate, K skipped) plus one indented reason per skipped line.
-Silence used to be the only output on success, which made a clean ingest
-indistinguishable from a hook that never ran, a wrong path, or a block that
-parsed to nothing.
+(N ingested, M duplicate, K skipped into project 'X') plus one indented reason
+per skipped line. Silence used to be the only output on success, which made a
+clean ingest indistinguishable from a hook that never ran, a wrong path, or a
+block that parsed to nothing.
+
+The summary NAMES THE PROJECT it wrote to, and marks a namespace nothing has
+ever been stored under as NEW. Counting alone was not enough: a diary misfiled
+under a phantom namespace still reported a perfectly clean "17 ingested" and
+exited 0, so the number a reader would check was right while the facts were
+unreachable from any recall for the real project.
 
   exit 0  nothing was lost: no FACTS block at all (silent, nothing on stdout),
           or at least one fact ingested, or an all-duplicates re-run of an
@@ -230,54 +240,122 @@ def parse_facts_block(text: str) -> FactsParse:
     return FactsParse(present=True, facts=facts, errors=errors, linenos=linenos)
 
 
-def _resolves(name: str) -> bool:
+def _resolves(name: str, failures: list[str] | None = None) -> bool:
     """True if the store already knows a project directory with this basename.
 
     Any non-empty result counts. Two hits mean an ambiguous basename collision,
     not "unknown" -- we only need to know the name exists, never which directory
     it maps to. Fail-open: an unreachable store answers "unknown", which leaves
     the raw slug in place rather than breaking the diary save.
+
+    Failing open is still right, but it used to be SILENT, and a silent
+    "unknown" is indistinguishable from a real one: an unreachable store minted
+    a phantom namespace for every project on the machine and said nothing. So
+    the first failure of a derivation warns, naming only the exception CLASS.
+    The exception's message is never echoed -- it is attacker-influenced free
+    text in the same sense a claim is, and the secrets policy forbids printing
+    what has not cleared an allowlist.
+
+    ``failures`` collects the classes seen so one derivation warns once rather
+    than once per rung; passing None keeps the single-shot behavior for direct
+    callers.
     """
     try:
         return bool(find_project_dirs_by_name(name))
-    except Exception:  # noqa: BLE001 -- never break the diary-save path
+    except Exception as exc:  # noqa: BLE001 -- never break the diary-save path
+        if not failures:
+            _warn(
+                f"project lookup failed ({type(exc).__name__}); cannot tell a "
+                f"known project from a new one, so the derived slug stands as-is"
+            )
+        if failures is not None:
+            failures.append(type(exc).__name__)
         return False
 
 
-def _project_from_path(path: str) -> str:
-    """Derive a dotted-path project slug from a diary filename.
+def _derive_project(path: str) -> tuple[str, bool]:
+    """Derive a project slug from a diary filename, and say whether it resolved.
+
+    Returns ``(slug, resolved)``. ``resolved`` is True when some rung matched a
+    project the store already knows, and False when every rung fell through and
+    the raw slug is standing on its own. The caller needs that second value to
+    tell "this diary belongs to a known project" from "this diary is about to
+    mint a namespace nobody has ever seen", which is the distinction the summary
+    line now reports.
 
     ``2026-07-20-memstack-skill-loader.md`` -> ``memstack-skill-loader``.
 
-    The diary skill writes ``{date}-{project}-N.md`` when a project already has a
-    diary for that date. Deriving the slug from the filename alone turned that
-    trailing ``-3`` into a separate project, stranding every ingested fact under
-    a phantom slug that no recall for the real project would ever reach.
-
-    So the raw name is checked against the store first, and only if it is unknown
-    do we try stripping a trailing ``-<digits>``. Checking raw first is what keeps
-    a project *genuinely* named with a trailing number (``proj-2``) resolving to
-    itself -- the suffix is only ever stripped when doing so turns an unknown name
-    into a known one. If neither resolves, the raw slug stands and downstream
-    auto-registration handles the genuinely-new project as before.
+    Three rungs, tried in order, first hit wins:
+
+    1. The raw slug, exactly. Checking raw FIRST is what keeps a project
+       genuinely named with a trailing number (``proj-2``) or a name that merely
+       looks like a suffix resolving to itself: a suffix is only ever stripped
+       when doing so turns an unknown name into a known one.
+    2. A trailing ``-<digits>`` stripped. The diary skill writes
+       ``{date}-{project}-N.md`` when a project already has a diary for that
+       date, and that ``-3`` used to become a separate project.
+    3. Trailing ``-segments`` stripped progressively, longest first. A diary
+       named ``{date}-{project}-{topic}.md`` -- the documented format is
+       ``{date}-{project}.md``, but descriptive names are written constantly --
+       filed every fact under ``{project}-{topic}``, invisible to any recall for
+       ``{project}``. ``foreman-turn-record`` tries ``foreman-turn``, then
+       ``foreman``. 495 facts across 37 phantom namespaces accumulated this way
+       before rung 3 existed.
+
+    Rung 3 is bounded by the segment count and never strips to empty, so the
+    last candidate it can offer is the first segment alone.
+
+    If nothing resolves the raw slug stands, exactly as before, and downstream
+    auto-registration handles the genuinely-new project -- but the caller now
+    knows to say so out loud.
+
+    Rung 3 is deliberately greedy, and that trades one silent failure for a
+    loud, correctable one: a genuinely distinct project whose name begins with
+    a known project's name (``deedstack-mobile`` alongside ``deedstack``) will
+    resolve to the shorter one and SAY it did. The escape hatch is the
+    ``--project`` flag, which skips derivation entirely.
     """
     stem = Path(path).stem
     m = _DATE_PREFIX.match(stem)
     raw = m.group(1) if m else stem
     slug = re.sub(r"[^a-z0-9_-]+", "-", raw.lower()).strip("-_") or "default"
 
-    if _resolves(slug):
-        return slug
+    # One list per derivation, so an unreachable store warns once, not per rung.
+    failures: list[str] = []
+
+    if _resolves(slug, failures):
+        return slug, True
 
     stripped = _SUFFIX_N.sub("", slug)
-    if stripped and stripped != slug and _resolves(stripped):
+    if stripped and stripped != slug and _resolves(stripped, failures):
         _warn(
             f"project {slug!r} is unknown but {stripped!r} is a known project -- "
             f"ingesting under {stripped!r} (stripped a trailing -N diary suffix)"
         )
-        return stripped
+        return stripped, True
+
+    # Rung 3: drop trailing '-segments' one at a time, longest candidate first.
+    # Bounded by the segment count; the loop stops with one segment left, so a
+    # candidate is never empty.
+    segments = slug.split("-")
+    for cut in range(len(segments) - 1, 0, -1):
+        candidate = "-".join(segments[:cut])
+        if candidate == stripped and stripped != slug:
+            continue  # rung 2 already asked about this exact name
+        if _resolves(candidate, failures):
+            _warn(
+                f"project {slug!r} is unknown but {candidate!r} is a known "
+                f"project -- ingesting under {candidate!r} (stripped a "
+                f"descriptive diary suffix)"
+            )
+            return candidate, True
+
+    return slug, False
+
 
-    return slug
+def _project_from_path(path: str) -> str:
+    """The derived slug alone, for callers that do not need the resolved flag."""
+    return _derive_project(path)[0]
 
 
 def _canonical_source_ref(path: str) -> str:
@@ -337,16 +415,27 @@ def _summary(
     }
 
 
-def _report(path: str, summary: dict) -> None:
+def _report(path: str, summary: dict, project: str, is_new: bool) -> None:
     """Print the one stdout summary. Callers can read this; stderr they ignore.
 
     Only ever called for a diary that HAS a FACTS block, so a diary without one
     stays silent on stdout as well as stderr.
+
+    The summary NAMES THE NAMESPACE IT WROTE TO. It did not, and that omission
+    is what let a whole class of misfiling stay invisible: every phantom-project
+    ingest printed a clean "N ingested" and exited 0, so the one number a reader
+    would have checked was correct and the one fact they needed was absent.
+    ``NEW`` marks a namespace no fact has ever been stored under, which is the
+    single cheapest signal that a derivation went somewhere unintended.
+
+    Everything stays on ONE line on purpose. A clean run must not emit a second
+    line, and must not put the word 'skipped' anywhere but the summary.
     """
+    label = f"NEW project {project!r}" if is_new else f"project {project!r}"
     print(
         f"{_PREFIX} {summary['ingested']} ingested, "
-        f"{summary['duplicates']} duplicate, {len(summary['skipped'])} skipped: "
-        f"{path}"
+        f"{summary['duplicates']} duplicate, {len(summary['skipped'])} skipped "
+        f"into {label}: {path}"
     )
     for reason in summary["skipped"]:
         print(f"  skipped {reason}")
@@ -359,13 +448,22 @@ def _report(path: str, summary: dict) -> None:
         )
 
 
-def ingest_diary_file(path: str, store: MemoryStore | None = None) -> dict:
+def ingest_diary_file(
+    path: str,
+    store: MemoryStore | None = None,
+    project: str | None = None,
+) -> dict:
     """Parse and ingest the FACTS block from a saved diary markdown file.
 
     Fail-open: returns a summary dict and never raises. Each problem prints one
     stderr line, and a diary with a FACTS block also gets one stdout summary.
     Returns ``{present, ingested, duplicates, attempted, skipped, errors,
-    store_failure, exit_code}``.
+    store_failure, exit_code, project}``.
+
+    ``project`` overrides filename derivation entirely and silently: an explicit
+    name is a decision already made, so there is nothing to warn about. It is
+    the escape hatch for a project whose real name looks like another project's
+    name plus a suffix, which rung 3 of the derivation would otherwise shorten.
     """
     try:
         text = Path(path).read_text(encoding="utf-8")
@@ -385,7 +483,29 @@ def ingest_diary_file(path: str, store: MemoryStore | None = None) -> dict:
 
     if store is None:
         store = MemoryStore()
-    project = _project_from_path(path)
+
+    if project:
+        # An explicit name is a decision already made: no derivation, no warning.
+        resolved = True
+    else:
+        project, resolved = _derive_project(path)
+
+    # "NEW" means no fact has EVER been stored under this namespace, asked
+    # before this run writes any. Deliberately a different question from
+    # _resolves, which consults the five legacy project_dir tables: a namespace
+    # that only ever held diary facts is invisible there, so it could never
+    # stop being "unknown" no matter how much it accumulated. This check reads
+    # memory_facts itself, so a phantom is announced once and only once.
+    is_new = False
+    if not resolved:
+        try:
+            is_new = store.stats(project=project)["total"] == 0
+        except Exception as exc:  # noqa: BLE001 -- never break the diary save
+            _warn(
+                f"could not check whether {project!r} is a new namespace "
+                f"({type(exc).__name__}); reporting it without the NEW marker"
+            )
+
     source_ref = _canonical_source_ref(path)
 
     skipped: list[str] = list(parsed.errors)   # malformed lines, already warned
@@ -437,26 +557,64 @@ def ingest_diary_file(path: str, store: MemoryStore | None = None) -> dict:
         skipped=skipped,
         store_failure=store_failure,
     )
-    _report(path, summary)
+    summary["project"] = project
+    _report(path, summary, project, is_new)
     return summary
 
 
+def _parse_argv(args: list[str]) -> tuple[str | None, str | None]:
+    """Split the CLI tail into ``(path, project)``. Never raises.
+
+    Accepts ``--project NAME`` and ``--project=NAME``. Unparseable input loses
+    nothing, so it warns and falls back to derivation rather than failing.
+    """
+    path: str | None = None
+    project: str | None = None
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == "--project":
+            if i + 1 < len(args) and args[i + 1] and not args[i + 1].startswith("--"):
+                project = args[i + 1]
+                i += 2
+                continue
+            _warn("--project needs a value; deriving the project from the filename")
+            i += 1
+            continue
+        if arg.startswith("--project="):
+            value = arg.split("=", 1)[1]
+            if value:
+                project = value
+            else:
+                _warn("--project needs a value; deriving the project from the filename")
+            i += 1
+            continue
+        if path is None:
+            path = arg
+        i += 1
+    return path, project
+
+
 def main(argv: list[str]) -> int:
     """Hook entry point. Never raises; the exit code classifies the outcome.
 
     0 = nothing lost, 1 = content total loss, 2 = store failure. See the
-    FAIL-OPEN CONTRACT in the module docstring.
+    FAIL-OPEN CONTRACT in the module docstring. Nothing added here changes an
+    exit code: every new warning path is still 0.
+
+    Usage: ``diary_ingest <diary.md> [--project NAME]``
     """
-    if len(argv) < 2 or not argv[1]:
+    path, project = _parse_argv(list(argv[1:]))
+    if not path:
         # A caller that passed no path lost nothing, because nothing was read.
         _warn("no diary path provided; nothing to ingest")
         return 0
     try:
-        return ingest_diary_file(argv[1])["exit_code"]
+        return ingest_diary_file(path, project=project)["exit_code"]
     except Exception as exc:
         # Absolute backstop: still never raises, but this is the store or
         # environment class of failure, so it is loud rather than silent.
-        _warn(f"unexpected error ingesting {argv[1]!r}: {exc}")
+        _warn(f"unexpected error ingesting {path!r}: {exc}")
         print(
             f"{_PREFIX} aborted, nothing ingested: {type(exc).__name__}: {exc}"
         )

{memstack_skill_loader-4.17.0 → memstack_skill_loader-4.18.1}/src/memstack_skill_loader/memory_db.py

@@ -11,6 +11,18 @@ from pathlib import Path, PureWindowsPath
 DB_PATH = Path.home() / ".memstack" / "memory.db"
 SCHEMA_VERSION = 1
 
+#: Seconds a connection waits for a lock before raising "database is locked".
+#: Deliberately the same number as ``memory_engine._BUSY_TIMEOUT_S``: the two
+#: modules open connections to the SAME file, and a five-second waiter losing to
+#: a thirty-second one is a difference with no reason behind it.
+#:
+#: This is a cushion for TRANSIENT contention, not a fix for a held lock. The
+#: rehome migration used to compute its map inside its own BEGIN IMMEDIATE, so
+#: every connection opened here waited the full timeout and then failed no
+#: matter how large the number was — the holder was the caller. That map now
+#: runs before the write lock is taken, so this timeout should never be reached.
+_BUSY_TIMEOUT_S = 30
+
 # ── project_dir canonicalization ─────────────────────────────────────────────
 # project_dir was stored raw from os.getcwd(), which on Windows returns whichever
 # drive-letter case the process happened to be launched with. Two spellings of
@@ -63,11 +75,20 @@ def _resolve_db_path() -> Path:
 
 
 def _get_conn() -> sqlite3.Connection:
+    # NOTE: opening a connection WRITES. _init_tables ends with an
+    # "INSERT OR IGNORE INTO schema_version", and SQLite takes the write lock
+    # at statement start whether or not the row already exists. So this is not
+    # a read-only operation and must never be called from inside another
+    # transaction on the same file.
     db_path = _resolve_db_path()
     db_path.parent.mkdir(parents=True, exist_ok=True)
-    conn = sqlite3.connect(str(db_path), timeout=5)
+    conn = sqlite3.connect(str(db_path), timeout=_BUSY_TIMEOUT_S)
     conn.row_factory = sqlite3.Row
     conn.execute("PRAGMA journal_mode=WAL")
+    # Stated as a PRAGMA as well as the connect() kwarg. They set the same
+    # thing, but the PRAGMA is the one that survives a future refactor of the
+    # connect call, and it is the form the engine uses.
+    conn.execute(f"PRAGMA busy_timeout={_BUSY_TIMEOUT_S * 1000}")
     _init_tables(conn)
     return conn
 
@@ -771,59 +792,67 @@ def find_project_dirs_by_name(name: str) -> list[str]:
     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.
-    """
-    try:
-        if name is None:
-            return []
-        if not isinstance(name, str):
-            name = str(name)
-        key = name.strip().lower()
-        if not key:
-            return []
 
-        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()
+    RAISES on an unreachable store. This used to swallow every exception and
+    return ``[]``, which made "the store has never seen this project" and "the
+    store could not be read" the same answer. That cost a data migration: the
+    rehome migration's fail-open tripwire lives in ``diary_ingest._resolves``,
+    one level ABOVE this function, and could never fire because the exception
+    died here. A caller that wants to continue without an answer catches it and
+    says so; a caller that must not guess lets it propagate. Both exist.
 
-        matches = set()
-        for row in rows:
-            pdir = row[0]
-            if not pdir:
-                continue
-            if PureWindowsPath(pdir).name.lower() == key:
-                matches.add(pdir)
-
-        # Collapse spellings that denote the SAME directory (drive-letter case,
-        # separator style) before counting — otherwise one stray "c:\..." row
-        # turns a perfectly well-known project into an ambiguous one. Distinct
-        # directories that merely share a basename remain separate entries.
-        groups: dict = {}
-        for match in matches:
-            groups.setdefault(_project_dir_key(match), []).append(match)
-
-        # Deterministic representative per group: sorted() puts the upper-case
-        # drive first, and canonicalizing makes the result independent of which
-        # spellings happen to be in the store.
-        return sorted(
-            canonical_project_dir(sorted(spellings)[0])
-            for spellings in groups.values()
-        )
-    except Exception as exc:
-        print(
-            f"[memstack-memory] find_project_dirs_by_name failed: {exc}",
-            file=sys.stderr,
-        )
+    Removing the swallow also removed a ``print`` of the raw exception text.
+    That string is not allowlisted and could carry a path or a connection
+    string, so the callers now report the exception CLASS and nothing else.
+
+    Bad INPUT is still not an error: None, a non-string and an empty name all
+    return ``[]``, because those are answerable questions whose answer is "no".
+    """
+    if name is None:
         return []
+    if not isinstance(name, str):
+        name = str(name)
+    key = name.strip().lower()
+    if not key:
+        return []
+
+    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)
+
+    # Collapse spellings that denote the SAME directory (drive-letter case,
+    # separator style) before counting — otherwise one stray "c:\..." row
+    # turns a perfectly well-known project into an ambiguous one. Distinct
+    # directories that merely share a basename remain separate entries.
+    groups: dict = {}
+    for match in matches:
+        groups.setdefault(_project_dir_key(match), []).append(match)
+
+    # Deterministic representative per group: sorted() puts the upper-case
+    # drive first, and canonicalizing makes the result independent of which
+    # spellings happen to be in the store.
+    return sorted(
+        canonical_project_dir(sorted(spellings)[0])
+        for spellings in groups.values()
+    )
 
 
 def resolve_project_dir_by_name(name: str) -> str | None:
@@ -833,8 +862,24 @@ def resolve_project_dir_by_name(name: str) -> str | None:
     no sensible behavior for a collision. Callers that must distinguish "never
     seen" from "shares a basename with another project" — and act differently —
     should use :func:`find_project_dirs_by_name` and inspect the length.
+
+    FAIL-OPEN, and this is where that decision now lives rather than inside the
+    lookup. Every caller of this function already treats ``None`` as "no usable
+    path", so an unreachable store degrading to ``None`` changes nothing for
+    them, and the alternative — raising into paths that only wanted a directory
+    name — would break working features to report a condition they cannot act
+    on. Only the exception CLASS is printed; the message is attacker-influenced
+    free text and is never echoed.
     """
-    matches = find_project_dirs_by_name(name)
+    try:
+        matches = find_project_dirs_by_name(name)
+    except Exception as exc:  # noqa: BLE001 -- see FAIL-OPEN above
+        print(
+            f"[memstack-memory] project lookup failed ({type(exc).__name__}); "
+            f"treating the project as unknown",
+            file=sys.stderr,
+        )
+        return None
     return matches[0] if len(matches) == 1 else None