superlocalmemory 4.2.4 → 4.2.6

package/muse-plugin/scripts/ensure-venv.sh

@@ -0,0 +1,169 @@
+#!/usr/bin/env bash
+# ensure-venv.sh — SuperLocalMemory plugin venv bootstrap
+#
+# Called by Claude Code SessionStart hook. Idempotent: fast-path exits in <100ms
+# on repeat invocations when requirements.txt is unchanged.
+#
+# Environment (set by Claude Code plugin runtime):
+#   CLAUDE_PLUGIN_ROOT  — plugin installation dir (ephemeral, contains scripts/ + requirements.txt)
+#   CLAUDE_PLUGIN_DATA  — persistent data dir (venv lives here, survives plugin updates)
+#
+# Exit codes: 0 = venv ready, or not needed   non-0 = failure (logged to stderr)
+# All output goes to stderr only (stdout reserved for MCP stdio protocol).
+
+set -euo pipefail
+
+# ---------------------------------------------------------------------------
+# :? guard — fail loudly if required env vars are unset or empty
+# ---------------------------------------------------------------------------
+: "${CLAUDE_PLUGIN_ROOT:?CLAUDE_PLUGIN_ROOT must be set (plugin installation directory)}"
+: "${CLAUDE_PLUGIN_DATA:?CLAUDE_PLUGIN_DATA must be set (plugin persistent data directory)}"
+
+# ---------------------------------------------------------------------------
+# Redirect all output to stderr (MCP uses stdout for protocol messages)
+# ---------------------------------------------------------------------------
+exec 1>&2
+
+# ---------------------------------------------------------------------------
+# Only build a venv that will be used.
+#
+# slm-launch prefers an slm that is already installed, and SLM_LAUNCHER can name
+# one outright. In those cases the plugin venv is never run, so neither its
+# Python requirement nor its install cost should land on this session. The
+# question is answered by slm-resolve.sh, the same code the launcher and the
+# hooks use, so the three can never disagree about which slm is in play.
+# ---------------------------------------------------------------------------
+# shellcheck source=slm-resolve.sh
+. "$(dirname "${BASH_SOURCE[0]}")/slm-resolve.sh"
+if ! slm_choose; then
+    # A venv cannot fix a launcher that is configured to use something else.
+    # Report it, and leave the session alone: the MCP server reports it again.
+    echo "SLM plugin: venv not needed — ${SLM_RESOLVE_ERROR}" >&2
+    exit 0
+fi
+if [ "${SLM_CHOICE}" != "plugin" ]; then
+    echo "SLM plugin: venv not needed — using ${SLM_CHOICE_BIN} (${SLM_CHOICE})." >&2
+    exit 0
+fi
+
+# ---------------------------------------------------------------------------
+# Python >= 3.12 guard
+# ---------------------------------------------------------------------------
+if ! python3 -c "import sys; sys.exit(0 if sys.version_info >= (3, 12) else 1)" 2>/dev/null; then
+    PY_VER=$(python3 --version 2>&1 || echo "unknown")
+    echo "ERROR: SuperLocalMemory plugin requires Python >= 3.12, found: ${PY_VER}" >&2
+    echo "Install Python 3.12+ and ensure it is first on PATH." >&2
+    exit 1
+fi
+
+# ---------------------------------------------------------------------------
+# Paths
+# ---------------------------------------------------------------------------
+REQ="${CLAUDE_PLUGIN_ROOT}/requirements.txt"
+TORCH_CPU_PIN_FILE="${CLAUDE_PLUGIN_ROOT}/requirements-cpu-torch.txt"
+VENV="${CLAUDE_PLUGIN_DATA}/venv"
+SENTINEL="${CLAUDE_PLUGIN_DATA}/.venv-reqs.sha256"
+VENV_TMP="${CLAUDE_PLUGIN_DATA}/venv.tmp"
+
+# ---------------------------------------------------------------------------
+# Compute sha256 of requirements.txt, and of the CPU-torch pin file when it
+# exists (a pin bump alone must also trigger a rebuild).
+# (cross-platform: prefer sha256sum, fall back to shasum -a 256)
+# ---------------------------------------------------------------------------
+_sha256_of() {
+    if command -v sha256sum >/dev/null 2>&1; then
+        sha256sum "$1" | awk '{print $1}'
+    else
+        shasum -a 256 "$1" | awk '{print $1}'
+    fi
+}
+
+hash_req() {
+    local combined
+    combined="$(_sha256_of "${REQ}")"
+    if [ -f "${TORCH_CPU_PIN_FILE}" ]; then
+        combined="${combined}:$(_sha256_of "${TORCH_CPU_PIN_FILE}")"
+    fi
+    # Fold the (possibly combined) digest down to one hash again so the
+    # sentinel stays a single opaque token either way.
+    if command -v sha256sum >/dev/null 2>&1; then
+        printf '%s' "${combined}" | sha256sum | awk '{print $1}'
+    else
+        printf '%s' "${combined}" | shasum -a 256 | awk '{print $1}'
+    fi
+}
+
+NEW_HASH=$(hash_req)
+
+# ---------------------------------------------------------------------------
+# Fast-path: venv python exists AND sentinel matches current requirements hash
+# venv/bin/python3 (or python) is always present after `python3 -m venv`;
+# the sentinel guards against stale requirements.
+# In production, superlocalmemory also installs venv/bin/slm; both checks pass.
+# ---------------------------------------------------------------------------
+VENV_PYTHON="${VENV}/bin/python3"
+if [ ! -x "${VENV_PYTHON}" ]; then
+    VENV_PYTHON="${VENV}/bin/python"
+fi
+if [ -x "${VENV_PYTHON}" ] && [ -f "${SENTINEL}" ] && [ "$(cat "${SENTINEL}")" = "${NEW_HASH}" ]; then
+    echo "SLM plugin: venv up-to-date (sha256=${NEW_HASH:0:12}…), skipping install." >&2
+    exit 0
+fi
+
+# ---------------------------------------------------------------------------
+# Rebuild venv atomically: install to venv.tmp, rename to venv, write sentinel LAST
+# ---------------------------------------------------------------------------
+echo "SLM plugin: bootstrapping Python venv at ${VENV} …" >&2
+echo "  requirements: ${REQ}" >&2
+echo "  python3: $(python3 --version 2>&1)" >&2
+
+# Clean up any partial previous attempt
+rm -rf "${VENV_TMP}"
+
+# Create fresh venv
+python3 -m venv "${VENV_TMP}"
+
+# Upgrade pip first (prefer binary to avoid source builds)
+"${VENV_TMP}/bin/pip" install --upgrade pip --prefer-binary --quiet
+
+# ---------------------------------------------------------------------------
+# CPU-only torch on CPU-only Linux. Plain PyPI resolution of the
+# `torch==X.Y.Z` requirement that requirements.txt pulls in transitively
+# installs the CUDA build on Linux (torch + triton + ~18 nvidia-* packages,
+# about 2.6 GiB) even when there is no GPU to use it. Pre-installing the
+# pinned version from the official CPU index first means the later
+# `pip install -r requirements.txt` below finds it already satisfied and
+# never touches the CUDA wheels. macOS, Windows, a host with a GPU, and a
+# user who already set SLM_TORCH_BACKEND or their own pip index are all left
+# exactly as before (see torch-cpu-resolve.sh).
+# shellcheck source=torch-cpu-resolve.sh
+. "$(dirname "${BASH_SOURCE[0]}")/torch-cpu-resolve.sh"
+if torch_cpu_should_force; then
+    if TORCH_PIN="$(torch_cpu_pin "${TORCH_CPU_PIN_FILE}")"; then
+        echo "SLM plugin: Linux, no GPU detected — installing ${TORCH_PIN} from ${TORCH_CPU_INDEX_URL} (set SLM_TORCH_BACKEND=cuda to opt out)." >&2
+        "${VENV_TMP}/bin/pip" install \
+            --require-virtualenv \
+            --prefer-binary \
+            --quiet \
+            --index-url "${TORCH_CPU_INDEX_URL}" \
+            "${TORCH_PIN}"
+    fi
+fi
+
+# Install requirements
+"${VENV_TMP}/bin/pip" install \
+    --require-virtualenv \
+    --prefer-binary \
+    --quiet \
+    -r "${REQ}"
+
+echo "SLM plugin: install complete, activating venv." >&2
+
+# Atomic swap: remove old venv (if any), rename tmp into place
+rm -rf "${VENV}"
+mv "${VENV_TMP}" "${VENV}"
+
+# Write sentinel LAST — guarantees that a crash before this line triggers rebuild
+echo "${NEW_HASH}" > "${SENTINEL}"
+
+echo "SLM plugin: venv ready at ${VENV}/bin/slm" >&2

