superlocalmemory 3.6.13 → 3.6.15

package/src/superlocalmemory/cli/main.py

@@ -24,6 +24,8 @@ _os.environ.setdefault('TORCH_DEVICE', 'cpu')
 import argparse
 import sys
 
+from superlocalmemory.core.config import CANONICAL_RECALL_LIMIT
+
 _HELP_EPILOG = """\
 operating modes:
   Mode A  Local Guardian — Zero cloud, zero LLM. All processing stays on
@@ -76,6 +78,17 @@ def main() -> None:
         handle_hook(sys.argv[2])
         return
 
+    # WP-07: lazy first-run init — runs after hook/mcp fast-paths so stdout
+    # is never polluted on those paths (CRIT-3, MCP JSON-RPC purity).
+    # Guarded: any failure must not crash the CLI (AC4).
+    _is_mcp_cmd = len(sys.argv) >= 2 and sys.argv[1] == "mcp"
+    if not _is_mcp_cmd:
+        try:
+            from superlocalmemory.cli._lazy_init import _ensure_initialized
+            _ensure_initialized()
+        except Exception:
+            pass
+
     from superlocalmemory.cli.json_output import _get_version
     _ver = _get_version()
 
@@ -101,8 +114,9 @@ def main() -> None:
                 from superlocalmemory.migrations.v3_4_25_to_v3_4_26 import (
                     migrate_if_safe as _migrate_if_safe,
                 )
-                _data = _P(_os.environ.get("SLM_DATA_DIR")
-                           or _P.home() / ".superlocalmemory")
+                # WP-07: route through slm_home() so all 3 env aliases are honoured.
+                from superlocalmemory.cli._lazy_init import slm_home as _slm_home
+                _data = _slm_home()
                 _res = _migrate_if_safe(_data)
                 if _res.get("status") == "deferred":
                     print(
@@ -140,6 +154,11 @@ def main() -> None:
         "--gate", action="store_true",
         help="Enable PreToolUse gate (experimental — blocks tools until session_init)",
     )
+    # WP-07: non-interactive auto setup (pip post-install, CI, scripts).
+    init_p.add_argument(
+        "--auto", action="store_true",
+        help="Non-interactive setup: mode A + hooks (no TTY required, for CI/scripts)",
+    )
 
     setup_p = sub.add_parser("setup", help="Interactive first-time setup wizard")
     setup_p.add_argument(
@@ -159,11 +178,32 @@ def main() -> None:
     )
 
     connect_p = sub.add_parser("connect", help="Auto-configure IDE integrations (17+ IDEs)")
-    connect_p.add_argument("ide", nargs="?", help="Specific IDE to configure")
+    connect_p.add_argument("ide", nargs="?", help="Specific IDE to configure (e.g. cursor, codex, continue)")
     connect_p.add_argument(
         "--list", action="store_true", help="List all supported IDEs",
     )
     connect_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
+    # WP-08 CRIT-1: declare missing flags so cmd_connect can read them without getattr fallback
+    connect_p.add_argument(
+        "--here", action="store_true", default=False,
+        help="Write config relative to current working directory (project scope)",
+    )
+    connect_p.add_argument(
+        "--cross-platform", action="store_true", dest="cross_platform", default=False,
+        help="Use LLD-05 cross-platform adapter orchestrator",
+    )
+    connect_p.add_argument(
+        "--disable", metavar="ADAPTER", default=None,
+        help="Disable a specific cross-platform adapter by name",
+    )
+    connect_p.add_argument(
+        "--profile", metavar="PROFILE", default=None,
+        help="Inject SLM_MCP_PROFILE env var into the MCP server block (WP-01)",
+    )
+    connect_p.add_argument(
+        "--dry-run", action="store_true", dest="dry_run", default=False,
+        help="Show what would be written without making changes",
+    )
 
     migrate_p = sub.add_parser("migrate", help="Migrate data from V2 to V3 schema")
     migrate_p.add_argument(
@@ -195,12 +235,24 @@ def main() -> None:
         "--sync", dest="sync_mode", action="store_true",
         help="Wait for completion (default: async background processing)",
     )
+    remember_p.add_argument(
+        "--scope", default=None, choices=("personal", "shared", "global"),
+        help="Memory scope: personal, shared, or global. Unset uses the "
+             "configured default_scope (personal). Shared memory is opt-in.",
+    )
+    remember_p.add_argument(
+        "--shared-with", default=None,
+        help="Comma-separated profile IDs for shared scope",
+    )
 
     # v3.6.12 (parity-3): `search` is an alias of `recall` so the CLI has the
     # same search verb the MCP exposes (handlers dict maps both to cmd_recall).
     recall_p = sub.add_parser("recall", aliases=["search"], help="Semantic search with 4-channel retrieval")
     recall_p.add_argument("query", help="Search query")
-    recall_p.add_argument("--limit", type=int, default=10, help="Max results (default 10)")
+    recall_p.add_argument(
+        "--limit", type=int, default=CANONICAL_RECALL_LIMIT,
+        help=f"Max results (default {CANONICAL_RECALL_LIMIT})",
+    )
     recall_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
     recall_p.add_argument(
         "--fast", action="store_true",
@@ -208,6 +260,26 @@ def main() -> None:
              "Other 4 channels (semantic, lexical, temporal, structural) still run. "
              "Use when you need recall before a tool call (e.g. before WebSearch).",
     )
+    # v3.6.15: shared memory is opt-in. Unset (None) → resolve the configured
+    # default (recall_include_global/shared, both False by default). Explicit
+    # flags override per-call. default=None on BOTH members of each pair so the
+    # store_false's implicit default=True can't sneak back in.
+    recall_p.add_argument(
+        "--include-global", dest="include_global", action="store_true", default=None,
+        help="Include global-scope facts in retrieval (opt-in; default off)",
+    )
+    recall_p.add_argument(
+        "--no-global", dest="include_global", action="store_false", default=None,
+        help="Exclude global-scope facts from retrieval",
+    )
+    recall_p.add_argument(
+        "--include-shared", dest="include_shared", action="store_true", default=None,
+        help="Include facts shared with this profile (opt-in; default off)",
+    )
+    recall_p.add_argument(
+        "--no-shared", dest="include_shared", action="store_false", default=None,
+        help="Exclude shared-scope facts from retrieval",
+    )
 
     forget_p = sub.add_parser("forget", help="Delete memories matching a query (fuzzy)")
     forget_p.add_argument("query", help="Query to match for deletion")
@@ -337,6 +409,22 @@ def main() -> None:
     )
     ctx_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
+    # #49: local session open/close (for hooks; no model roundtrip)
+    session_p = sub.add_parser(
+        "session", help="Open/close a session locally (for hooks; no model roundtrip)"
+    )
+    session_sub = session_p.add_subparsers(dest="session_command", title="session actions")
+    sopen_p = session_sub.add_parser("open", help="Warm session context")
+    sopen_p.add_argument("--project-path", default="", help="Project path to derive the warm query")
+    sopen_p.add_argument("--query", default="", help="Explicit warm query")
+    sopen_p.add_argument("--max-results", type=int, default=10, help="Max memories to warm (default 10)")
+    sclose_p = session_sub.add_parser(
+        "close", help="Close session, create temporal summaries"
+    )
+    sclose_p.add_argument(
+        "--session-id", default="", help="Session to close (default: most recent)"
+    )
+
     obs_p = sub.add_parser("observe", help="Auto-capture content (pipe or argument)")
     obs_p.add_argument("content", nargs="?", default="", help="Content to evaluate")
 

package/src/superlocalmemory/cli/setup_wizard.py

@@ -28,7 +28,17 @@ from pathlib import Path
 # Constants
 # ---------------------------------------------------------------------------
 
-_SLM_HOME = Path(os.environ.get("SL_MEMORY_PATH", Path.home() / ".superlocalmemory"))
+# WP-07: resolve via slm_home() so all 3 env aliases are honoured.
+# Fallback keeps stdlib-only path if the import fails during early bootstrap.
+def _resolve_slm_home() -> Path:
+    try:
+        from superlocalmemory.cli._lazy_init import slm_home
+        return slm_home()
+    except Exception:
+        return Path(os.environ.get("SL_MEMORY_PATH", "") or Path.home() / ".superlocalmemory")
+
+
+_SLM_HOME = _resolve_slm_home()
 _SETUP_MARKER = _SLM_HOME / ".setup-complete"
 _EMBED_MODEL = "nomic-ai/nomic-embed-text-v1.5"
 _RERANKER_MODEL = "cross-encoder/ms-marco-MiniLM-L-12-v2"
@@ -369,6 +379,33 @@ def run_wizard(auto: bool = False) -> None:
     mode_map = {"a": Mode.A, "b": Mode.B, "c": Mode.C}
     config = SLMConfig.for_mode(mode_map[choice])
 
+    # -- Multi-scope (shared memory) opt-in — v3.6.15 --
+    # OFF by default: your memories stay private to this profile (3.6.14 behaviour).
+    # Enabling only turns ON recall VISIBILITY of other profiles' shared/global facts;
+    # your own writes still default to 'personal' (mark a memory shared/global per call
+    # with --scope). Existing users can flip this later in the `scope` section of
+    # mode_a/b/c.json. See docs/shared-memory.md.
+    print()
+    print("  Shared memory lets other local profiles' 'shared'/'global' memories")
+    print("  appear in your recall. It is OFF by default — your memories stay private.")
+    if interactive:
+        sm_choice = _prompt(
+            "  See shared/global memories from other profiles by default? [y/N] (default: N): ",
+            "n",
+        ).lower()
+    else:
+        sm_choice = "n"
+    if sm_choice in ("y", "yes"):
+        from superlocalmemory.core.config import ScopeConfig
+        config.scope = ScopeConfig(
+            default_scope="personal",
+            recall_include_global=True,
+            recall_include_shared=True,
+        )
+        print("  ✓ Shared-memory recall ENABLED (your own writes still default to personal).")
+    else:
+        print("  ✓ Shared memory OFF (default) — enable later in mode_*.json if needed.")
+
     if choice == "b":
         print()
         if shutil.which("ollama"):
@@ -703,14 +740,18 @@ def check_first_use(command: str) -> None:
     if is_setup_complete():
         return
 
-    # Non-interactive: use defaults silently, don't block the command
+    # Non-interactive: use defaults silently, don't block the command.
+    # CRIT-1: only save config when it does NOT already exist — lazy-init may
+    # have already written a valid config.json; overwriting it here would clobber
+    # any lazy-init content (e.g. a pre-existing mode-A skeleton).
     if not is_interactive():
-        # Just create config with defaults and mark complete
         try:
-            from superlocalmemory.core.config import SLMConfig
+            from superlocalmemory.core.config import SLMConfig, DEFAULT_BASE_DIR
             from superlocalmemory.storage.models import Mode
-            config = SLMConfig.for_mode(Mode.A)
-            config.save(mode_change=True)
+            config_path = DEFAULT_BASE_DIR / "config.json"
+            if not config_path.exists():
+                cfg = SLMConfig.for_mode(Mode.A)
+                cfg.save(mode_change=True)
             _mark_complete()
         except Exception:
             pass

package/src/superlocalmemory/core/backend_orchestrator.py

@@ -342,15 +342,15 @@ class BackendOrchestrator:
                         count: int = 0, error: str = "") -> None:
         self._backend_cache[name] = status
         try:
-            self._db.conn.execute(
+            # #47 fix: DatabaseManager has no `.conn`; execute() commits itself.
+            self._db.execute(
                 "INSERT OR REPLACE INTO backend_status "
                 "(backend_name, status, record_count, error_message, last_sync_at) "
                 "VALUES (?, ?, ?, ?, datetime('now'))",
                 (name, status, count, error),
             )
-            self._db.conn.commit()
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("backend_status update failed for %s: %s", name, exc)
 
     # ------------------------------------------------------------------
     # Internal: Schema
@@ -361,10 +361,14 @@ class BackendOrchestrator:
             from superlocalmemory.storage.schema_v345 import (
                 apply_migration, schema_version_applied,
             )
-            if not schema_version_applied(self._db.conn):
-                result = apply_migration(self._db.conn)
-                if result.get("errors"):
-                    logger.warning("Schema v3.4.5 had errors: %s", result["errors"])
+            # #47 fix: use raw_connection() — DatabaseManager has no `.conn`,
+            # so the old code raised AttributeError that was silently swallowed,
+            # leaving the v3.4.5 migration (access_count_30d) permanently unapplied.
+            with self._db.raw_connection() as conn:
+                if not schema_version_applied(conn):
+                    result = apply_migration(conn)
+                    if result.get("errors"):
+                        logger.warning("Schema v3.4.5 had errors: %s", result["errors"])
         except ImportError:
             logger.debug("schema_v345 not found — skipping")
         except Exception as exc:

package/src/superlocalmemory/core/config.py

@@ -21,6 +21,16 @@ logger = logging.getLogger(__name__)
 from superlocalmemory.storage.models import Mode
 
 
+# ---------------------------------------------------------------------------
+# Canonical limits (WP-02 — single source of truth across all surfaces)
+# ---------------------------------------------------------------------------
+
+#: Default number of results returned by recall across MCP, CLI, daemon, and
+#: engine.  All surfaces bind their ``limit`` defaults to this constant so a
+#: single change is sufficient to keep the full stack in sync.
+CANONICAL_RECALL_LIMIT: int = 20
+
+
 # ---------------------------------------------------------------------------
 # Default Paths
 # ---------------------------------------------------------------------------
@@ -119,6 +129,79 @@ class ChannelWeights:
         }
 
 
+# ---------------------------------------------------------------------------
+# Scope Weights
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ScopeWeights:
+    """RRF fusion weights for multi-scope retrieval.
+
+    Personal scope has highest weight (most relevant to current profile).
+    Shared scope has medium weight (team/group memories).
+    Global scope has lowest weight (public/common knowledge).
+    """
+
+    personal: float = 1.0
+    shared: float = 0.7
+    global_: float = 0.5  # trailing underscore avoids Python keyword
+
+    def __post_init__(self) -> None:
+        for name in ("personal", "shared", "global_"):
+            val = getattr(self, name)
+            if val < 0:
+                raise ValueError(f"ScopeWeights values must be non-negative, got {name}={val}")
+
+    def as_dict(self) -> dict[str, float]:
+        return {"personal": self.personal, "shared": self.shared, "global": self.global_}
+
+
+# ---------------------------------------------------------------------------
+# Scope Config (multi-scope memory behaviour defaults)
+# ---------------------------------------------------------------------------
+
+_VALID_SCOPES = ("personal", "shared", "global")
+
+
+@dataclass
+class ScopeConfig:
+    """User-facing defaults for multi-scope (shared) memory.
+
+    SHARED MEMORY IS OPT-IN — NOT a default feature (v3.6.15 product decision).
+    The defaults below make a fresh / unconfigured install behave EXACTLY like
+    3.6.14: every write is ``personal`` and recall returns only this profile's
+    own facts. Another profile's ``global``/``shared`` facts never leak into
+    recall until the user explicitly turns sharing on.
+
+      - ``default_scope='personal'``      → writes stay private by default;
+      - ``recall_include_global=False``   → don't surface other profiles' global;
+      - ``recall_include_shared=False``   → don't surface facts shared *to* me.
+
+    Turning it on is a deliberate act, done either per-call (``--scope`` /
+    ``--include-global`` / MCP args) or persistently by editing config.json /
+    mode_a|b|c.json (the installer can also write the choice). The CLI/MCP
+    boundary passes ``None`` ("not specified") so the engine resolves these
+    config values as the effective default.
+    """
+
+    default_scope: str = "personal"         # scope assigned to new memories
+    recall_include_global: bool = False     # surface scope='global' facts in recall
+    recall_include_shared: bool = False     # surface scope='shared' facts in recall
+
+    def __post_init__(self) -> None:
+        if self.default_scope not in _VALID_SCOPES:
+            raise ValueError(
+                f"default_scope must be one of {_VALID_SCOPES}, got {self.default_scope!r}"
+            )
+
+    def as_dict(self) -> dict:
+        return {
+            "default_scope": self.default_scope,
+            "recall_include_global": self.recall_include_global,
+            "recall_include_shared": self.recall_include_shared,
+        }
+
+
 # ---------------------------------------------------------------------------
 # Encoding Config
 # ---------------------------------------------------------------------------
@@ -692,6 +775,8 @@ class SLMConfig:
     embedding: EmbeddingConfig = field(default_factory=EmbeddingConfig)
     llm: LLMConfig = field(default_factory=LLMConfig)
     channel_weights: ChannelWeights = field(default_factory=ChannelWeights)
+    scope_weights: ScopeWeights = field(default_factory=ScopeWeights)
+    scope: ScopeConfig = field(default_factory=ScopeConfig)
     encoding: EncodingConfig = field(default_factory=EncodingConfig)
     retrieval: RetrievalConfig = field(default_factory=RetrievalConfig)
     math: MathConfig = field(default_factory=MathConfig)
@@ -739,17 +824,32 @@ class SLMConfig:
     @classmethod
     def load(cls, config_path: Path | None = None) -> SLMConfig:
         """Load config from JSON file. Returns default Mode A if file doesn't exist."""
