feat(/mine): translate client-side paths via PALACE_DAEMON_PATH_MAP

The daemon's /mine endpoint requires a directory that exists on the
daemon's filesystem. Hooks running on a client machine speak in their
own namespace (e.g. /home/<user>/.claude/projects/...), but a remote
daemon may see the same files at a different mount (e.g. via
Syncthing replication into /mnt/raid/...). Without translation the
hook's POST /mine fails with 400 "Directory does not exist" and
transcript ingest silently goes nowhere.

Add an opt-in PALACE_DAEMON_PATH_MAP env var and apply translation in
/mine before path validation. Format is comma-separated
client_prefix=daemon_prefix entries; first matching prefix wins,
non-matching paths pass through unchanged so existing direct
daemon-side absolute paths still work.

Example deploy on disks::

    PALACE_DAEMON_PATH_MAP="/home/jp/.claude/=/mnt/raid/claude-config/,/home/jp/Projects/=/mnt/raid/projects/"

Companion to memorypalace fix/restore-transcript-ingest-via-daemon —
that PR un-skips the three hook mining paths so they POST to /mine;
this PR makes /mine accept the client-side paths those POSTs send.

Tests: new tests/test_path_translation.py with 10 stdlib-unittest
cases covering parse_path_map (empty, single, multi, malformed,
whitespace, env-var fallback) and _translate_client_path (passthrough,
prefix match, non-match passthrough, multi-rule first-match-wins).
Run via:

    python -m unittest tests.test_path_translation -v

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jphein

main.py

@@ -176,6 +176,54 @@ def _check_auth(x_api_key: str | None):
         raise HTTPException(status_code=401, detail="Invalid API key")
 
 
+def _parse_path_map(raw: str | None = None) -> list[tuple[str, str]]:
+    """Parse PALACE_DAEMON_PATH_MAP into ordered (client_prefix, daemon_prefix) pairs.
+
+    Format: comma-separated ``client_prefix=daemon_prefix`` entries. Whitespace
+    around each token is stripped. Empty entries and entries missing ``=`` are
+    skipped silently. Order is preserved so the operator can put more-specific
+    prefixes first.
+
+    Example::
+
+        PALACE_DAEMON_PATH_MAP="/home/jp/.claude/=/mnt/raid/claude-config/,/home/jp/Projects/=/mnt/raid/projects/"
+    """
+    if raw is None:
+        raw = os.environ.get("PALACE_DAEMON_PATH_MAP", "")
+    raw = (raw or "").strip()
+    if not raw:
+        return []
+    pairs: list[tuple[str, str]] = []
+    for entry in raw.split(","):
+        entry = entry.strip()
+        if not entry or "=" not in entry:
+            continue
+        client_prefix, daemon_prefix = entry.split("=", 1)
+        client_prefix = client_prefix.strip()
+        daemon_prefix = daemon_prefix.strip()
+        if client_prefix and daemon_prefix:
+            pairs.append((client_prefix, daemon_prefix))
+    return pairs
+
+
+def _translate_client_path(path: str) -> str:
+    """Translate a client-side absolute path to a daemon-side path.
+
+    Hooks running on a client machine (e.g. katana) speak in their own
+    filesystem namespace (``/home/jp/.claude/...``); the daemon may see the
+    same files at a different mount (``/mnt/raid/claude-config/...`` via
+    Syncthing). ``PALACE_DAEMON_PATH_MAP`` lets the operator declare those
+    rewrites without coupling client code to deployment specifics.
+
+    The first matching prefix wins; non-matching paths pass through
+    unchanged so daemon-side absolute paths still work.
+    """
+    for client_prefix, daemon_prefix in _parse_path_map():
+        if path.startswith(client_prefix):
+            return daemon_prefix + path[len(client_prefix):]
+    return path
+
+
 def _sem_for(request_dict: dict) -> asyncio.Semaphore:
     method = request_dict.get("method", "")
     if method == "ping":
@@ -1014,6 +1062,10 @@ async def mine(request: Request, x_api_key: str | None = Header(default=None)):
     if not directory:
         raise HTTPException(status_code=400, detail="'dir' is required")
 
+    # Hook clients send paths in their own filesystem namespace. Translate
+    # to the daemon's view via PALACE_DAEMON_PATH_MAP before validation.
+    directory = _translate_client_path(directory)
+
     dir_path = Path(directory)
     if not dir_path.is_absolute() or ".." in dir_path.parts:
         raise HTTPException(status_code=400, detail="'dir' must be an absolute path with no traversal")

