symgrep-codesearch 0.7.1__tar.gz → 0.7.2__tar.gz

{symgrep_codesearch-0.7.1 → symgrep_codesearch-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symgrep-codesearch
-Version: 0.7.1
+Version: 0.7.2
 Summary: Code search with honest recall — structure-aware grep that tells you what it does not know, plus search by meaning
 License-Expression: MIT
 Project-URL: Repository, https://github.com/ashdamle/symgrep

{symgrep_codesearch-0.7.1 → symgrep_codesearch-0.7.2}/pyproject.toml

@@ -31,7 +31,7 @@ name = "symgrep-codesearch"
 # semantic search. Minor bump (dependency surface changed; no breaking import/CLI/MCP change).
 # 0.5.0: added the public `file_structure` library API (+ its MCP tool and `symgrep structure` CLI), import
 # module-name normalization, and the FileStructure `connects` list (structure schema v2).
-version = "0.7.1"
+version = "0.7.2"
 description = "Code search with honest recall — structure-aware grep that tells you what it does not know, plus search by meaning"
 readme = "README.md"
 # 3.11+ : the maintained grammar pack (tree-sitter-language-pack, a CORE dep below) ships abi3 wheels for

{symgrep_codesearch-0.7.1 → symgrep_codesearch-0.7.2}/src/symgrep/mcp_server.py

@@ -14,6 +14,8 @@ importing symgrep in-process into a venv that lacks fastembed. Loopback only, by
 """
 
 import json
+import logging
+from logging.handlers import RotatingFileHandler
 import os
 import sys
 import traceback
@@ -21,6 +23,7 @@ from typing import List, Optional
 
 from .report import DEFAULT_MAX_SITES, render_report
 from .cli import build_report
+from .runtime_paths import resolved_mcp_log_path
 
 PROTOCOL_VERSION_FALLBACK = "2024-11-05"
 HTTP_HOST_DEFAULT = "127.0.0.1"        # $SYMGREP_MCP_HOST — loopback unless deliberately widened
@@ -28,6 +31,87 @@ HTTP_HOST_DEFAULT = "127.0.0.1"        # $SYMGREP_MCP_HOST — loopback unless d
 # engine): 4900 ccwatch · 4910 7thsense · 4911 symgrep. Override via $SYMGREP_MCP_PORT.
 HTTP_PORT_DEFAULT = 4911
 HTTP_PATH = "/mcp"                     # mirrors ccwatch's POST /mcp convention
+MCP_LOG_MAX_BYTES_DEFAULT = 5 * 1024 * 1024
+MCP_LOG_BACKUP_COUNT_DEFAULT = 3
+MCP_REQUEST_LOGGER_NAME = "symgrep.mcp.requests"
+
+
+def _mcp_request_logger() -> logging.Logger:
+    """Return the rotating request logger, rebinding it when SYMGREP_LOG changes at runtime."""
+    log_path = resolved_mcp_log_path()
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    request_logger = logging.getLogger(MCP_REQUEST_LOGGER_NAME)
+    request_logger.setLevel(logging.INFO)
+    request_logger.propagate = False
+    current_path = getattr(request_logger, "_symgrep_log_path", None)
+    if current_path != str(log_path):
+        for existing_handler in list(request_logger.handlers):
+            existing_handler.close()
+            request_logger.removeHandler(existing_handler)
+        rotating_handler = RotatingFileHandler(
+            log_path, maxBytes=int(os.environ.get("SYMGREP_LOG_MAX_BYTES", MCP_LOG_MAX_BYTES_DEFAULT)),
+            backupCount=int(os.environ.get("SYMGREP_LOG_BACKUP_COUNT", MCP_LOG_BACKUP_COUNT_DEFAULT)),
+            encoding="utf-8")
+        rotating_handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
+        request_logger.addHandler(rotating_handler)
+        request_logger._symgrep_log_path = str(log_path)
+    return request_logger
+
+
+def _summarize_mcp_tool_arguments(tool_arguments: dict) -> str:
+    """Create a compact mechanical summary without dropping the pattern or single-file path."""
+    parts = []
+    for argument_name in sorted(tool_arguments):
+        argument_value = tool_arguments[argument_name]
+        if argument_name == "roots" and isinstance(argument_value, list):
+            rendered_value = f"{len(argument_value)} root(s)"
+        elif argument_value in (None, False, [], ""):
+            continue
+        else:
+            rendered_value = repr(argument_value)
+        parts.append(f"{argument_name}={rendered_value}")
+    return ", ".join(parts)
+
+
+def _returned_mcp_error_details(tool_result):
+    """Parse only server-authored error fields/prefixes; normal search verdicts are not errors."""
+    parsed_result = tool_result
+    if isinstance(tool_result, str):
+        try:
+            parsed_result = json.loads(tool_result)
+        except (TypeError, json.JSONDecodeError):
+            if tool_result.startswith("semantic search UNAVAILABLE"):
+                return "unavailable", tool_result
+            return None
+    if not isinstance(parsed_result, dict):
+        return None
+    status = parsed_result.get("status")
+    if status in ("unavailable", "no_index"):
+        return parsed_result.get("reason") or status, parsed_result.get("message") or repr(parsed_result)
+    if "error" in parsed_result:
+        error_value = parsed_result["error"]
+        if isinstance(error_value, dict):
+            return error_value.get("code", "error"), error_value.get("message") or repr(error_value)
+        return "error", str(error_value)
+    if parsed_result.get("refused") is True:
+        return "refused", parsed_result.get("message") or repr(parsed_result)
+    return None
+
+
+def _invoke_logged_mcp_tool(tool_name: str, tool_arguments: dict, invocation):
+    """Run one tool call and make every raised or returned error durable in the MCP log."""
+    argument_summary = _summarize_mcp_tool_arguments(tool_arguments)
+    try:
+        tool_result = invocation()
+    except Exception:
+        _mcp_request_logger().exception("tool=%s args={%s} raised", tool_name, argument_summary)
+        raise
+    returned_error = _returned_mcp_error_details(tool_result)
+    if returned_error is not None:
+        error_code, error_message = returned_error
+        _mcp_request_logger().warning("tool=%s args={%s} returned error code=%s message=%s",
+                                      tool_name, argument_summary, error_code, error_message)
+    return tool_result
 
 
 def _package_version() -> str:
@@ -194,15 +278,24 @@ def _run_fastmcp(http=None) -> bool:
         roots: directories/files to search (absolute paths preferred).
         globs: rg --glob filters, e.g. ["*.py"].
         """
-        return _search(pattern, roots, case_insensitive, fixed_string,
-                       multiline, globs, include_ignored, max_sites, semantic, k, json_output, structured,
-                       structural, lang, usage, resolve, unit, kind)
+        tool_arguments = {"pattern": pattern, "roots": roots, "case_insensitive": case_insensitive,
+                          "fixed_string": fixed_string, "multiline": multiline, "globs": globs,
+                          "include_ignored": include_ignored, "max_sites": max_sites, "semantic": semantic,
+                          "k": k, "json_output": json_output, "structured": structured,
+                          "structural": structural, "lang": lang, "usage": usage, "resolve": resolve,
+                          "unit": unit, "kind": kind}
+        return _invoke_logged_mcp_tool(
+            "search", tool_arguments,
+            lambda: _search(pattern, roots, case_insensitive, fixed_string, multiline, globs,
+                            include_ignored, max_sites, semantic, k, json_output, structured,
+                            structural, lang, usage, resolve, unit, kind))
 
     @mcp.tool(description="Structural symbols of ONE file: every function/class with its line span and "
                           "basis (ast/treesitter/…). The AST layer without an in-process import.")
     def file_symbols(path: str) -> str:
         from .mcp_structured import structured_file_symbols
-        return json.dumps(structured_file_symbols(path))
+        return _invoke_logged_mcp_tool(
+            "file_symbols", {"path": path}, lambda: json.dumps(structured_file_symbols(path)))
 
     @mcp.tool(description="Mechanical STRUCTURE of ONE file, from the same grammar parse: {schema_version, "
                           "language, basis, functions:[{name,signature,start,end}], classes, imports, "
@@ -212,13 +305,15 @@ def _run_fastmcp(http=None) -> bool:
                           "caller's agentic layer).")
     def file_structure(path: str) -> str:
         from .mcp_structured import structured_file_structure
-        return json.dumps(structured_file_structure(path))
+        return _invoke_logged_mcp_tool(
+            "file_structure", {"path": path}, lambda: json.dumps(structured_file_structure(path)))
 
     @mcp.tool(description="The roots the semantic index covers, so an un-hit query reads as 'not indexed "
                           "here' vs 'indexed, nothing near'.")
     def indexed_roots() -> str:
         from .mcp_structured import structured_indexed_roots
-        return json.dumps(structured_indexed_roots())
+        return _invoke_logged_mcp_tool(
+            "indexed_roots", {}, lambda: json.dumps(structured_indexed_roots()))
 
     if http:
         host, port = http
@@ -305,26 +400,26 @@ def _fallback_handle(req):
         name = params.get("name")
         a = params.get("arguments", {})
         if name == "search":
-            text = _search(a["pattern"], a.get("roots"),
-                           a.get("case_insensitive", False),
-                           a.get("fixed_string", False),
-                           a.get("multiline", False),
-                           a.get("globs"), a.get("include_ignored", False),
-                           a.get("max_sites", DEFAULT_MAX_SITES),
-                           a.get("semantic", False), a.get("k", 8),
-                           a.get("json_output", False), a.get("structured", False),
-                           a.get("structural", False), a.get("lang"),
-                           a.get("usage", False), a.get("resolve", False),
-                           a.get("unit", "symbol"), a.get("kind"))
+            text = _invoke_logged_mcp_tool(
+                name, a, lambda: _search(
+                    a["pattern"], a.get("roots"), a.get("case_insensitive", False),
+                    a.get("fixed_string", False), a.get("multiline", False), a.get("globs"),
+                    a.get("include_ignored", False), a.get("max_sites", DEFAULT_MAX_SITES),
+                    a.get("semantic", False), a.get("k", 8), a.get("json_output", False),
+                    a.get("structured", False), a.get("structural", False), a.get("lang"),
+                    a.get("usage", False), a.get("resolve", False), a.get("unit", "symbol"), a.get("kind")))
         elif name == "file_symbols":
             from .mcp_structured import structured_file_symbols
-            text = json.dumps(structured_file_symbols(a["path"]))
+            text = _invoke_logged_mcp_tool(
+                name, a, lambda: json.dumps(structured_file_symbols(a["path"])))
         elif name == "file_structure":
             from .mcp_structured import structured_file_structure
-            text = json.dumps(structured_file_structure(a["path"]))
+            text = _invoke_logged_mcp_tool(
+                name, a, lambda: json.dumps(structured_file_structure(a["path"])))
         elif name == "indexed_roots":
             from .mcp_structured import structured_indexed_roots
-            text = json.dumps(structured_indexed_roots())
+            text = _invoke_logged_mcp_tool(
+                name, a, lambda: json.dumps(structured_indexed_roots()))
         else:
             raise ValueError(f"unknown tool {name!r}")
         return {"content": [{"type": "text", "text": text}]}
@@ -343,12 +438,16 @@ def _run_fallback() -> None:
         except json.JSONDecodeError:
             # JSON-RPC 2.0: a parse error is answered (-32700), not dropped — a client that sent
             # malformed JSON and hears nothing waits forever.
-            print(json.dumps({"jsonrpc": "2.0", "id": None,
-                              "error": {"code": -32700, "message": "parse error"}}), flush=True)
+            parse_error = {"code": -32700, "message": "parse error"}
+            _mcp_request_logger().warning("tool=jsonrpc args={} returned error code=%s message=%s",
+                                          parse_error["code"], parse_error["message"])
+            print(json.dumps({"jsonrpc": "2.0", "id": None, "error": parse_error}), flush=True)
             continue
         if not isinstance(req, dict):
-            print(json.dumps({"jsonrpc": "2.0", "id": None,
-                              "error": {"code": -32600, "message": "invalid request"}}), flush=True)
+            invalid_request_error = {"code": -32600, "message": "invalid request"}
+            _mcp_request_logger().warning("tool=jsonrpc args={} returned error code=%s message=%s",
+                                          invalid_request_error["code"], invalid_request_error["message"])
+            print(json.dumps({"jsonrpc": "2.0", "id": None, "error": invalid_request_error}), flush=True)
             continue
         rid = req.get("id")
         try:
@@ -356,17 +455,18 @@ def _run_fallback() -> None:
             if result is None and rid is not None:
                 # a REQUEST (has id) for a method we don't serve gets -32601, not silence;
                 # notifications (no id) legitimately get nothing.
-                print(json.dumps({"jsonrpc": "2.0", "id": rid,
-                                  "error": {"code": -32601,
-                                            "message": f"method not found: {req.get('method')!r}"}}),
-                      flush=True)
+                method_error = {"code": -32601, "message": f"method not found: {req.get('method')!r}"}
+                _mcp_request_logger().warning("tool=jsonrpc args={method=%r} returned error code=%s message=%s",
+                                              req.get("method"), method_error["code"], method_error["message"])
+                print(json.dumps({"jsonrpc": "2.0", "id": rid, "error": method_error}), flush=True)
                 continue
         except Exception as e:
+            _mcp_request_logger().exception("tool=jsonrpc args={method=%r} raised", req.get("method"))
             if rid is not None:
-                print(json.dumps({"jsonrpc": "2.0", "id": rid,
-                                  "error": {"code": -32603,
-                                            "message": f"{type(e).__name__}: {e}"}}),
-                      flush=True)
+                internal_error = {"code": -32603, "message": f"{type(e).__name__}: {e}"}
+                _mcp_request_logger().warning("tool=jsonrpc args={method=%r} returned error code=%s message=%s",
+                                              req.get("method"), internal_error["code"], internal_error["message"])
+                print(json.dumps({"jsonrpc": "2.0", "id": rid, "error": internal_error}), flush=True)
             continue
         if rid is not None and result is not None:
             print(json.dumps({"jsonrpc": "2.0", "id": rid, "result": result}),
@@ -383,6 +483,8 @@ def main() -> None:
             sys.exit(2)
         host = os.environ.get("SYMGREP_MCP_HOST", HTTP_HOST_DEFAULT)
         port = int(os.environ.get("SYMGREP_MCP_PORT", HTTP_PORT_DEFAULT))
+        _mcp_request_logger()                         # create the rotating request log before serving
+        sys.stderr.write(f"symgrep-mcp: error log {resolved_mcp_log_path()}\n")
         # WARM SHARED DAEMON = SINGLETON (one per port): every session CONNECTS to this warm HTTP server via urllib
         # instead of spawning a stdio copy. A second start detects the incumbent (flock via spendguard's single-instance
         # primitive) and exits 0 — never races FastMCP into a bind crash — so a supervisor can (re)start it idempotently.

symgrep_codesearch-0.7.2/src/symgrep/runtime_paths.py

@@ -0,0 +1,26 @@
+"""Shared runtime paths used by the server and its lifecycle hooks."""
+
+import os
+import pathlib
+
+
+SYMGREP_CACHE_DIRECTORY_ENV = "SYMGREP_CACHE_DIR"
+SYMGREP_LOG_PATH_ENV = "SYMGREP_LOG"
+SYMGREP_CACHE_DIRECTORY_NAME = "symgrep"
+SYMGREP_MCP_LOG_FILENAME = "mcp.log"
+
+
+def resolved_symgrep_cache_directory() -> pathlib.Path:
+    """Return symgrep's configured cache directory, using the repository's existing user-cache default."""
+    configured = os.environ.get(SYMGREP_CACHE_DIRECTORY_ENV)
+    if configured:
+        return pathlib.Path(configured).expanduser()
+    return pathlib.Path.home() / ".cache" / SYMGREP_CACHE_DIRECTORY_NAME
+
+
+def resolved_mcp_log_path() -> pathlib.Path:
+    """Return the request/crash log path shared by the MCP process and its ensure hook."""
+    configured = os.environ.get(SYMGREP_LOG_PATH_ENV)
+    if configured:
+        return pathlib.Path(configured).expanduser()
+    return resolved_symgrep_cache_directory() / SYMGREP_MCP_LOG_FILENAME

{symgrep_codesearch-0.7.1 → symgrep_codesearch-0.7.2}/src/symgrep/semantic.py

@@ -47,6 +47,8 @@ import sys
 import threading
 from typing import List, Optional, Tuple
 
+from .runtime_paths import resolved_symgrep_cache_directory
+
 MODEL = os.environ.get("SYMGREP_EMBED_MODEL", "BAAI/bge-small-en-v1.5")
 DIM = 384                        # bge-small-en-v1.5 geometry; veccore's ensure() guards it (DimMismatch)
 # The model is encoded in the COLLECTION name, so changing SYMGREP_EMBED_MODEL means a NEW collection — never
@@ -62,7 +64,7 @@ def index_path() -> pathlib.Path:
     import, so a test or caller setting it afterwards silently hit the real index (flagged by the seam
     axis as a one-sided `config:INDEX` contract, 2026-08-19)."""
     return pathlib.Path(os.environ.get("SYMGREP_INDEX")
-                        or (pathlib.Path.home() / ".cache" / "symgrep" / "semantic.sqlite"))
+                        or (resolved_symgrep_cache_directory() / "semantic.sqlite"))
 
 
 class Unavailable(RuntimeError):
@@ -106,15 +108,15 @@ def _veccore_present() -> bool:
     return importlib.util.find_spec("veccore") is not None
 
 
-# store+core are cached PER index path; the loaded embedder is a process-wide singleton. Guarded by a lock so
-# concurrent first calls (e.g. a threaded MCP server) build exactly one embedder + one store per path.
+# SQLite-backed store+core pairs are cached per thread and index path, so a daemon worker never reuses a
+# connection created by another worker. Thread-local lifetime also releases a worker's cache when it exits.
 _EMBEDDER = [None]
-_CORES = {}
+_SEMANTIC_THREAD_STATE = threading.local()
 _CACHE_LOCK = threading.Lock()
 
 
 def _core_for(path_str):
-    """(store, core) for the index at `path_str`, built once and cached under `_CACHE_LOCK`.
+    """(store, core) for the index at `path_str`, built once per calling thread under `_CACHE_LOCK`.
 
     CACHE STALENESS, explicitly: the cache is PROCESS-LIVED and keyed by the index PATH — every symgrep CLI run
     is a fresh process, so it starts empty. Within one process a store's sqlite connection SEES other
@@ -124,12 +126,16 @@ def _core_for(path_str):
     Tests point $SYMGREP_INDEX at distinct temp paths, so each gets its own entry. The embedder is
     path-independent (a reload per call was catastrophically slow), so it is shared. Maps veccore's store-open
     failure to symgrep's index_unusable; a missing veccore surfaced earlier as Unavailable(no_embedder)."""
-    hit = _CORES.get(path_str)
+    thread_cores = getattr(_SEMANTIC_THREAD_STATE, "cores_by_index_path", None)
+    if thread_cores is None:
+        thread_cores = {}
+        _SEMANTIC_THREAD_STATE.cores_by_index_path = thread_cores
+    hit = thread_cores.get(path_str)
     if hit is not None:
         return hit
     vc = _veccore()
     with _CACHE_LOCK:                                 # one builder wins; a racing caller re-reads the cache
-        hit = _CORES.get(path_str)
+        hit = thread_cores.get(path_str)
         if hit is not None:
             return hit
         try:
@@ -145,8 +151,8 @@ def _core_for(path_str):
         core.register(vc.CollectionSpec(name=COLLECTION, backend="sqlite_numpy", embedder=f"fastembed:{MODEL}",
                                         dim=DIM, payload_schema=("qual", "path", "lineno", "what", "stamp",
                                                                  "unit", "parent_key", "block_start", "block_end")))
-        _CORES[path_str] = (store, core)
-        return _CORES[path_str]
+        thread_cores[path_str] = (store, core)         # sqlite connections stay owned by their worker thread
+        return thread_cores[path_str]
 
 
 def _embedder():

{symgrep_codesearch-0.7.1 → symgrep_codesearch-0.7.2}/src/symgrep_codesearch.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symgrep-codesearch
-Version: 0.7.1
+Version: 0.7.2
 Summary: Code search with honest recall — structure-aware grep that tells you what it does not know, plus search by meaning
 License-Expression: MIT
 Project-URL: Repository, https://github.com/ashdamle/symgrep

{symgrep_codesearch-0.7.1 → symgrep_codesearch-0.7.2}/src/symgrep_codesearch.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ src/symgrep/resolve.py
 src/symgrep/resolve_js.py
 src/symgrep/resolve_python.py
 src/symgrep/ripgrep.py
+src/symgrep/runtime_paths.py
 src/symgrep/semantic.py
 src/symgrep/structural.py
 src/symgrep/structure.py
@@ -40,7 +41,9 @@ tests/test_http_ensure.py
 tests/test_index_reconstruct.py
 tests/test_index_scope.py
 tests/test_index_worker.py
+tests/test_mcp_error_log.py
 tests/test_mcp_structured.py
+tests/test_mcp_thread_safety.py
 tests/test_mcp_version.py
 tests/test_name_uniqueness.py
 tests/test_nudge_classify.py

symgrep_codesearch-0.7.2/tests/test_mcp_error_log.py

@@ -0,0 +1,56 @@
+"""Regression: MCP refusals and exceptions are durable in the configured rotating error log."""
+
+import logging
+import os
+import pathlib
+import sys
+import tempfile
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(HERE), "src"))
+sys.path.insert(0, HERE)
+from checklib import Checks                                                            # noqa: E402
+
+from symgrep import mcp_server                                                         # noqa: E402
+
+_t = Checks("test_mcp_error_log")
+check = _t.check
+
+temporary_directory = tempfile.TemporaryDirectory(prefix="symgrep-mcp-log-")
+configured_log = pathlib.Path(temporary_directory.name) / "request-errors.log"
+saved_log_path = os.environ.get("SYMGREP_LOG")
+os.environ["SYMGREP_LOG"] = str(configured_log)
+
+try:
+    returned_message = "semantic index is unavailable for this regression"
+    returned_payload = {"status": "unavailable", "reason": "no_index", "message": returned_message}
+    mcp_server._invoke_logged_mcp_tool(
+        "search", {"pattern": "find capability", "roots": [temporary_directory.name]},
+        lambda: __import__("json").dumps(returned_payload))
+
+    def raise_request_regression_error():
+        raise RuntimeError("request regression exploded")
+
+    try:
+        mcp_server._invoke_logged_mcp_tool(
+            "file_symbols", {"path": pathlib.Path(temporary_directory.name) / "broken.py"},
+            raise_request_regression_error)
+    except RuntimeError:
+        pass
+
+    for handler in logging.getLogger(mcp_server.MCP_REQUEST_LOGGER_NAME).handlers:
+        handler.flush()
+    logged = configured_log.read_text(encoding="utf-8")
+    check("returned MCP refusal is logged with tool, args, returned code, and exact message",
+          "tool=search" in logged and "pattern='find capability'" in logged
+          and "code=no_index" in logged and returned_message in logged, logged)
+    check("raised MCP exception is logged with its complete traceback",
+          "tool=file_symbols" in logged and "Traceback (most recent call last)" in logged
+          and "raise_request_regression_error" in logged and "request regression exploded" in logged, logged)
+finally:
+    if saved_log_path is None:
+        os.environ.pop("SYMGREP_LOG", None)
+    else:
+        os.environ["SYMGREP_LOG"] = saved_log_path
+
+_t.finish()