package/muse-plugin/scripts/slm-launch

@@ -0,0 +1,207 @@
+#!/usr/bin/env bash
+# slm-launch — SuperLocalMemory MCP launcher (POSIX)
+#
+# Cross-platform counterpart: slm-launch.bat (Windows)
+# Referenced by .mcp.json as the MCP server command.
+#
+# WHAT THIS RESOLVES, AND WHY THE DEFAULT CHANGED
+#
+# It used to default to a venv the plugin owns:
+# "${CLAUDE_PLUGIN_DATA}/venv/bin/slm". So anyone who already had SuperLocalMemory
+# — from pip, pipx or npm — got a SECOND installation the moment they installed
+# the plugin, on its own schedule, upgraded separately, and easy to leave behind
+# a release. Installing a plugin should not fork your installation.
+#
+# It was also Claude-Code-only. ${CLAUDE_PLUGIN_DATA} is set by Claude Code and
+# by nothing else, so on Codex or Antigravity the path collapsed to
+# "/venv/bin/slm" and the server simply did not start.
+#
+# The default is now: USE THE SLM THAT IS ALREADY INSTALLED. A plugin-owned venv
+# is the fallback for a machine that has none, not the first choice.
+#
+# Environment (all optional):
+#   SLM_LAUNCHER       auto (default) — prefer an installed slm, else the plugin venv
+#                      system         — require the slm on PATH
+#                      plugin         — require the plugin's own venv
+#                      <path>         — an explicit slm binary (leading ~ expanded)
+#   SLM_DATA_DIR       SLM data dir (default: ~/.superlocalmemory)
+#   CLAUDE_PLUGIN_DATA where a plugin-owned venv lives (then CURSOR_PLUGIN_DATA,
+#                      PLUGIN_DATA, then ~/.local/share/superlocalmemory-plugin)
+#   SLM_LAUNCHER_BOOTSTRAP=1  build that venv here when nothing else can run
+#
+# HOSTS THAT DO NOT EXPAND THEIR VARIABLES
+#
+# Some hosts (Grok Bot's plugin computer) pass ${CLAUDE_PLUGIN_ROOT} and
+# ${CLAUDE_PLUGIN_DATA} through literally. So this script finds itself from
+# BASH_SOURCE, and treats any value still containing "${" as unset.
+#
+# Which slm runs, in order: SLM_LAUNCHER; an slm on PATH; the plugin venv, if
+# built; uvx, pinned to this plugin's release (CPU-only torch on Linux); and,
+# only with SLM_LAUNCHER_BOOTSTRAP=1, a plugin venv built on the spot.
+# The daemon is started first and `slm serve start` waits (up to 60 s) for its
+# /health, so the first remember after a cold start is not "daemon unavailable".
+#
+# Deliberately NOT set here: the MCP profile. Which tools a host exposes is the
+# user's decision, and a plugin that narrows it takes away tools they configured.
+
+# Where this script lives. Never from ${CLAUDE_PLUGIN_ROOT}: not every host sets it.
+_slm_self="${BASH_SOURCE[0]}"
+while [ -h "${_slm_self}" ]; do
+    _slm_link="$(readlink "${_slm_self}")"
+    case "${_slm_link}" in
+        /*) _slm_self="${_slm_link}" ;;
+        *)  _slm_self="$(dirname "${_slm_self}")/${_slm_link}" ;;
+    esac
+done
+_SLM_SCRIPTS="$(cd "$(dirname "${_slm_self}")" && pwd)"
+_SLM_PLUGIN_ROOT="$(dirname "${_SLM_SCRIPTS}")"
+
+# A value that is empty, or a placeholder the host never replaced, is not a value.
+_slm_usable() {
+    case "$1" in
+        ''|*'${'*) return 1 ;;
+    esac
+    return 0
+}
+[ -n "${HOME:-}" ] || { HOME="$(cd ~ 2>/dev/null && pwd)"; export HOME; }
+_slm_usable "${SLM_DATA_DIR:-}" || unset SLM_DATA_DIR
+_slm_usable "${SLM_LAUNCHER:-}" || unset SLM_LAUNCHER
+if ! _slm_usable "${CLAUDE_PLUGIN_DATA:-}"; then
+    unset CLAUDE_PLUGIN_DATA
+    for _slm_d in "${CURSOR_PLUGIN_DATA:-}" "${PLUGIN_DATA:-}" \
+                  "${XDG_DATA_HOME:-${HOME}/.local/share}/superlocalmemory-plugin"; do
+        if _slm_usable "${_slm_d}"; then CLAUDE_PLUGIN_DATA="${_slm_d}"; break; fi
+    done
+fi
+
+_SLM_DATA="${SLM_DATA_DIR:-$HOME/.superlocalmemory}"
+
+# Which slm to run is decided in ONE place, shared with the hooks and the venv
+# bootstrap, so the three can never disagree about which install is in play.
+# shellcheck source=slm-resolve.sh
+. "${_SLM_SCRIPTS}/slm-resolve.sh"
+_PLUGIN_BIN="$(slm_plugin_bin)"
+
+# Is a daemon already up for this data dir? If so we join it rather than boot a
+# second one — one writer for every session that shares the store.
+_daemon_running=0
+if [ -f "${_SLM_DATA}/daemon.pid" ] \
+   && kill -0 "$(cat "${_SLM_DATA}/daemon.pid" 2>/dev/null)" 2>/dev/null; then
+    _daemon_running=1
+fi
+
+# Start a daemon with the chosen command unless one is already serving.
+_ensure_daemon() {
+    [ "${_daemon_running}" -eq 1 ] && return 0
+    "$@" serve start >&2
+}
+
+# The release this plugin tree ships (requirements.txt is stamped every release).
+_slm_pin() {
+    sed -n 's/^\(superlocalmemory==[0-9][0-9A-Za-z.+!-]*\)[[:space:]]*$/\1/p' \
+        "${_SLM_PLUGIN_ROOT}/requirements.txt" 2>/dev/null | head -n 1
+}
+
+# No installed slm and no plugin venv: run this release through uvx. Returns
+# only when it cannot (no uvx, or no pin); otherwise it becomes the server.
+_slm_run_uvx() {
+    local _pin
+    command -v uvx >/dev/null 2>&1 || return 1
+    _pin="$(_slm_pin)"
+    if [ -z "${_pin}" ]; then
+        echo "SLM plugin: not using uvx: no superlocalmemory pin in ${_SLM_PLUGIN_ROOT}/requirements.txt." >&2
+        return 1
+    fi
+    # PyPI's Linux torch is the CUDA build; macOS and Windows get CPU wheels anyway.
+    if [ "$(uname -s 2>/dev/null)" = "Linux" ]; then
+        export UV_TORCH_BACKEND="${UV_TORCH_BACKEND:-cpu}"
+    fi
+    export TOKENIZERS_PARALLELISM="${TOKENIZERS_PARALLELISM:-false}"
+    echo "SLM plugin: no installed slm; running ${_pin} through uvx (downloaded once, then cached)." >&2
+    _ensure_daemon uvx --from "${_pin}" slm || \
+        echo "SLM plugin: daemon did not start; the MCP server will retry on first use." >&2
+    exec uvx --from "${_pin}" slm mcp
+}
+
+# Opt-in: build the plugin venv now, with the same bootstrap SessionStart runs.
+_slm_bootstrap() {
+    [ "${SLM_LAUNCHER_BOOTSTRAP:-0}" = "1" ] || return 1
+    CLAUDE_PLUGIN_ROOT="${_SLM_PLUGIN_ROOT}" CLAUDE_PLUGIN_DATA="${CLAUDE_PLUGIN_DATA}" \
+        bash "${_SLM_SCRIPTS}/ensure-venv.sh" >&2 || return 1
+    [ -x "${SLM_CHOICE_BIN}" ]
+}
+
+if ! slm_choose; then
+    echo "${SLM_RESOLVE_ERROR}" >&2
+    exit 1
+fi
+
+case "${SLM_LAUNCHER:-auto}:${SLM_CHOICE}" in
+    auto:system)
+        # An slm already on PATH — the pip, pipx or npm install the user has.
+        # This is the common case and the one that must not be forked.
+        #
+        # Both orderings end up here, and both must converge on ONE
+        # environment:
+        #   installed first, plugin second -> nothing was ever forked;
+        #   plugin first, installed second -> the plugin venv is now the
+        #     older copy and must stop being used.
+        # They already share one store, because this launcher sets no
+        # SLM_DATA_DIR and both resolve ~/.superlocalmemory. What is left to
+        # go wrong is two DIFFERENT VERSIONS serving that one store: whoever
+        # starts the daemon first decides which code the other one talks to.
+        # So when a leftover plugin venv is found beside a real install, say
+        # so, with both versions named. Silent duplication is how a store
+        # ends up served by a release nobody thinks they are running.
+        if [ -n "${_PLUGIN_BIN}" ] && [ -x "${_PLUGIN_BIN}" ]; then
+            _sys_v="$(slm --version 2>/dev/null | awk '{print $NF}')"
+            _plg_v="$("${_PLUGIN_BIN}" --version 2>/dev/null | awk '{print $NF}')"
+            if [ -n "${_plg_v}" ] && [ "${_sys_v}" != "${_plg_v}" ]; then
+                echo "SLM plugin: using the installed slm ${_sys_v:-?} and IGNORING a leftover plugin venv at ${_PLUGIN_BIN} (${_plg_v})." >&2
+                echo "  One store, one version. Remove the venv to stop it drifting:  rm -rf \"${CLAUDE_PLUGIN_DATA}/venv\"" >&2
+            fi
+        fi
+        _ensure_daemon "${SLM_CHOICE_BIN}" || \
+            echo "SLM plugin: daemon did not start; continuing as a direct MCP writer." >&2
+        exec slm mcp
+        ;;
+    auto:plugin)
+        # No system install. Use the plugin's own venv, once SessionStart has
+        # built it. A host that runs no hooks never builds it: then uvx, then
+        # (opt-in) a venv built here. If none of that works, say what was
+        # looked for, so the fix is obvious.
+        if [ "${SLM_CHOICE_READY}" -ne 1 ]; then
+            _slm_run_uvx
+            if ! _slm_bootstrap; then
+                slm_not_found_message >&2
+                echo >&2
+                echo "  Or install uv (https://docs.astral.sh/uv/): the plugin then runs SuperLocalMemory through uvx." >&2
+                exit 1
+            fi
+        fi
+        if ! _ensure_daemon "${SLM_CHOICE_BIN}"; then
+            echo "SLM plugin: unable to start the owned daemon; refusing a direct MCP writer." >&2
+            exit 1
+        fi
+        exec "${SLM_CHOICE_BIN}" mcp
+        ;;
+    system:system)
+        _ensure_daemon "${SLM_CHOICE_BIN}" || true
+        exec slm mcp
+        ;;
+    plugin:plugin)
+        if ! _ensure_daemon "${SLM_CHOICE_BIN}"; then
+            echo "SLM plugin: unable to start the owned daemon; refusing a direct MCP writer." >&2
+            exit 1
+        fi
+        exec "${SLM_CHOICE_BIN}" mcp
+        ;;
+    *:explicit)
+        _ensure_daemon "${SLM_CHOICE_BIN}" || true
+        exec "${SLM_CHOICE_BIN}" mcp
+        ;;
+    *)
+        echo "SLM plugin: internal error: unexpected launcher choice '${SLM_LAUNCHER:-auto}:${SLM_CHOICE}'." >&2
+        exit 1
+        ;;
+esac

package/muse-plugin/scripts/slm-launch.bat

@@ -0,0 +1,32 @@
+@echo off
+:: slm-launch.bat — WP-F SuperLocalMemory MCP launcher (Windows)
+::
+:: Cross-platform counterpart: slm-launch (POSIX bash)
+::
+:: NOT reached through plugin/.mcp.json. That file names the extensionless
+:: "${CLAUDE_PLUGIN_ROOT}/scripts/slm-launch", and a host that spawns it without
+:: a shell (CreateProcess, Node spawn without shell) never resolves it to this
+:: .bat: CreateProcess cannot start a batch file and only appends .exe to a
+:: name without an extension. This file runs only when started through cmd.exe
+:: (for example a hand-written MCP entry using "cmd /c"). It does not read
+:: SLM_LAUNCHER; see MCP_JSON_NOTES.md and issue #139. Since 4.1.20 the plugin's
+:: .mcp.json starts the INSTALLED slm on Windows through %ComSpec% instead.
+:: Proven on the Windows CI runner: tests/test_plugin/test_windows_mcp_spawn_premise.py
+::
+:: Resolves the correct venv binary for Windows and joins the namespace daemon
+:: before opening MCP, preserving one writer for parallel Claude sessions.
+::
+:: On Windows, Python venv places entry points in Scripts\ (not bin\ like POSIX).
+:: This launcher bridges the path difference so ONE .mcp.json command field works
+:: cross-platform.
+::
+:: Environment:
+::   CLAUDE_PLUGIN_DATA — persistent data dir where venv lives
+
+"%CLAUDE_PLUGIN_DATA%\venv\Scripts\slm.exe" serve start 1>&2
+if errorlevel 1 (
+    echo SLM plugin: unable to start the owned daemon; refusing a direct MCP writer. 1>&2
+    exit /b 1
+)
+
+"%CLAUDE_PLUGIN_DATA%\venv\Scripts\slm.exe" mcp

package/muse-plugin/scripts/slm-resolve.sh

@@ -0,0 +1,128 @@
+#!/usr/bin/env bash
+# slm-resolve.sh — which SuperLocalMemory install does this plugin use?
+#
+# Sourced, never run. ONE answer to that question, shared by every script that
+# needs it:
+#   slm-launch      the MCP server
+#   slm-run         every lifecycle hook
+#   ensure-venv.sh  the plugin venv bootstrap (it only builds what will be used)
+# Before this file each of them decided on its own, and they disagreed: the
+# launcher fell back to the plugin venv, the hooks only ever tried a bare `slm`,
+# and the bootstrap built a venv even when nothing would run it.
+#
+# Environment (all optional):
+#   SLM_LAUNCHER       auto (default) — prefer an installed slm, else the plugin venv
+#                      system         — require the slm on PATH
+#                      plugin         — require the plugin's own venv
+#                      <path>         — an explicit slm binary (leading ~ expanded)
+#   CLAUDE_PLUGIN_DATA where a plugin-owned venv lives, when there is one
+#
+# After slm_choose returns 0:
+#   SLM_CHOICE        system | plugin | explicit
+#   SLM_CHOICE_BIN    the binary that choice names
+#   SLM_CHOICE_READY  1 when SLM_CHOICE_BIN is executable now, else 0
+#                     (a plugin venv that SessionStart has not built yet is 0)
+# After slm_choose returns 1:
+#   SLM_RESOLVE_ERROR what was asked for and why it cannot be honoured
+#
+# Safe under `set -euo pipefail`: every variable read has a default.
+
+# Expand a leading ~ WITHOUT eval — eval on an environment value is a
+# command-injection foot-gun. Only tilde expansion; pass expanded paths for vars.
+_slm_expand_tilde() {
+    case "$1" in
+        "~"*) printf '%s' "${HOME}${1#\~}" ;;
+        *)    printf '%s' "$1" ;;
+    esac
+}
+
+# Where the plugin venv keeps slm. Empty when the host gives the plugin no data
+# directory (only Claude Code sets CLAUDE_PLUGIN_DATA). A venv built on Windows
+# keeps entry points in Scripts\ with an .exe suffix, and Git Bash is where these
+# scripts run there.
+#
+# _slm_plugin_bin_var sets SLM_PLUGIN_BIN without a subshell (hooks run this on
+# every tool call); slm_plugin_bin prints it, for callers that want a value.
+_slm_plugin_bin_var() {
+    SLM_PLUGIN_BIN=""
+    [ -n "${CLAUDE_PLUGIN_DATA:-}" ] || return 0
+    case "${OSTYPE:-}" in
+        msys*|cygwin*|win32*) SLM_PLUGIN_BIN="${CLAUDE_PLUGIN_DATA}/venv/Scripts/slm.exe" ;;
+        *)                    SLM_PLUGIN_BIN="${CLAUDE_PLUGIN_DATA}/venv/bin/slm" ;;
+    esac
+}
+
+slm_plugin_bin() {
+    _slm_plugin_bin_var
+    printf '%s' "${SLM_PLUGIN_BIN}"
+}
+
+# The message for "nothing to run", naming both places that were looked in.
+slm_not_found_message() {
+    local _pbin
+    _pbin="$(slm_plugin_bin)"
+    printf '%s\n' "SLM plugin: no SuperLocalMemory found."
+    printf '%s\n' "  Looked for: 'slm' on PATH, and ${_pbin:-a plugin venv (this host sets no plugin data dir)}."
+    printf '%s'   "  Install it with:  pipx install superlocalmemory"
+}
+
+_slm_set_choice() {
+    SLM_CHOICE="$1"
+    SLM_CHOICE_BIN="$2"
+    if [ -n "$2" ] && [ -x "$2" ]; then SLM_CHOICE_READY=1; else SLM_CHOICE_READY=0; fi
+}
+
+slm_choose() {
+    SLM_CHOICE=""
+    SLM_CHOICE_BIN=""
+    SLM_CHOICE_READY=0
+    SLM_RESOLVE_ERROR=""
+    local _pbin _sys
+    _slm_plugin_bin_var
+    _pbin="${SLM_PLUGIN_BIN}"
+
+    case "${SLM_LAUNCHER:-auto}" in
+        auto)
+            # 1. An slm already on PATH — the pip, pipx or npm install the user
+            #    has. The common case, and the one that must not be forked.
+            if _sys="$(command -v slm 2>/dev/null)" && [ -n "${_sys}" ]; then
+                _slm_set_choice system "${_sys}"
+                return 0
+            fi
+            # 2. No system install: the plugin's own venv, if this host gives the
+            #    plugin somewhere to keep one. It may not be built yet.
+            if [ -n "${_pbin}" ]; then
+                _slm_set_choice plugin "${_pbin}"
+                return 0
+            fi
+            # 3. Neither.
+            SLM_RESOLVE_ERROR="$(slm_not_found_message)"
+            return 1
+            ;;
+        system)
+            if _sys="$(command -v slm 2>/dev/null)" && [ -n "${_sys}" ]; then
+                _slm_set_choice system "${_sys}"
+                return 0
+            fi
+            SLM_RESOLVE_ERROR="SLM_LAUNCHER=system but no 'slm' on PATH."
+            return 1
+            ;;
+        plugin)
+            if [ -z "${_pbin}" ]; then
+                SLM_RESOLVE_ERROR="SLM_LAUNCHER=plugin but this host sets no CLAUDE_PLUGIN_DATA."
+                return 1
+            fi
+            _slm_set_choice plugin "${_pbin}"
+            return 0
+            ;;
+        *)
+            _sys="$(_slm_expand_tilde "${SLM_LAUNCHER}")"
+            if [ ! -x "${_sys}" ]; then
+                SLM_RESOLVE_ERROR="SLM_LAUNCHER is not an executable slm binary: ${_sys}"
+                return 1
+            fi
+            _slm_set_choice explicit "${_sys}"
+            return 0
+            ;;
+    esac
+}

package/muse-plugin/scripts/slm-run

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# slm-run — run slm for a plugin hook, using the slm the MCP server uses.
+#
+#   "${CLAUDE_PLUGIN_ROOT}/scripts/slm-run" hook <name>
+#
+# Hooks used to call a bare `slm`, so on a machine where SuperLocalMemory lives
+# only in the plugin venv every hook was "command not found" — and the error was
+# thrown away, so memory capture stopped with nothing to say why. This wrapper
+# resolves slm with the launcher's own code (slm-resolve.sh), honours the same
+# SLM_LAUNCHER, and passes stdin, stdout and the arguments straight through.
+#
+# A hook must never break the session that runs it, so this ALWAYS exits 0
+# (Claude Code reads exit 2 as "block"). When slm cannot be found, or fails, the
+# reason goes to
+#     ${SLM_DATA_DIR:-~/.superlocalmemory}/logs/plugin-hooks.log
+# and one line naming that file goes to stderr. A hook that succeeds is silent:
+# whatever slm wrote to stderr is discarded, exactly as before.
+
+_slm_args="$*"
+_log_dir="${SLM_DATA_DIR:-${HOME}/.superlocalmemory}/logs"
+_log="${_log_dir}/plugin-hooks.log"
+_LOG_MAX_BYTES=1048576
+
+# Append one entry. Best effort: an unwritable log must not fail the hook.
+_log_entry() {
+    {
+        mkdir -p "${_log_dir}" || return 1
+        if [ -f "${_log}" ] && [ "$(wc -c < "${_log}")" -gt "${_LOG_MAX_BYTES}" ]; then
+            mv -f "${_log}" "${_log}.1"
+        fi
+        printf '%s slm %s: %s\n' "$(date -u '+%Y-%m-%dT%H:%M:%SZ')" "${_slm_args}" "$1" >> "${_log}"
+    } 2>/dev/null
+}
+
+# Record a failure, tell stderr where to look, and leave the session alone.
+_give_up() {
+    if _log_entry "$1"; then
+        echo "SLM plugin: hook 'slm ${_slm_args}' did not run cleanly; see ${_log}" >&2
+    else
+        echo "SLM plugin: hook 'slm ${_slm_args}' did not run cleanly: $1" >&2
+    fi
+    exit 0
+}
+
+_here="${BASH_SOURCE[0]%/*}"
+[ "${_here}" = "${BASH_SOURCE[0]}" ] && _here=.
+# shellcheck source=slm-resolve.sh
+if ! . "${_here}/slm-resolve.sh" 2>/dev/null; then
+    _give_up "the plugin is incomplete: ${_here}/slm-resolve.sh is missing"
+fi
+
+if ! slm_choose; then
+    _give_up "$(printf '%s' "${SLM_RESOLVE_ERROR}" | tr '\n' ' ')"
+fi
+
+if [ "${SLM_CHOICE_READY}" -ne 1 ]; then
+    if [ "${SLM_LAUNCHER:-auto}" = "auto" ]; then
+        _give_up "$(slm_not_found_message | tr '\n' ' ') (A plugin venv is built by SessionStart; the first session can run its hooks before it exists.)"
+    fi
+    _give_up "${SLM_CHOICE} slm is not executable: ${SLM_CHOICE_BIN}"
+fi
+
+# slm's stderr is kept only long enough to report a failure. The trap removes
+# it however this script ends, including a host timeout killing the hook.
+_err="$(mktemp "${TMPDIR:-/tmp}/slm-hook.XXXXXX" 2>/dev/null)" || _err=/dev/null
+trap '[ "${_err}" = /dev/null ] || rm -f "${_err}"' EXIT
+trap 'exit 0' HUP INT TERM
+
+"${SLM_CHOICE_BIN}" "$@" 2>"${_err}"
+_rc=$?
+if [ "${_rc}" -ne 0 ]; then
+    _detail=""
+    [ "${_err}" = /dev/null ] || _detail="$(tail -n 5 "${_err}" 2>/dev/null | tr '\n' ' ')"
+    _give_up "exit ${_rc} from ${SLM_CHOICE_BIN} (${SLM_CHOICE})${_detail:+: ${_detail}}"
+fi
+exit 0