tests/__init__.py

@@ -0,0 +1,111 @@
+"""Unit tests for PALACE_DAEMON_PATH_MAP parsing + translation.
+
+Run with::
+
+    cd /path/to/palace-daemon
+    python -m unittest tests.test_path_translation -v
+
+These tests are pure-function and need no live daemon, palace, or
+network. They exist because the path-translation logic is the only
+glue between the hook's client-side path namespace and the daemon's
+filesystem view; getting it wrong silently swallows transcript ingest.
+"""
+import os
+import sys
+import unittest
+from unittest.mock import patch
+
+# Ensure project root is on sys.path so ``import main`` resolves to the
+# daemon's main.py regardless of where the test runner is invoked from.
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_ROOT = os.path.dirname(_HERE)
+if _ROOT not in sys.path:
+    sys.path.insert(0, _ROOT)
+
+import main  # noqa: E402
+
+
+class TestParsePathMap(unittest.TestCase):
+    def test_empty_returns_empty(self):
+        self.assertEqual(main._parse_path_map(""), [])
+        self.assertEqual(main._parse_path_map(None), [])
+        self.assertEqual(main._parse_path_map("   "), [])
+
+    def test_single_pair(self):
+        out = main._parse_path_map("/home/u/.claude/=/mnt/raid/claude-config/")
+        self.assertEqual(out, [("/home/u/.claude/", "/mnt/raid/claude-config/")])
+
+    def test_multiple_pairs_preserve_order(self):
+        raw = "/home/u/.claude/=/mnt/raid/cc/,/home/u/Projects/=/mnt/raid/projects/"
+        out = main._parse_path_map(raw)
+        self.assertEqual(
+            out,
+            [
+                ("/home/u/.claude/", "/mnt/raid/cc/"),
+                ("/home/u/Projects/", "/mnt/raid/projects/"),
+            ],
+        )
+
+    def test_skips_malformed_entries(self):
+        # Missing '=' and empty entries are skipped, valid ones survive.
+        raw = "noequals,,/a/=/b/, =/x/, /c/= "
+        out = main._parse_path_map(raw)
+        self.assertEqual(out, [("/a/", "/b/")])
+
+    def test_strips_whitespace_around_tokens(self):
+        out = main._parse_path_map("  /a/  =  /b/  ")
+        self.assertEqual(out, [("/a/", "/b/")])
+
+    def test_reads_env_var_when_no_arg(self):
+        with patch.dict(
+            os.environ, {"PALACE_DAEMON_PATH_MAP": "/x/=/y/"}, clear=False
+        ):
+            out = main._parse_path_map()
+        self.assertEqual(out, [("/x/", "/y/")])
+
+
+class TestTranslateClientPath(unittest.TestCase):
+    def test_passthrough_when_no_map(self):
+        with patch.dict(os.environ, {}, clear=True):
+            self.assertEqual(
+                main._translate_client_path("/home/u/.claude/projects/-x"),
+                "/home/u/.claude/projects/-x",
+            )
+
+    def test_first_matching_prefix_wins(self):
+        env = {"PALACE_DAEMON_PATH_MAP": "/home/u/.claude/=/mnt/raid/cc/"}
+        with patch.dict(os.environ, env, clear=True):
+            self.assertEqual(
+                main._translate_client_path("/home/u/.claude/projects/-x"),
+                "/mnt/raid/cc/projects/-x",
+            )
+
+    def test_non_matching_path_passes_through(self):
+        env = {"PALACE_DAEMON_PATH_MAP": "/home/u/.claude/=/mnt/raid/cc/"}
+        with patch.dict(os.environ, env, clear=True):
+            self.assertEqual(
+                main._translate_client_path("/var/log/syslog"),
+                "/var/log/syslog",
+            )
+
+    def test_multiple_rules_first_match_wins(self):
+        # Order matters: list more specific rules first if needed.
+        env = {
+            "PALACE_DAEMON_PATH_MAP": (
+                "/home/u/Projects/memorypalace/=/mnt/raid/mempalace/,"
+                "/home/u/Projects/=/mnt/raid/projects/"
+            )
+        }
+        with patch.dict(os.environ, env, clear=True):
+            self.assertEqual(
+                main._translate_client_path("/home/u/Projects/memorypalace/foo"),
+                "/mnt/raid/mempalace/foo",
+            )
+            self.assertEqual(
+                main._translate_client_path("/home/u/Projects/realmwatch/foo"),
+                "/mnt/raid/projects/realmwatch/foo",
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()