memoryintelligence-mcp 0.2.2__tar.gz → 0.2.3__tar.gz

{memoryintelligence_mcp-0.2.2 → memoryintelligence_mcp-0.2.3}/CHANGELOG.md

@@ -3,16 +3,50 @@
 All notable changes to `memoryintelligence-mcp` are documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/); this project uses [Semantic Versioning](https://semver.org/).
 
-## [0.2.2] — 2026-07-18
-
-### Fixed
-- `mi_account` now works. It called the JWT-only `/v1/accounts/me` and always
-  returned 401 under the API-key auth the MCP server uses; repointed to the
-  API-key endpoint `GET /v1/account`.
-- Set `asyncio_mode = auto` so the bare-`async` tests run (CI was red).
-
-### Changed
-- Relicensed MIT → **Apache-2.0**.
+## [0.2.3] — 2026-07-22
+
+### Fixed — Claude Desktop actually launches: the sandbox P0 finally ships (#1135)
+The Desktop direct-interpreter wire (merged 2026-07-07) never reached PyPI — the
+published 0.2.2 was built from an earlier commit under the same version number,
+so `mi-mcp wire`/`setup` on the released package kept writing a Desktop entry
+pointing at `run-mi-mcp.sh`, which Claude Desktop's macOS sandbox refuses to
+exec. Result: the server never completes the MCP handshake, Desktop kills it at
+its 60s timeout ("Server disconnected"), and no tools register — while `doctor`
+reported green. This release cuts current `main`, which carries:
+
+- **`wire` emits `{command: <python>, args: ["-m", "mi_mcp"]}` for Desktop** —
+  a real Mach-O binary the sandbox allows; the key still never touches the
+  config (resolved in-process from the Keychain, time-boxed at 5s).
+- **`doctor` now FAILS when the Desktop entry points at a shell script**, with
+  the exact remediation printed — the escalated user's hours of debugging
+  become one red line.
+- **The launcher's Keychain read is time-boxed** (perl alarm, 5s) for the
+  surfaces that keep the wrapper (Code/Cursor): a Keychain ACL authorization
+  prompt (e.g. after a venv/binary change) can no longer hang the launch
+  until the host's timeout.
+- Config backup before overwrite (P1) + startup marker line (P2) from the
+  onboarding-report arc, also previously unreleased.
+- **License clarified: Apache-2.0.** Every published release (0.2.0–0.2.2) has
+  shipped under Apache-2.0; an in-repo MIT text was drift, never a decision.
+  This release restores the LICENSE file and metadata to Apache-2.0 so the
+  paperwork matches what has always been published — including its explicit
+  patent grant (LICENSE §3), which applies to this package as the licensed
+  Work. See the LICENSE for its exact scope and terms.
+
+**To pick this up:** `pip install -U memoryintelligence-mcp` (or `uv tool
+upgrade`), then **re-run `mi-mcp wire`**, then fully quit + reopen Claude
+Desktop. `mi-mcp doctor` must show `[✓] desktop entry sandbox-launchable`.
+
+## [0.2.2] — 2026-07-07
+
+### Fixed — `explain` now surfaces the score breakdown through `mi_ask` (MI#482)
+`mi_ask`'s `explain` argument was silently dropped: the MCP output shaper projected
+every hit down to `{umo_id, summary, source, score}` and discarded the per-signal
+`scores` breakdown unconditionally, so passing `explain: "human"` (or any level) had
+no observable effect and ranking couldn't be diagnosed (e.g. the entity-channel
+contribution). The shaper now **keeps the `scores` block** (semantic/keyword/entity/
+recency) on each hit whenever `explain` is anything other than `none`; the default
+lean shape is unchanged, so token cost is unaffected unless you ask for the breakdown.
 
 ## [0.2.1] — 2026-07-05
 

{memoryintelligence_mcp-0.2.2 → memoryintelligence_mcp-0.2.3}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: memoryintelligence-mcp
-Version: 0.2.2
+Version: 0.2.3
 Summary: MCP server for MemoryIntelligence — give Claude a memory you own, set up in one command
 Project-URL: Homepage, https://memoryintelligence.io
 Project-URL: Repository, https://github.com/somewhere11/memoryintelligence-mcp
 Project-URL: Issues, https://github.com/somewhere11/memoryintelligence-mcp/issues
 Project-URL: Changelog, https://github.com/somewhere11/memoryintelligence-mcp/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://memoryintelligence.io/docs/api-reference