-        path = config_path or (DEFAULT_BASE_DIR / "config.json")
+        # WP-07: resolve base dir through slm_home() at call time so all 3 env
+        # aliases (SLM_DATA_DIR → SL_MEMORY_PATH → SLM_HOME) are honoured.
+        try:
+            from superlocalmemory.cli._lazy_init import slm_home as _slm_home
+            _runtime_base = _slm_home()
+        except Exception:
+            _runtime_base = DEFAULT_BASE_DIR
+        path = config_path or (_runtime_base / "config.json")
         if not path.exists():
             return cls.for_mode(Mode.A)
         import json
-        data = json.loads(path.read_text())
+        try:
+            data = json.loads(path.read_text())
+        except (json.JSONDecodeError, OSError) as exc:
+            # An already-corrupt/truncated config.json must NOT brick every `slm`
+            # call — degrade to the Mode-A default and warn rather than raise.
+            logger.warning(
+                "config.json unreadable/corrupt (%s) — using Mode A default", exc
+            )
+            return cls.for_mode(Mode.A)
         mode = Mode(data.get("mode", "a"))
         llm_data = data.get("llm", {})
         emb_data = data.get("embedding", {})
         # V3.5.9: read base_dir before constructing config so for_mode() builds
         # db_path from the user's directory, not DEFAULT_BASE_DIR.