symgrep_codesearch-0.7.2/tests/test_mcp_thread_safety.py

@@ -0,0 +1,57 @@
+"""Regression: semantic daemon workers never share a thread-bound SQLite store."""
+
+import os
+import sys
+import tempfile
+import threading
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(os.path.dirname(HERE), "src"))
+sys.path.insert(0, HERE)
+from checklib import Checks                                                            # noqa: E402
+
+from symgrep import semantic                                                           # noqa: E402
+
+_t = Checks("test_mcp_thread_safety")
+check = _t.check
+
+try:
+    semantic._embedder()
+except semantic.Unavailable:
+    _t.skip("veccore/fastembed absent — threaded semantic-store regression not exercised here")
+else:
+    temporary_directory = tempfile.TemporaryDirectory(prefix="symgrep-thread-store-")
+    index_file = os.path.join(temporary_directory.name, "semantic.sqlite")
+    workers_ready = threading.Barrier(2)
+    worker_results = []
+    worker_failures = []
+    result_lock = threading.Lock()
+
+    def exercise_thread_owned_semantic_store():
+        try:
+            first_store, first_core = semantic._core_for(index_file)
+            second_store, second_core = semantic._core_for(index_file)
+            workers_ready.wait()
+            first_store.existing_ids(semantic.COLLECTION)
+            with result_lock:
+                worker_results.append((threading.get_ident(), first_store, first_core,
+                                       first_store is second_store and first_core is second_core))
+        except Exception as error:
+            with result_lock:
+                worker_failures.append(error)
+
+    worker_threads = [threading.Thread(target=exercise_thread_owned_semantic_store) for _ in range(2)]
+    for worker_thread in worker_threads:
+        worker_thread.start()
+    for worker_thread in worker_threads:
+        worker_thread.join()
+
+    check("two daemon-style worker threads can use the same semantic index without SQLite thread errors",
+          not worker_failures and len(worker_results) == 2,
+          "\n".join(f"{type(error).__name__}: {error}" for error in worker_failures))
+    check("each worker reuses its own store/core pair within that thread",
+          len(worker_results) == 2 and all(result[3] for result in worker_results), str(worker_results))
+    check("different worker threads receive different SQLite-backed stores for the same index path",
+          len(worker_results) == 2 and worker_results[0][1] is not worker_results[1][1], str(worker_results))
+
+_t.finish()