feat(config): honor MEMPALACE_CONFIG_DIR, mirroring the palace-path override

`MempalaceConfig.__init__` took `config_dir` as a constructor argument documented "useful for
testing", with no environment or CLI lever — so the config directory hardwires to `~/.mempalace` for
every spawned process, while `palace_path` already honors `MEMPALACE_PALACE_PATH`.

A host that embeds mempalace as a sidecar spawns it as a process: it can pass env and argv, and
nothing else. The config file supplies `backend`, `collection_name`, `embedding_model`,
`write_routing`, `palace_path`, the milvus/qdrant/pgvector sets and ~20 more, so an embedding host
inherits every one of them from a user-level file it does not own. Countering key-by-key with env
vars does not scale to that surface; one symmetric lever closes it.

Resolution order matches `palace_path`: explicit argument > environment > default. `~` expands, a
blank value reads as unset, and an unset variable leaves `~/.mempalace` exactly where it stood — the
change adds a lever and moves no existing behaviour.

Six tests cover the promised order: env redirects both config-dir-derived files; a config.json under
the env-named directory actually feeds resolved values; an explicit argument outranks the env; unset
and blank both keep the home default; `~` expands.

Revert-verified: with the change reverted, 3 of the 6 fail — the guard bites rather than passing
vacuously.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Q4NJGuNb4oxv4C8RJH8TJx

Author: joshuafontany

mempalace/config.py

@@ -354,15 +354,28 @@ def __init__(self, config_dir=None, palace_path=None):
         """Initialize config.
 
         Args:
-            config_dir: Override config directory (useful for testing).
-                        Defaults to ~/.mempalace.
+            config_dir: Explicit config directory. Takes precedence over the
+                        ``MEMPALACE_CONFIG_DIR`` environment variable, which in
+                        turn takes precedence over the ~/.mempalace default.
             palace_path: Explicit palace data directory. This is primarily
                          used by CLI operations that received ``--palace``;
                          it takes precedence over environment and file config.
         """
-        self._config_dir = (
-            Path(config_dir) if config_dir else Path(os.path.expanduser("~/.mempalace"))
-        )
+        # Explicit arg > MEMPALACE_CONFIG_DIR > ~/.mempalace, mirroring how
+        # ``palace_path`` resolves. A host that embeds mempalace as a library
+        # needs to point a spawned process at its own config root: without an
+        # env lever the directory hardwires to ~/.mempalace, so every spawned
+        # process reads a user-level config it does not own. The config file
+        # supplies backend, collection_name, embedding_model, write_routing and
+        # ~20 more, so an embedding host inherits all of them by default.
+        env_config_dir = os.environ.get("MEMPALACE_CONFIG_DIR")
+        if config_dir:
+            resolved_config_dir = str(config_dir)
+        elif env_config_dir and env_config_dir.strip():
+            resolved_config_dir = env_config_dir.strip()
+        else:
+            resolved_config_dir = "~/.mempalace"
+        self._config_dir = Path(os.path.expanduser(resolved_config_dir))
         self._config_file = self._config_dir / "config.json"
         self._people_map_file = self._config_dir / "people_map.json"
         self._palace_path_override = (

tests/test_config_dir_env.py

@@ -0,0 +1,63 @@
+"""MEMPALACE_CONFIG_DIR — the config-directory lever, mirroring MEMPALACE_PALACE_PATH.
+
+A host that embeds mempalace as a sidecar spawns it as a process, so it can pass env and argv and
+nothing else. Without an env lever the config directory hardwires to ~/.mempalace and every spawned
+process reads a user-level config it does not own — carrying backend, collection_name,
+embedding_model, write_routing and ~20 more keys across a boundary the embedding was meant to hold.
+
+These cover the resolution order the docstring promises: explicit arg > env > default.
+"""
+
+import json
+import os
+
+from mempalace.config import MempalaceConfig
+
+
+def test_env_var_sets_the_config_dir(tmp_path, monkeypatch):
+    """MEMPALACE_CONFIG_DIR redirects both config-dir-derived files."""
+    monkeypatch.setenv("MEMPALACE_CONFIG_DIR", str(tmp_path))
+    cfg = MempalaceConfig()
+    assert cfg._config_dir == tmp_path
+    assert cfg._config_file == tmp_path / "config.json"
+    assert cfg._people_map_file == tmp_path / "people_map.json"
+
+
+def test_env_var_config_file_actually_loads(tmp_path, monkeypatch):
+    """A config.json under the env-named dir feeds the resolved values — the point of the lever."""
+    (tmp_path / "config.json").write_text(json.dumps({"collection_name": "sidecar_only"}))
+    monkeypatch.setenv("MEMPALACE_CONFIG_DIR", str(tmp_path))
+    cfg = MempalaceConfig()
+    assert cfg._file_config.get("collection_name") == "sidecar_only"
+
+
+def test_explicit_arg_outranks_the_env_var(tmp_path, monkeypatch):
+    """Explicit arg > env, matching how palace_path resolves an explicit --palace over its env."""
+    env_dir = tmp_path / "from_env"
+    arg_dir = tmp_path / "from_arg"
+    env_dir.mkdir()
+    arg_dir.mkdir()
+    monkeypatch.setenv("MEMPALACE_CONFIG_DIR", str(env_dir))
+    cfg = MempalaceConfig(config_dir=str(arg_dir))
+    assert cfg._config_dir == arg_dir
+
+
+def test_unset_env_keeps_the_home_default(monkeypatch):
+    """Absent the env var the directory stands where it always stood — behaviour-preserving."""
+    monkeypatch.delenv("MEMPALACE_CONFIG_DIR", raising=False)
+    cfg = MempalaceConfig()
+    assert cfg._config_dir == type(cfg._config_dir)(os.path.expanduser("~/.mempalace"))
+
+
+def test_blank_env_falls_through_to_the_default(monkeypatch):
+    """An exported-but-empty value reads as unset rather than as the current directory."""
+    monkeypatch.setenv("MEMPALACE_CONFIG_DIR", "   ")
+    cfg = MempalaceConfig()
+    assert cfg._config_dir == type(cfg._config_dir)(os.path.expanduser("~/.mempalace"))
+
+
+def test_env_var_expands_a_tilde(monkeypatch):
+    """`~` expands, so an operator may export a home-relative path."""
+    monkeypatch.setenv("MEMPALACE_CONFIG_DIR", "~/some-sidecar-root")
+    cfg = MempalaceConfig()
+    assert str(cfg._config_dir) == os.path.expanduser("~/some-sidecar-root")