-        raw_base_dir = Path(data.get("base_dir", str(DEFAULT_BASE_DIR)))
+        raw_base_dir = Path(data.get("base_dir", str(_runtime_base)))
         config = cls.for_mode(
             mode,
             llm_provider=llm_data.get("provider", ""),
@@ -835,6 +935,36 @@ class SLMConfig:
             prestage_max_response_bytes=int(inj.get("prestage_max_response_bytes", 64 * 1024)),
         )
 
+        # Multi-scope memory: scope weights
+        sw = data.get("scope_weights", {})
+        if sw:
+            # v3.6.15: a malformed value (e.g. negative weight) must NOT brick
+            # every `slm` command via an uncaught ValueError out of load().
+            # Fall back to defaults and warn — the config is recoverable.
+            try:
+                config.scope_weights = ScopeWeights(**{
+                    k: v for k, v in sw.items()
+                    if k in ScopeWeights.__dataclass_fields__
+                })
+            except (ValueError, TypeError) as exc:
+                logger.warning(
+                    "Ignoring invalid scope_weights in config (%s) — using defaults", exc
+                )
+
+        # Multi-scope memory: behaviour defaults (default scope + recall visibility)
+        sc = data.get("scope", {})
+        if sc:
+            # Same guard: a typo'd default_scope must not crash the whole CLI.
+            try:
+                config.scope = ScopeConfig(**{
+                    k: v for k, v in sc.items()
+                    if k in ScopeConfig.__dataclass_fields__
+                })
+            except (ValueError, TypeError) as exc:
+                logger.warning(
+                    "Ignoring invalid scope config (%s) — using shared-off defaults", exc
+                )
+
         return config
 
     def save(
@@ -927,12 +1057,27 @@ class SLMConfig:
             "prestage_max_response_bytes": self.injection.prestage_max_response_bytes,
         }
 