-Author-email: MemoryIntelligence <sdk@memoryintelligence.io>
+Author-email: Somewhere <connect@somewheremedia.com>
 License-Expression: Apache-2.0
 License-File: LICENSE
 Keywords: ai,claude,llm,mcp,memory,memory-intelligence,model-context-protocol
@@ -115,8 +115,10 @@ and never leaves your machine except to authenticate.
 <details>
 <summary><b>Security</b> — key handling, capture consent, PII redaction, no open port</summary>
 
-- **No key in configs.** `setup`/`wire` write `env: {}`; a launcher resolves the key
-  from the Keychain (or a `chmod 600 ~/.memoryintelligence/.env` keyfile) **at launch**.
+- **No key in configs.** The key is resolved from the Keychain (or a `chmod 600
+  ~/.memoryintelligence/.env` keyfile) **at launch** — in-process for Claude Desktop
+  (direct `python -m mi_mcp` entry; its sandbox blocks shell scripts), via the
+  launcher script for Code/Cursor.
   A leaked or committed config exposes nothing.
   > **Never** put your key in a client config as `"env": {"MI_API_KEY": "mi_sk_…"}` —
   > those files get synced, backed up, and committed. Let `setup` handle it.
@@ -146,7 +148,7 @@ Found a vulnerability? [SECURITY.md](SECURITY.md) — report privately to connec
 | `MI_API_KEY` | — | Resolved by the launcher from Keychain / keyfile — don't set inline in configs |
 | `MI_BASE_URL` | `https://api.memoryintelligence.io` | API base URL |
 | `MI_MCP_FULL` | _(off)_ | `1` exposes all 10 tools; otherwise the 3 core |
-| `MI_VAULT` | `~/MemoryIntelligence` | Local `.umo` vault location |
+| `MI_VAULT` | `~/Somewhere` (set by `wire`) | Local `.umo` vault — `wire`/`setup` point it at `~/Somewhere` so it's shared with the MemorySpace Desktop app. Unwired fallback is `~/MemoryIntelligence`; an explicit value here always wins. |
 | `MI_DEFAULT_SCOPE` · `MI_DEFAULT_RETENTION` · `MI_DEFAULT_PII_HANDLING` | `user` · `meaning_only` · `extract_and_redact` | Governance defaults |
 
 **Names you'll see** — they collapse to one long form and one short form:
@@ -163,8 +165,8 @@ Found a vulnerability? [SECURITY.md](SECURITY.md) — report privately to connec
 
 | Path | What |
 |---|---|
-| `~/MemoryIntelligence/` | your `.umo` vault (override with `MI_VAULT`) |
-| `~/.memoryintelligence/mcp/run-mi-mcp.sh` | the launcher each host spawns |
+| `~/Somewhere/` | your `.umo` vault — shared with the MemorySpace Desktop app (`wire` sets `MI_VAULT` here; override with `MI_VAULT`) |
+| `~/.memoryintelligence/mcp/run-mi-mcp.sh` | the launcher Code/Cursor spawn (Claude Desktop runs `python -m mi_mcp` directly — its sandbox blocks scripts) |
 | `~/.memoryintelligence/mcp/opt-in-paths` | per-directory capture allowlist |
 | `~/.memoryintelligence/.env` | `chmod 600` keyfile (Keychain fallback) |
 </details>

{memoryintelligence_mcp-0.2.2 → memoryintelligence_mcp-0.2.3}/README.md

@@ -76,8 +76,10 @@ and never leaves your machine except to authenticate.
 <details>
 <summary><b>Security</b> — key handling, capture consent, PII redaction, no open port</summary>
 
