basic-memory 0.23.2.dev3__tar.gz → 0.23.3.dev2__tar.gz

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Official Basic Memory plugins from the canonical basic-memory repository",
-    "version": "0.23.1"
+    "version": "0.23.2"
   },
   "plugins": [
     {
       "name": "basic-memory",
       "source": "./plugins/claude-code",
       "description": "The bridge between Claude's working memory and Basic Memory's durable knowledge graph \u2014 session briefings, pre-compaction checkpoints, and capture reflexes",
-      "version": "0.23.1",
+      "version": "0.23.2",
       "author": {
         "name": "Basic Machines"
       },

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: basic-memory
-Version: 0.23.2.dev3
+Version: 0.23.3.dev2
 Summary: Local-first knowledge management combining Zettelkasten with knowledge graphs
 Project-URL: Homepage, https://github.com/basicmachines-co/basic-memory
 Project-URL: Repository, https://github.com/basicmachines-co/basic-memory
@@ -29,7 +29,6 @@ Requires-Dist: mcp<3,>=2
 Requires-Dist: mdformat-frontmatter>=2.0.8
 Requires-Dist: mdformat-gfm>=0.3.7
 Requires-Dist: mdformat>=0.7.22
-Requires-Dist: nest-asyncio>=1.6.0
 Requires-Dist: openai>=1.100.2
 Requires-Dist: pillow>=11.1.0
 Requires-Dist: psutil>=5.9.0

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/integrations/hermes/__init__.py

@@ -39,7 +39,7 @@ from typing import Any, Callable
 from agent.memory_provider import MemoryProvider
 from tools.registry import tool_error
 
-__version__ = "0.23.1"
+__version__ = "0.23.2"
 
 logger = logging.getLogger("hermes.memory.basic-memory")
 

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/integrations/hermes/plugin.yaml

@@ -1,5 +1,5 @@
 name: basic-memory
-version: 0.23.1
+version: 0.23.2
 description: "Basic Memory — persistent knowledge graph backed by the basic-memory MCP server"
 manifest_version: 2
 api_version: 1

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/integrations/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basicmemory/openclaw-basic-memory",
-  "version": "0.23.1",
+  "version": "0.23.2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/plugins/claude-code/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Official plugins from Basic Machines for knowledge management and AI-assisted development",
-    "version": "0.23.1"
+    "version": "0.23.2"
   },
   "plugins": [
     {
       "name": "basic-memory",
       "source": "./",
       "description": "The bridge between Claude's working memory and Basic Memory's durable knowledge graph \u2014 session briefings, pre-compaction checkpoints, and capture reflexes",
-      "version": "0.23.1",
+      "version": "0.23.2",
       "author": {
         "name": "Basic Machines"
       },

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/plugins/claude-code/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "basic-memory",
   "description": "The bridge between Claude's working memory and Basic Memory's durable knowledge graph \u2014 session briefings, pre-compaction checkpoints, and capture reflexes",
-  "version": "0.23.1",
+  "version": "0.23.2",
   "author": {
     "name": "Basic Machines"
   },

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/plugins/claude-code/hooks/pre_compact.py

@@ -2,7 +2,7 @@
 # /// script
 # requires-python = ">=3.12"
 # dependencies = [
-#     "basic-memory>=0.23.1",
+#     "basic-memory>=0.23.2",
 #     # Direct pre-release pin so old uv resolves basic-memory (which
 #     # requires this exact beta transitively) without enabling
 #     # pre-releases for basic-memory itself. Keep in lockstep with

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/plugins/claude-code/hooks/session_start.py

@@ -2,7 +2,7 @@
 # /// script
 # requires-python = ">=3.12"
 # dependencies = [
-#     "basic-memory>=0.23.1",
+#     "basic-memory>=0.23.2",
 #     # Direct pre-release pin so old uv resolves basic-memory (which
 #     # requires this exact beta transitively) without enabling
 #     # pre-releases for basic-memory itself. Keep in lockstep with

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/plugins/codex/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "codex",
-  "version": "0.23.1",
+  "version": "0.23.2",
   "description": "A Codex-native bridge to Basic Memory for durable engineering context, decisions, and resumable checkpoints.",
   "author": {
     "name": "Basic Machines",

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/plugins/codex/hooks/pre_compact.py

@@ -2,7 +2,7 @@
 # /// script
 # requires-python = ">=3.12"
 # dependencies = [
-#     "basic-memory @ git+https://github.com/basicmachines-co/basic-memory@v0.23.1",
+#     "basic-memory @ git+https://github.com/basicmachines-co/basic-memory@v0.23.2",
 #     # Direct pre-release pin so old uv resolves basic-memory (which
 #     # requires this exact beta transitively) without enabling
 #     # pre-releases broadly. Keep in lockstep with core pyproject.

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/plugins/codex/hooks/session_start.py

@@ -2,7 +2,7 @@
 # /// script
 # requires-python = ">=3.12"
 # dependencies = [
-#     "basic-memory @ git+https://github.com/basicmachines-co/basic-memory@v0.23.1",
+#     "basic-memory @ git+https://github.com/basicmachines-co/basic-memory@v0.23.2",
 #     # Direct pre-release pin so old uv resolves basic-memory (which
 #     # requires this exact beta transitively) without enabling
 #     # pre-releases broadly. Keep in lockstep with core pyproject.

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/pyproject.toml

@@ -35,7 +35,6 @@ dependencies = [
     "pytest-aio>=1.9.0",
     "aiofiles>=24.1.0",
     "asyncpg>=0.30.0",
-    "nest-asyncio>=1.6.0", # For Alembic migrations with Postgres
     "pytest-asyncio>=1.2.0",
     "psycopg==3.3.1",
     "mdformat>=0.7.22",

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/basicmachines-co/basic-memory.git",
     "source": "github"
   },
-  "version": "0.23.1",
+  "version": "0.23.2",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "basic-memory",
-      "version": "0.23.1",
+      "version": "0.23.2",
       "runtimeHint": "uvx",
       "runtimeArguments": [
         {

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/src/basic_memory/__init__.py

@@ -1,7 +1,7 @@
 """basic-memory - Local-first knowledge management combining Zettelkasten with knowledge graphs"""
 
 # Package version - updated by release automation
-__version__ = "0.23.1"
+__version__ = "0.23.2"
 
 # API version for FastAPI - independent of package version
 __api_version__ = "v2"

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/src/basic_memory/alembic/env.py

@@ -2,34 +2,24 @@
 
 import asyncio
 import os
-import sys
 from contextlib import suppress
 from logging.config import fileConfig
 
-from loguru import logger
 from sqlalchemy import engine_from_config, pool
 from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
 
 from alembic import context
 
 from basic_memory.config import ConfigManager
-from basic_memory.migration_loop import running_on_uvloop
 
-# Allow nested event loops (needed for pytest-asyncio and other async contexts).
-# nest_asyncio cannot patch a uvloop loop or Python 3.14+; in those cases we skip
-# it and rely on the thread-based fallback in run_migrations_online() instead
-# (see basic_memory.migration_loop for why uvloop must be detected up front).
-if sys.version_info < (3, 14) and not running_on_uvloop():
-    try:
-        import nest_asyncio
-
-        nest_asyncio.apply()
-    except (ImportError, ValueError) as exc:
-        # Trigger: nest_asyncio is absent (ImportError) or refuses to patch the
-        # running loop (ValueError).
-        # Outcome: log at DEBUG (observable, not noisy) and fall through to the
-        # thread-based migration fallback.
-        logger.debug(f"nest_asyncio not applied ({exc!r}); using thread-based migration fallback")
+# Constraint: never apply nest_asyncio here. It replaces asyncio.run and
+# run_until_complete process-wide, and its run_until_complete returns the moment
+# the root task finishes without running that task's done-callbacks. anyio stops
+# its worker threads from exactly such a callback, so any request that touched
+# the thread pool left a non-daemon worker parked forever and one-shot CLI
+# commands hung at interpreter exit on Python < 3.14 (#1333, #1345). Callers
+# already inside a running loop (pytest-asyncio, the API lifespan) take the
+# thread fallback in run_migrations_online(), the only path 3.14 ever used.
 
 # Trigger: only set test env when actually running under pytest
 # Why: alembic/env.py is imported during normal operations (MCP server startup, migrations)

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/src/basic_memory/deps/config.py

@@ -12,12 +12,16 @@ from fastapi import Depends, Request
 from basic_memory.config import BasicMemoryConfig
 
 
-def get_app_config(request: Request) -> BasicMemoryConfig:
+async def get_app_config(request: Request) -> BasicMemoryConfig:
     """Resolve the application configuration from the composition root.
 
     API requests read the container the lifespan stored on ``app.state``.
     Requests served without a lifespan (the CLI/MCP local ASGI flow) fall back
     to the API composition root, which creates a container on demand.
+
+    Declared ``async`` although it never awaits: FastAPI runs *sync* dependencies
+    on anyio's worker-thread pool, and an attribute read is not worth a thread
+    hop per request — nor the non-daemon worker it leaves parked (#1345).
     """
     container = getattr(request.app.state, "container", None)
     if container is not None:

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/src/basic_memory/deps/read_cache.py

@@ -12,8 +12,12 @@ from basic_memory.read_cache.policy import (
 )
 
 
-def get_read_cache(request: Request) -> ReadCache | None:
-    """Return the optional host-injected cache backend."""
+async def get_read_cache(request: Request) -> ReadCache | None:
+    """Return the optional host-injected cache backend.
+
+    ``async`` for the same reason as ``get_app_config``: a sync dependency would
+    hop to anyio's worker pool just to read an attribute (#1345).
+    """
     try:
         container = request.app.state.container
     except AttributeError:

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/src/basic_memory/markdown/plugins.py

@@ -5,6 +5,7 @@ from typing import List, Any, Dict
 
 from basic_memory.utils import normalize_project_reference
 from markdown_it import MarkdownIt
+from markdown_it.rules_inline.backticks import backtick
 from markdown_it.token import Token
 
 # Transcript timecodes like [00:00:11] or [1:02:03.500] share the bracket shape of
@@ -127,6 +128,84 @@ def parse_observation(token: Token) -> Dict[str, Any]:
 
 
 # Relation handling functions
+def _relation_content(token: Token) -> str:
+    """Return the source content of an inline token."""
+    return token.tag or token.content
+
+
+_CODE_SPANS_KEY = "basic_memory_code_spans"
+_CODE_SPAN_PARSER = MarkdownIt()
+
+
+def _record_inline_code_span(state: Any, silent: bool) -> bool:
+    """Delegate to MarkdownIt and retain exact source spans for code tokens."""
+    start = state.pos
+    token_count = len(state.tokens)
+    matched = backtick(state, silent)
+    if matched and not silent and len(state.tokens) > token_count:
+        if state.tokens[-1].type == "code_inline":
+            state.env[_CODE_SPANS_KEY].append((start, state.pos))
+    return matched
+
+
+_CODE_SPAN_PARSER.inline.ruler.at("backticks", _record_inline_code_span)
+
+
+def _inline_code_spans(content: str) -> list[tuple[int, int]]:
+    """Return source ranges that MarkdownIt classifies as inline code.
+
+    This delegates delimiter and escape handling to the same MarkdownIt inline
+    rule used by the document parser instead of duplicating CommonMark's
+    backtick scanner. It also preserves MarkdownIt's linear-time cache for
+    unmatched delimiter runs.
+    """
+    if "`" not in content:
+        return []
+
+    spans: list[tuple[int, int]] = []
+    _CODE_SPAN_PARSER.inline.parse(content, _CODE_SPAN_PARSER, {_CODE_SPANS_KEY: spans}, [])
+    return spans
+
+
+def _mask_wikilinks_in_inline_code(content: str, code_spans: list[tuple[int, int]]) -> str:
+    """Mask only brackets in code spans, retaining all non-link source text."""
+    if not code_spans:
+        return content
+
+    masked = list(content)
+    for start, end in code_spans:
+        for position in range(start, end):
+            if masked[position] in "[]":
+                masked[position] = " "
+
+    return "".join(masked)
+
+
+def _remove_links_to_directive_outside_inline_code(
+    content: str, code_spans: list[tuple[int, int]]
+) -> tuple[str, bool]:
+    """Remove a terminal directive only when MarkdownIt parsed it as non-code."""
+    directive_content = list(content)
+    for start, end in code_spans:
+        directive_content[start:end] = " " * (end - start)
+
+    match = _LINKS_TO_DIRECTIVE.search("".join(directive_content))
+    if not match:
+        return content, False
+    return content[: match.start()].rstrip(), True
+
+
+def _relation_parsing_content(token: Token) -> tuple[str, str, list[tuple[int, int]]]:
+    """Build source-preserving relation input from MarkdownIt's code spans."""
+    source_content = _relation_content(token)
+    code_spans = _inline_code_spans(source_content)
+    return (
+        source_content,
+        _mask_wikilinks_in_inline_code(source_content, code_spans),
+        code_spans,
+    )
+
+
 def parse_relation_type(content: str) -> str | None:
     """Return the explicit relation label before the first wikilink, if any."""
     before_link = content.partition("[[")[0].strip()
@@ -154,15 +233,17 @@ def is_explicit_relation(token: Token) -> bool:
     if token.type != "inline":  # pragma: no cover
         return False
 
-    # Use token.tag which contains the actual content for test tokens, fallback to content
-    content = (token.tag or token.content).strip()
+    _, content, _ = _relation_parsing_content(token)
     if "[[" not in content or "]]" not in content:
         return False
     return _parse_explicit_relation(content) is not None
 
 
-def _parse_explicit_relation(content: str) -> Dict[str, Any] | None:
+def _parse_explicit_relation(
+    content: str, source_content: str | None = None
+) -> Dict[str, Any] | None:
     """Parse ``type [[target]] (context)``, rejecting lines with a prose tail."""
+    source_content = source_content or content
     rel_type = parse_relation_type(content)
     if rel_type is None:
         return None
@@ -172,7 +253,7 @@ def _parse_explicit_relation(content: str) -> Dict[str, Any] | None:
     if start == -1 or end == -1:
         return None
 
-    target = normalize_project_reference(content[start + 2 : end].strip())
+    target = normalize_project_reference(source_content[start + 2 : end].strip())
     if not target:
         return None
 
@@ -189,7 +270,8 @@ def _parse_explicit_relation(content: str) -> Dict[str, Any] | None:
     if after:
         if not _is_single_parenthesized(after):
             return None
-        context = after[1:-1].strip() or None
+        source_after = source_content[end + 2 :].strip()
+        context = source_after[1:-1].strip() or None
 
     return {"type": rel_type, "target": target, "context": context}
 
@@ -217,13 +299,23 @@ def _is_single_parenthesized(text: str) -> bool:
 
 def parse_relation(token: Token) -> Dict[str, Any] | None:
     """Extract relation parts from token."""
-    # Use token.tag which contains the actual content for test tokens, fallback to content
-    content = (token.tag or token.content).strip()
-    return _parse_explicit_relation(content)
+    source_content, content, _ = _relation_parsing_content(token)
+    return _parse_explicit_relation(content, source_content)
+
 
+def _is_escaped(content: str, position: int) -> bool:
+    """Whether the character at ``position`` is escaped by an odd slash run."""
+    slash_count = 0
+    position -= 1
+    while position >= 0 and content[position] == "\\":
+        slash_count += 1
+        position -= 1
+    return slash_count % 2 == 1
 
-def parse_inline_relations(content: str) -> List[Dict[str, Any]]:
-    """Find wiki-style links in regular content."""
+
+def parse_inline_relations(content: str, source_content: str | None = None) -> List[Dict[str, Any]]:
+    """Find wiki-style links, extracting targets from the original source."""
+    source_content = content if source_content is None else source_content
     relations = []
     start = 0
 
@@ -232,6 +324,9 @@ def parse_inline_relations(content: str) -> List[Dict[str, Any]]:
         start = content.find("[[", start)
         if start == -1:  # pragma: no cover
             break
+        if _is_escaped(content, start):
+            start += 2
+            continue
 
         # Find matching ]]
         depth = 1
@@ -239,10 +334,10 @@ def parse_inline_relations(content: str) -> List[Dict[str, Any]]:
         end = -1
 
         while pos < len(content):
-            if content[pos : pos + 2] == "[[":
+            if content[pos : pos + 2] == "[[" and not _is_escaped(content, pos):
                 depth += 1
                 pos += 2
-            elif content[pos : pos + 2] == "]]":
+            elif content[pos : pos + 2] == "]]" and not _is_escaped(content, pos):
                 depth -= 1
                 if depth == 0:
                     end = pos
@@ -255,7 +350,7 @@ def parse_inline_relations(content: str) -> List[Dict[str, Any]]:
             # No matching ]] found
             break
 
-        target = normalize_project_reference(content[start + 2 : end].strip())
+        target = normalize_project_reference(source_content[start + 2 : end].strip())
         if target:
             relations.append({"type": "links_to", "target": target, "context": None})
 
@@ -336,21 +431,27 @@ def relation_plugin(md: MarkdownIt) -> None:
 
             # Only process inline tokens
             if token.type == "inline":
-                content = token.tag or token.content
-                content_without_directive, has_directive = remove_links_to_directive(content)
+                source_content = _relation_content(token)
+                if "[[" not in source_content:
+                    continue
+
+                code_spans = _inline_code_spans(source_content)
+                relation_content = _mask_wikilinks_in_inline_code(source_content, code_spans)
+                content_without_directive, has_directive = (
+                    _remove_links_to_directive_outside_inline_code(relation_content, code_spans)
+                )
 
                 # Check for explicit relations in list items
-                if in_list_item and not has_directive and is_explicit_relation(token):
-                    rel = parse_relation(token)
+                if in_list_item and not has_directive:
+                    rel = _parse_explicit_relation(relation_content, source_content)
                     if rel:
                         token.meta["relations"] = [rel]
+                        continue
 
                 # Always check for inline links in any text
-                else:
-                    if "[[" in content:
-                        rels = parse_inline_relations(content_without_directive)
-                        if rels:
-                            token.meta["relations"] = token.meta.get("relations", []) + rels
+                rels = parse_inline_relations(content_without_directive, source_content)
+                if rels:
+                    token.meta["relations"] = token.meta.get("relations", []) + rels
 
     # Add the rule after inline processing
     md.core.ruler.after("inline", "relations", relation_rule)

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/tests/cli/test_cli_exit.py

@@ -4,10 +4,49 @@ These tests verify that CLI commands exit cleanly without hanging,
 which was a bug fixed in the database initialization refactor.
 """
 
+import os
 import subprocess
 from pathlib import Path
 
 
+def test_bm_schema_validate_exits_cleanly(tmp_path):
+    """Regression test (#1333, #1345): a command that drives the API in-process must exit.
+
+    ``bm schema validate`` runs migrations (importing alembic/env.py) and then
+    serves one request over the local ASGI transport. On Python < 3.14 the
+    interpreter used to block at shutdown on a non-daemon anyio worker thread
+    that nest_asyncio's patched event loop never stopped.
+    """
+    home = tmp_path / "home"
+    home.mkdir()
+    # A pristine profile: the developer's or CI's Basic Memory settings must not
+    # leak in, and the promo/analytics path stays out of the picture.
+    env = {
+        key: value
+        for key, value in os.environ.items()
+        if not key.startswith("BASIC_MEMORY_") and key != "PYTEST_CURRENT_TEST"
+    }
+    env.update(
+        HOME=str(home),
+        USERPROFILE=str(home),
+        BASIC_MEMORY_HOME=str(home / "basic-memory"),
+        BASIC_MEMORY_CONFIG_DIR=str(home / ".basic-memory"),
+        BASIC_MEMORY_NO_PROMOS="1",
+    )
+    result = subprocess.run(
+        ["uv", "run", "bm", "schema", "validate", "--json", "--local"],
+        capture_output=True,
+        text=True,
+        env=env,
+        # Guards against a hang, not a performance budget: migrations plus one
+        # in-process request take a few seconds on a loaded CI runner.
+        timeout=90,
+        cwd=Path(__file__).parent.parent.parent,
+    )
+    assert result.returncode == 0, result.stderr
+    assert result.stdout.lstrip().startswith("{"), result.stdout
+
+
 def test_bm_version_exits_cleanly():
     """Test that 'bm --version' exits cleanly within timeout."""
     # Use uv run to ensure correct environment

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/tests/markdown/test_relation_edge_cases.py

@@ -104,6 +104,70 @@ def test_inline_relations():
     assert len(token.meta["relations"]) == 3
 
 
+def test_inline_code_wikilinks_do_not_create_relations():
+    """CommonMark code spans quote wikilinks instead of linking notes (#1332)."""
+    code = "`"
+    cases = [
+        (
+            f"The template is {code}[[Inline Target]]{code}; prose [[Real Target]].",
+            ["Real Target"],
+        ),
+        (
+            f"{code}{code}literal {code} and [[Double Backtick Target]]{code}{code}",
+            [],
+        ),
+    ]
+
+    for source, expected_targets in cases:
+        parsed = parse(source)
+        assert [relation.target for relation in parsed.relations] == expected_targets
+
+
+def test_inline_code_mask_keeps_source_outside_code_spans():
+    """Masking code must not normalize escapes or discard relation context (#1332)."""
+    escaped = parse(r"\[[Literal]]")
+    assert escaped.relations == []
+
+    escaped_backticks = parse(r"\`see [[Target]]\`")
+    assert [relation.target for relation in escaped_backticks.relations] == ["Target"]
+
+    md = MarkdownIt().use(relation_plugin)
+    tokens = md.parse("- implemented_by [[Parser]] (`parse()`)")
+    token = next(t for t in tokens if t.type == "inline")
+    assert parse_relation(token) == {
+        "type": "implemented_by",
+        "target": "Parser",
+        "context": "`parse()`",
+    }
+
+    tokens = md.parse("- `example` implemented_by [[Parser]]")
+    token = next(t for t in tokens if t.type == "inline")
+    assert parse_relation(token) is None
+    assert token.meta["relations"] == [{"type": "links_to", "target": "Parser", "context": None}]
+
+    tokens = md.parse("- calls [[Parser]] `parse()`")
+    token = next(t for t in tokens if t.type == "inline")
+    assert parse_relation(token) is None
+    assert token.meta["relations"] == [{"type": "links_to", "target": "Parser", "context": None}]
+
+    literal_directive = parse("`#bm:links_to` [[Target]]")
+    assert [relation.target for relation in literal_directive.relations] == ["Target"]
+
+    for source, target in [
+        ("[[API `[v2]`]]", "API `[v2]`"),
+        ("[[Outer `[[literal]]` Target]]", "Outer `[[literal]]` Target"),
+    ]:
+        parsed = parse(source)
+        assert [relation.target for relation in parsed.relations] == [target]
+
+
+def test_many_unmatched_backtick_runs_keep_a_real_wikilink():
+    """MarkdownIt's cached scanner avoids quadratic work on unmatched runs (#1332)."""
+    source = " ".join("`" * width for width in range(1, 801)) + " [[Target]]"
+    parsed = parse(source)
+    assert [relation.target for relation in parsed.relations] == ["Target"]
+
+
 def test_prose_tail_falls_back_to_inline_link():
     """A sentence containing a wikilink must not mint a typed relation (#1260).
 

{basic_memory-0.23.2.dev3 → basic_memory-0.23.3.dev2}/tests/test_alembic_env.py

@@ -1,5 +1,6 @@
 """Regression tests for Alembic env async migration helpers."""
 
+import asyncio
 import importlib.util
 import uuid
 from contextlib import nullcontext
@@ -61,6 +62,19 @@ def load_alembic_env_module(monkeypatch, tmp_path):
     return module
 
 
+def test_env_import_leaves_asyncio_unpatched(monkeypatch, tmp_path):
+    """env.py must not apply nest_asyncio (#1333, #1345).
+
+    nest_asyncio swaps asyncio.run/run_until_complete process-wide and its loop
+    skips the root task's done-callbacks — the hook anyio uses to stop its worker
+    threads — so a CLI process that ran migrations hung at interpreter exit.
+    """
+    load_alembic_env_module(monkeypatch, tmp_path)
+
+    assert not getattr(asyncio, "_nest_patched", False)
+    assert asyncio.run.__module__ == "asyncio.runners"
+
+
 def test_asyncio_run_failure_closes_migration_coroutine(monkeypatch, tmp_path):
     """The running-loop fallback should not leak an un-awaited coroutine."""
     env_module = load_alembic_env_module(monkeypatch, tmp_path)