+        # Multi-scope memory: scope weights
+        data["scope_weights"] = {
+            "personal": self.scope_weights.personal,
+            "shared": self.scope_weights.shared,
+            "global_": self.scope_weights.global_,
+        }
+
+        # Multi-scope memory: behaviour defaults
+        data["scope"] = self.scope.as_dict()
+
         # Preserve existing V3.3 config sections that aren't in for_mode()
         for key in ("forgetting", "quantization", "sagq", "embedding_signature", "auto_invoke"):
             if key in existing:
                 data[key] = existing[key]
 
-        path.write_text(json.dumps(data, indent=2))
+        # Atomic write: a crash mid-write must NOT leave a truncated/corrupt
+        # config.json (which would make every subsequent `slm` call fail to load).
+        import os as _os
+        _tmp = path.with_suffix(path.suffix + ".tmp")
+        _tmp.write_text(json.dumps(data, indent=2))
+        _os.replace(_tmp, path)
 
     @staticmethod
     def provider_presets() -> dict[str, dict[str, str]]:
@@ -987,7 +1132,15 @@ class SLMConfig:
         embedding_dimension: int = 0,
     ) -> SLMConfig:
         """Create config with mode-appropriate defaults."""
-        _base = base_dir or DEFAULT_BASE_DIR
+        # WP-07: resolve base dir via slm_home() at call time when not explicit.
+        if base_dir is None:
+            try:
+                from superlocalmemory.cli._lazy_init import slm_home as _slm_home
+                _base = _slm_home()
+            except Exception:
+                _base = DEFAULT_BASE_DIR
+        else:
+            _base = base_dir
 
         if mode == Mode.A:
             # V3.4.24: If user chose "openai" provider, honour their custom