-- **No key in configs.** `setup`/`wire` write `env: {}`; a launcher resolves the key
-  from the Keychain (or a `chmod 600 ~/.memoryintelligence/.env` keyfile) **at launch**.
+- **No key in configs.** The key is resolved from the Keychain (or a `chmod 600
+  ~/.memoryintelligence/.env` keyfile) **at launch** — in-process for Claude Desktop
+  (direct `python -m mi_mcp` entry; its sandbox blocks shell scripts), via the
+  launcher script for Code/Cursor.
   A leaked or committed config exposes nothing.
   > **Never** put your key in a client config as `"env": {"MI_API_KEY": "mi_sk_…"}` —
   > those files get synced, backed up, and committed. Let `setup` handle it.
@@ -107,7 +109,7 @@ Found a vulnerability? [SECURITY.md](SECURITY.md) — report privately to connec
 | `MI_API_KEY` | — | Resolved by the launcher from Keychain / keyfile — don't set inline in configs |
 | `MI_BASE_URL` | `https://api.memoryintelligence.io` | API base URL |
 | `MI_MCP_FULL` | _(off)_ | `1` exposes all 10 tools; otherwise the 3 core |
-| `MI_VAULT` | `~/MemoryIntelligence` | Local `.umo` vault location |
+| `MI_VAULT` | `~/Somewhere` (set by `wire`) | Local `.umo` vault — `wire`/`setup` point it at `~/Somewhere` so it's shared with the MemorySpace Desktop app. Unwired fallback is `~/MemoryIntelligence`; an explicit value here always wins. |
 | `MI_DEFAULT_SCOPE` · `MI_DEFAULT_RETENTION` · `MI_DEFAULT_PII_HANDLING` | `user` · `meaning_only` · `extract_and_redact` | Governance defaults |
 
 **Names you'll see** — they collapse to one long form and one short form:
@@ -124,8 +126,8 @@ Found a vulnerability? [SECURITY.md](SECURITY.md) — report privately to connec
 
 | Path | What |
 |---|---|
-| `~/MemoryIntelligence/` | your `.umo` vault (override with `MI_VAULT`) |
-| `~/.memoryintelligence/mcp/run-mi-mcp.sh` | the launcher each host spawns |
+| `~/Somewhere/` | your `.umo` vault — shared with the MemorySpace Desktop app (`wire` sets `MI_VAULT` here; override with `MI_VAULT`) |
+| `~/.memoryintelligence/mcp/run-mi-mcp.sh` | the launcher Code/Cursor spawn (Claude Desktop runs `python -m mi_mcp` directly — its sandbox blocks scripts) |
 | `~/.memoryintelligence/mcp/opt-in-paths` | per-directory capture allowlist |
 | `~/.memoryintelligence/.env` | `chmod 600` keyfile (Keychain fallback) |
 </details>

{memoryintelligence_mcp-0.2.2 → memoryintelligence_mcp-0.2.3}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memoryintelligence-mcp"
-version = "0.2.2"
+version = "0.2.3"
 description = "MCP server for MemoryIntelligence — give Claude a memory you own, set up in one command"
 readme = "README.md"
 license = "Apache-2.0"
 requires-python = ">=3.10"
-authors = [{ name = "MemoryIntelligence", email = "sdk@memoryintelligence.io" }]
+authors = [{ name = "Somewhere", email = "connect@somewheremedia.com" }]
 keywords = ["mcp", "model-context-protocol", "memory-intelligence", "claude", "llm", "memory", "ai"]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -70,10 +70,3 @@ include = ["src/mi_mcp", "README.md", "LICENSE", "CHANGELOG.md", "CONTRIBUTING.m
 [tool.ruff]
 target-version = "py310"
 line-length = 100
-
-[tool.pytest.ini_options]
-# Bare `async def test_*` functions (e.g. tests/test_localreads.py) are collected
-# as asyncio tests without needing a per-test @pytest.mark.asyncio marker. Without
-# this, pytest-asyncio's default (strict) mode skips/errors them with
-# "async def functions are not natively supported". Explicit markers still work.
-asyncio_mode = "auto"

{memoryintelligence_mcp-0.2.2 → memoryintelligence_mcp-0.2.3}/src/mi_mcp/__init__.py

@@ -1,3 +1,3 @@
 """MI MCP Server — MemoryIntelligence tools for Claude."""
 
-__version__ = "0.2.1"
+__version__ = "0.2.3"

{memoryintelligence_mcp-0.2.2 → memoryintelligence_mcp-0.2.3}/src/mi_mcp/__main__.py

@@ -89,6 +89,11 @@ def main():
         stream=sys.stderr,
     )
 
