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

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

@@ -3,6 +3,51 @@
 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.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
 
 ### Fixed — one shared vault with the MemorySpace Desktop (MI#653)

memoryintelligence_mcp-0.2.3/LICENSE

@@ -0,0 +1,204 @@
+Copyright 2026 Somewhere Media, LLC
+
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memoryintelligence-mcp
-Version: 0.2.1
+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
@@ -8,7 +8,7 @@ Project-URL: Issues, https://github.com/somewhere11/memoryintelligence-mcp/issue
 Project-URL: Changelog, https://github.com/somewhere11/memoryintelligence-mcp/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://memoryintelligence.io/docs/api-reference
 Author-email: Somewhere <connect@somewheremedia.com>
-License-Expression: MIT
+License-Expression: Apache-2.0
 License-File: LICENSE
 Keywords: ai,claude,llm,mcp,memory,memory-intelligence,model-context-protocol
 Classifier: Development Status :: 4 - Beta
@@ -41,7 +41,7 @@ Description-Content-Type: text/markdown
 
 [![PyPI](https://img.shields.io/pypi/v/memoryintelligence-mcp.svg)](https://pypi.org/project/memoryintelligence-mcp/)
 [![Python](https://img.shields.io/pypi/pyversions/memoryintelligence-mcp.svg)](https://pypi.org/project/memoryintelligence-mcp/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
 [![MCP](https://img.shields.io/badge/MCP-server-blue.svg)](https://modelcontextprotocol.io)
 
 > ## Stop paying AI to reread the same context.
@@ -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>
@@ -234,4 +236,4 @@ Contributions welcome — [CONTRIBUTING.md](CONTRIBUTING.md).
 [What is MCP](https://modelcontextprotocol.io) ·
 [Changelog](CHANGELOG.md)
 
-MIT © Somewhere. See [LICENSE](LICENSE).
+Apache-2.0 © Somewhere Media, LLC. See [LICENSE](LICENSE).

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

@@ -2,7 +2,7 @@
 
 [![PyPI](https://img.shields.io/pypi/v/memoryintelligence-mcp.svg)](https://pypi.org/project/memoryintelligence-mcp/)
 [![Python](https://img.shields.io/pypi/pyversions/memoryintelligence-mcp.svg)](https://pypi.org/project/memoryintelligence-mcp/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
 [![MCP](https://img.shields.io/badge/MCP-server-blue.svg)](https://modelcontextprotocol.io)
 
 > ## Stop paying AI to reread the same context.
@@ -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>
@@ -195,4 +197,4 @@ Contributions welcome — [CONTRIBUTING.md](CONTRIBUTING.md).
 [What is MCP](https://modelcontextprotocol.io) ·
 [Changelog](CHANGELOG.md)
 
-MIT © Somewhere. See [LICENSE](LICENSE).
+Apache-2.0 © Somewhere Media, LLC. See [LICENSE](LICENSE).

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

@@ -4,10 +4,10 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memoryintelligence-mcp"
-version = "0.2.1"
+version = "0.2.3"
 description = "MCP server for MemoryIntelligence — give Claude a memory you own, set up in one command"
 readme = "README.md"
-license = "MIT"
+license = "Apache-2.0"
 requires-python = ">=3.10"
 authors = [{ name = "Somewhere", email = "connect@somewheremedia.com" }]
 keywords = ["mcp", "model-context-protocol", "memory-intelligence", "claude", "llm", "memory", "ai"]

{memoryintelligence_mcp-0.2.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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)

memoryintelligence_mcp-0.2.1/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Somewhere
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.