@@ -1130,7 +1283,15 @@ class SLMConfig:
 
         Returns ``\"b\"`` (the default) if the file doesn't exist.
         """
-        _base = base_dir or DEFAULT_BASE_DIR
+        # WP-07: resolve via slm_home() at call time when base_dir not explicit.
+        if base_dir is None:
+            try:
+                from superlocalmemory.cli._lazy_init import slm_home as _slm_home
+                _base = _slm_home()
+            except Exception:
+                _base = DEFAULT_BASE_DIR
+        else:
+            _base = base_dir
         _f = _base / CURRENT_MODE_FILE
         try:
             return _f.read_text(encoding="utf-8").strip().lower() or "b"
@@ -1140,7 +1301,15 @@ class SLMConfig:
     @staticmethod
     def write_current_mode(mode: str, base_dir: Path | None = None) -> None:
         """Write the current mode letter to ``current_mode``."""
-        _base = base_dir or DEFAULT_BASE_DIR
+        # WP-07: resolve via slm_home() at call time when base_dir not explicit.
+        if base_dir is None:
+            try:
+                from superlocalmemory.cli._lazy_init import slm_home as _slm_home
+                _base = _slm_home()
+            except Exception:
+                _base = DEFAULT_BASE_DIR
+        else:
+            _base = base_dir
         _base.mkdir(parents=True, exist_ok=True)
         (_base / CURRENT_MODE_FILE).write_text(
             mode.lower().strip(), encoding="utf-8",
@@ -1175,7 +1344,15 @@ class SLMConfig:
         import dataclasses
 
         from superlocalmemory.storage.models import Mode as _M
-        _base = base_dir or DEFAULT_BASE_DIR
+        # WP-07: resolve via slm_home() at call time when base_dir not explicit.
+        if base_dir is None:
+            try:
+                from superlocalmemory.cli._lazy_init import slm_home as _slm_home
+                _base = _slm_home()
+            except Exception:
+                _base = DEFAULT_BASE_DIR
+        else:
+            _base = base_dir
         _base.mkdir(parents=True, exist_ok=True)
 
         old_config = cls.load(_base / "config.json")
@@ -1242,7 +1419,15 @@ class SLMConfig:
         Called on daemon boot. Idempotent — if ``current_mode`` already
         exists, this is a no-op. Returns True if migration was performed.
         """