+    # Startup marker (Adrian's onboarding report, P2): emit ONE line the instant we reach
+    # main(), so the host log shows the process actually started. Without it, a hang in
+    # config/import reads as a silent "connected → 60s timeout" with no failure point.
+    logger.info("mi-mcp %s starting…", __version__)
+
     # Load config from env (CLI args override env vars)
     from .config import MIConfig
 

{memoryintelligence_mcp-0.2.2 → memoryintelligence_mcp-0.2.3}/src/mi_mcp/cli.py

@@ -59,8 +59,14 @@ WRAPPER_TEMPLATE = r"""#!/usr/bin/env bash
 set -euo pipefail
 
 # 1. inherited env  →  2. macOS Keychain  →  3. keyfile (new then legacy)  →  fail
+# The Keychain read is TIME-BOXED (perl alarm — present on stock macOS; the
+# Python side already bounds its own read at 5s): if the item's ACL no longer
+# trusts the caller (e.g. after a binary/venv change), `security` blocks on an
+# authorization dialog a headless MCP host can never answer, and an unbounded
+# read here hangs the launch until the host's 60s timeout kills it (#1135).
+# On timeout we fall through to the keyfile instead of hanging.
 if [[ -z "${MI_API_KEY:-}" ]]; then
-  MI_API_KEY="$(security find-generic-password -a "${MI_KEYCHAIN_ACCOUNT:-$USER}" -s "MI_API_KEY" -w 2>/dev/null || true)"
+  MI_API_KEY="$(perl -e 'alarm shift; exec @ARGV' 5 security find-generic-password -a "${MI_KEYCHAIN_ACCOUNT:-$USER}" -s "MI_API_KEY" -w 2>/dev/null || true)"
 fi
 for __mi_envf in "$HOME/.memoryintelligence/.env" "$HOME/.mi-env"; do
   if [[ -z "${MI_API_KEY:-}" && -f "$__mi_envf" ]]; then
@@ -302,21 +308,35 @@ def do_wire(home: Path, surfaces: list[str], dry_run: bool,
         migrated = [k for k in LEGACY_SERVER_KEYS if servers.pop(k, None) is not None]
         if migrated:
             print(f"  {s:8} migrated id {', '.join(migrated)} → {SERVER_KEY}")
-        # Build this surface's entry. env carries at most the one non-secret
-        # opt-in flag, desktop-only. capture_anywhere is tri-state: True enables,
+        # Build this surface's entry. capture_anywhere is tri-state: True enables,
         # False disables, None preserves the current setting (so a plain re-wire
         # never silently flips a capture choice the user made).
         env: dict[str, str] = {}
         if s == "desktop":
             prior = servers.get(SERVER_KEY)
             prior_env = prior.get("env") if isinstance(prior, dict) else None
+            # D7: point the local .umo vault at the MemorySpace Desktop vault (~/Somewhere) so
+            # both surfaces resolve ONE vault. The shell wrapper used to set this at launch;
+            # the direct-interpreter entry carries it here. A deliberate prior override wins.
+            prior_vault = prior_env.get("MI_VAULT") if isinstance(prior_env, dict) else None
+            env["MI_VAULT"] = prior_vault or str(home / "Somewhere")
             already_on = isinstance(prior_env, dict) and prior_env.get("MI_MCP_OPT_IN_ALL") == "1"
             enabled = already_on if capture_anywhere is None else capture_anywhere
             if enabled:
                 # Tag Desktop captures with a distinct provenance source so they're
                 # identifiable/reviewable apart from project (folder-scoped) captures.
-                env = {"MI_MCP_OPT_IN_ALL": "1", "MI_DEFAULT_SOURCE": "claude-desktop"}
-        entry = {"command": str(wrapper), "args": [], "env": env}
+                env["MI_MCP_OPT_IN_ALL"] = "1"
+                env["MI_DEFAULT_SOURCE"] = "claude-desktop"
+        # P0 FIX (Adrian's onboarding report): Claude Desktop's macOS sandbox throws
+        # "Operation not permitted" on any shell script it didn't ship — so pointing the
+        # config at run-mi-mcp.sh breaks EVERY Mac Desktop user. Spawn the Python interpreter
+        # directly (a real Mach-O binary the sandbox allows). config.resolve_api_key() finds
+        # the key in the Keychain at startup, so it still never lives in this file. Other
+        # surfaces (Code/Cursor) aren't sandboxed the same way and keep the self-healing wrapper.
+        if s == "desktop":
+            entry = {"command": sys.executable, "args": ["-m", "mi_mcp"], "env": env}
+        else:
+            entry = {"command": str(wrapper), "args": [], "env": env}
         # VS Code / Copilot require an explicit transport type on each entry;
         # Claude surfaces don't use one.
         surface_entry = {"type": "stdio", **entry} if s == "vscode" else entry
@@ -324,16 +344,23 @@ def do_wire(home: Path, surfaces: list[str], dry_run: bool,
         action = "update" if SERVER_KEY in servers else "add"
         nochange = servers.get(SERVER_KEY) == surface_entry
         servers[SERVER_KEY] = surface_entry
-        note = ("  ·  capture-anywhere ON" if env else "  ·  capture-anywhere off") if s == "desktop" else ""
+        opt_in_on = env.get("MI_MCP_OPT_IN_ALL") == "1"
+        note = ("  ·  capture-anywhere ON" if opt_in_on else "  ·  capture-anywhere off") if s == "desktop" else ""
         print(f"  {s:8} {cfg_path}  [{action}{' / no-change' if nochange else ''}]{note}")
-        if env and s == "desktop":
+        if opt_in_on and s == "desktop":
             print("           ⚠ ANY Claude Desktop chat under this macOS login can now write to your")
             print("             MI account (captures are PII-redacted + tagged source=claude-desktop).")
             print("             Don't enable on a shared login. Turn off: --no-capture-anywhere")
         if not dry_run:
+            # P1 (Adrian's report): an upgrade silently overwrote a working config. Before
+            # any changing write, snapshot the prior file so a bad wire is always recoverable.
+            if not nochange and cfg_path.exists():
+                backup = cfg_path.with_name(cfg_path.name + ".mi-bak")
+                _atomic_write(backup, cfg_path.read_text())
+                print(f"           backed up prior config → {backup.name}")
             _atomic_write(cfg_path, json.dumps(cfg, indent=2) + "\n")
 
-    print("\n  ✓ no API key written to any config — the wrapper resolves it at launch")
+    print("\n  ✓ no API key written to any config — resolved from the Keychain at launch")
 
 
 def cmd_wire(argv: list[str]) -> int:
@@ -444,6 +471,37 @@ def cmd_doctor(argv: list[str]) -> int:
             detail = f"legacy id {', '.join(legacy)} present — run `mi-mcp wire` to migrate"
         check(f"{s} wired", wired, detail, critical=False)
 
+        # #1135 — the escalated-user failure this check exists to catch in ONE
+        # line: Claude Desktop's macOS sandbox refuses to exec shell scripts it
+        # didn't ship ("Operation not permitted"), so a Desktop entry pointing
+        # at run-mi-mcp.sh (written by wire <= the published 0.2.2) starts,
+        # never completes the MCP handshake, and Desktop kills it at its 60s
+        # timeout — "Server disconnected", no tools registered, doctor green.
+        # CRITICAL: a wired-but-unlaunchable Desktop is worse than unwired.
+        if s == "desktop" and wired:
+            entry = servers.get(SERVER_KEY) or {}
+            cmd = str(entry.get("command", ""))
+            # An absent/empty command is just as unlaunchable as a blocked
+            # script — "" must not slip through as green.
+            launchable = bool(cmd) and not cmd.endswith(".sh")
+            # The manual-edit remediation must carry the env block: wire sets
+            # MI_VAULT on the Desktop entry (#653 vault unification), and a
+            # hand-edit that drops it launches fine but reads the wrong vault —
+            # which THIS doctor's vault check would not catch, since that check
+            # inspects the wrapper's baked default, not the Desktop entry env.
+            check(
+                "desktop entry sandbox-launchable", launchable,
+                "" if launchable else (
+                    (f"points at {cmd} — the Desktop sandbox blocks shell scripts "
+                     if cmd else "entry has no command — the server cannot launch ")
+                    + f"(60s timeout / 'Server disconnected'). Fix: re-run `mi-mcp wire` "
+                    f"on >=0.2.3 (recommended — preserves env). Manual edit must keep "
+                    f"the env block: {{\"command\": \"{sys.executable}\", "
+                    f"\"args\": [\"-m\", \"mi_mcp\"], "
+                    f"\"env\": {{\"MI_VAULT\": \"{home / 'Somewhere'}\"}}}}"
+                ),
+            )
+
     print(f"\n  {'healthy ✓' if ok else 'issues found ✗'}")
     return 0 if ok else 1
 

{memoryintelligence_mcp-0.2.2 → memoryintelligence_mcp-0.2.3}/src/mi_mcp/client.py

@@ -342,10 +342,5 @@ class MIClient:
         return resp.json()
 
     async def account_info(self) -> dict[str, Any]:
-        """GET /v1/account — API key status, owner, and plan limits.
-
-        Authenticated with the API key itself. (The older /v1/accounts/me
-        requires a portal JWT, which an MCP client never holds — it only has
-        an API key — so calling it always 401'd.)
-        """
-        return await self._request("GET", "/v1/account", idempotent=True)
+        """GET /v1/accounts/me — get current account info and key status."""
+        return await self._request("GET", "/v1/accounts/me", idempotent=True)

{memoryintelligence_mcp-0.2.2 → memoryintelligence_mcp-0.2.3}/src/mi_mcp/config.py

@@ -7,12 +7,41 @@ from __future__ import annotations
 
 import fnmatch
 import os
+import subprocess
 from dataclasses import dataclass
 from pathlib import Path
 
 from . import paths
 
 
+def resolve_api_key() -> str:
+    """Resolve MI_API_KEY the same chain the launcher wrapper used to: inherited env →
+    macOS Keychain (service ``MI_API_KEY``) → keyfile (~/.memoryintelligence/.env, then
+    legacy ~/.mi-env). Resolving IN-PROCESS lets ``wire`` emit a direct ``python -m mi_mcp``
+    command (which macOS Claude Desktop's sandbox allows) instead of a shell script (which it
+    blocks) — with the key still never living in any MCP config file."""
+    key = os.environ.get("MI_API_KEY", "").strip()
+    if key:
+        return key
+    account = os.environ.get("MI_KEYCHAIN_ACCOUNT") or os.environ.get("USER") or ""
+    try:
+        r = subprocess.run(
+            ["security", "find-generic-password", "-a", account, "-s", "MI_API_KEY", "-w"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if r.returncode == 0 and r.stdout.strip():
+            return r.stdout.strip()
+    except (OSError, subprocess.SubprocessError):
+        pass  # `security` unavailable (non-macOS) or failed — fall through to the keyfile
+    envf = paths.resolve_keyfile()
+    if envf is not None:
+        for line in envf.read_text().splitlines():
+            line = line.strip()
+            if line.startswith("MI_API_KEY="):
+                return line.split("=", 1)[1].strip().strip('"').strip("'")
+    return ""
+
+
 @dataclass(frozen=True)
 class MIConfig:
     """Immutable configuration resolved from environment."""
@@ -59,13 +88,13 @@ class MIConfig:
             MI_MCP_LOCAL       — "1" routes mi_ask/mi_list to the local vault index when
                                  one is built (network-free); falls back to cloud on error
         """
-        api_key = os.environ.get("MI_API_KEY", "")
+        api_key = resolve_api_key()
         if not api_key:
             raise ValueError(
                 "MI_API_KEY is required.\n"
-                "Recommended: run `mi-mcp wire` — it resolves the key from your macOS Keychain\n"
-                "at launch, so the key never lives in any config file. Or export MI_API_KEY in\n"
-                "your shell. Never paste the key into an MCP client config file.\n"
+                "Recommended: run `mi-mcp setup` — it stores the key in your macOS Keychain, which\n"
+                "the server resolves at launch, so the key never lives in any config file. Or export\n"
+                "MI_API_KEY in your shell. Never paste the key into an MCP client config file.\n"
                 "Get your key at https://memoryintelligence.io/portal"
             )
 

{memoryintelligence_mcp-0.2.2 → memoryintelligence_mcp-0.2.3}/src/mi_mcp/keys.py

@@ -1,6 +1,6 @@
 """Owner key handling for the local vault — key model **A1** (locked 2026-06-05).
 
-The owner holds an **X25519 private key**; MemoryIntelligence only ever sees the
+The owner holds an **X25519 private key**; Memory Intelligence only ever sees the
 **public key** (sent on capture). MI wraps each per-UMO content key for that
 public key, so **MI cannot decrypt the owner's ``.umo`` files**.
 

{memoryintelligence_mcp-0.2.2 → memoryintelligence_mcp-0.2.3}/src/mi_mcp/paths.py

@@ -1,4 +1,4 @@
-"""Filesystem layout for MemoryIntelligence — one on-brand namespace.
+"""Filesystem layout for Memory Intelligence — one on-brand namespace.
 
 Single visible/hidden split, no lookalike names:
 

{memoryintelligence_mcp-0.2.2 → memoryintelligence_mcp-0.2.3}/src/mi_mcp/server.py

@@ -112,25 +112,39 @@ def _error_text(e: MIAPIError) -> list[TextContent]:
 # UNCHANGED when it isn't the expected success shape, so errors/odd payloads
 # still surface.
 
-def _shape_ask(result: Any) -> Any:
-    """Project a /v1/memories/query response to ``[{umo_id, summary, source, score}]``."""
+def _shape_ask(result: Any, explain: Any = "none") -> Any:
+    """Project a /v1/memories/query response to a compact per-hit shape.
+
+    Default shape is ``{umo_id, summary, source, score}``. When the caller asked
+    for ``explain`` (any level other than "none"), each hit ALSO carries the
+    per-signal ``scores`` breakdown (semantic/keyword/entity/recency) the API
+    returns — #482: this shaper used to drop ``scores`` unconditionally, so the
+    ``explain`` argument had no observable effect through the MCP tool and
+    ranking couldn't be diagnosed (e.g. the entity-channel contribution).
+    """
     if not isinstance(result, dict):
         return result
     data = result.get("data")
     if not isinstance(data, dict) or "results" not in data:
         return result
+    want_scores = str(explain).strip().lower() not in ("", "none", "false", "0")
     shaped = []
     for r in data.get("results") or []:
         if not isinstance(r, dict):
             continue
-        shaped.append({
+        hit = {
             "umo_id":  r.get("umo_id"),
             # content_text duplicates summary; fall back to it only if summary is empty.
             "summary": r.get("summary") or r.get("content_text"),
             # #538: the API omits source when it's the default — absent means "api".
             "source":  r.get("source") or "api",
             "score":   r.get("score"),
-        })
+        }
+        # #482: preserve the score decomposition when explain was requested and
+        # the API actually returned it (it omits `scores` when explain=none).
+        if want_scores and r.get("scores") is not None:
+            hit["scores"] = r.get("scores")
+        shaped.append(hit)
     return shaped
 
 
@@ -279,8 +293,11 @@ def create_server(config: MIConfig | None = None) -> Server:
                 description=(
                     "Capture content into MemoryIntelligence. Transforms raw text into "
                     "a Unified Memory Object (UMO) — extracting entities, topics, sentiment, "
-                    "and generating embeddings. The raw content is discarded by default "
-                    "(meaning-only retention). Returns the created UMO with its ID."
+                    "and generating embeddings. Long captures are chunked into per-claim "
+                    "child UMOs that persist each claim's verbatim text; short captures "
+                    "persist their normalized text with a generated summary. The default "
+                    "meaning_only retention discards the raw pre-normalization buffer, "
+                    "not the readable content. Returns the created UMO with its ID."
                 ),
                 inputSchema={
                     "type": "object",
@@ -712,7 +729,8 @@ def create_server(config: MIConfig | None = None) -> Server:
 
                 case "mi_ask":
                     result = await _route_ask(config, client, arguments)
-                    return [TextContent(type="text", text=_fmt_untrusted(_shape_ask(result)))]
+                    return [TextContent(type="text", text=_fmt_untrusted(
+                        _shape_ask(result, explain=arguments.get("explain", "none"))))]
 
                 case "mi_list":
                     result = await _route_list(config, client, arguments)