-        _base = base_dir or DEFAULT_BASE_DIR
+        # WP-07: resolve via slm_home() at call time when base_dir not explicit.
+        if base_dir is None:
+            try:
+                from superlocalmemory.cli._lazy_init import slm_home as _slm_home
+                _base = _slm_home()
+            except Exception:
+                _base = DEFAULT_BASE_DIR
+        else:
+            _base = base_dir
         _current = _base / CURRENT_MODE_FILE
         if _current.exists():
             return False  # already migrated

package/src/superlocalmemory/core/embeddings.py

@@ -601,8 +601,13 @@ class EmbeddingService:
     def _cloud_embed_batch(
         self, texts: list[str], *, max_retries: int = 3,
     ) -> list[list[float]]:
-        """Encode via Azure OpenAI embedding API with retry."""
-        import httpx
+        """Encode via Azure OpenAI embedding API with retry.
+
+        V3.6.14: Reuses self._get_http_client() (shared persistent connection)
+        instead of creating a fresh httpx.Client per call/retry.  resp.json()
+        is now called inside the try block while the response object is still
+        in scope, eliminating reliance on httpx body-buffering after close.
+        """
         url = (
             f"{self._config.api_endpoint.rstrip('/')}/openai/deployments/"
             f"{self._config.deployment_name}/embeddings"
@@ -613,12 +618,12 @@ class EmbeddingService:
             "api-key": self._config.api_key,
         }
         body = {"input": texts, "model": self._config.deployment_name}
+        client = self._get_http_client()
         last_error: Exception | None = None
         for attempt in range(max_retries):
             try:
-                with httpx.Client(timeout=httpx.Timeout(30.0)) as client:
-                    resp = client.post(url, headers=headers, json=body)
-                    resp.raise_for_status()
+                resp = client.post(url, headers=headers, json=body)
+                resp.raise_for_status()
                 data = resp.json()
                 results = []
                 for item in sorted(data["data"], key=lambda d: d["index"]):