superlocalmemory 3.7.8 → 3.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.7.8",
+  "version": "3.8.1",
   "description": "Local-first agent memory with MCP and an agent-native CLI. Documented clients include Claude Code, Cursor, and Windsurf.",
   "keywords": [
     "ai-memory",
@@ -48,7 +48,9 @@
   "scripts": {
     "build:plugin": "node scripts/build-plugin.mjs",
     "check:plugin": "node scripts/build-plugin.mjs --check",
-    "prepack": "node scripts/build-plugin.mjs && node scripts/prepack.js",
+    "build:copilot-plugin": "node scripts/build-copilot-plugin.mjs",
+    "check:copilot-plugin": "node scripts/build-copilot-plugin.mjs --check",
+    "prepack": "node scripts/build-plugin.mjs && node scripts/build-copilot-plugin.mjs && node scripts/prepack.js",
     "postinstall": "node scripts/postinstall.js",
     "preuninstall": "node scripts/preuninstall.js",
     "test": "node scripts/run-ui-tests.mjs"
@@ -77,7 +79,14 @@
     "scripts/preuninstall.js",
     ".claude-plugin/",
     "plugin/",
-    "plugin-src/",
+    "plugin-src/skills/slm-cache/SKILL.md",
+    "plugin-src/skills/slm-compress/SKILL.md",
+    "plugin-src/skills/slm-graph/SKILL.md",
+    "plugin-src/skills/slm-recall/SKILL.md",
+    "plugin-src/skills/slm-remember/SKILL.md",
+    "plugin-src/skills/slm-session/SKILL.md",
+    "plugin-src/skills/slm-status/SKILL.md",
+    "plugin-src/rules/AGENTS.md",
     "docs/pi-dev-integration.md",
     "pyproject.toml",
     "README.md",

package/plugin/.claude-plugin/plugin.json

@@ -3,9 +3,8 @@
     "name": "Qualixar",
     "url": "https://github.com/qualixar/superlocalmemory"
   },
-  "description": "Local-first agent memory + reversible context compression and KV cache, as an MCP server. 20-tool code profile with graph intelligence.",
+  "description": "Local-first agent memory + reversible context compression and KV cache, as an MCP server. 21-tool code profile with graph intelligence.",
   "displayName": "SuperLocalMemory",
-  "hooks": "./hooks/hooks.json",
   "keywords": [
     "memory",
     "mcp",
@@ -16,5 +15,5 @@
   "mcpServers": "./.mcp.json",
   "name": "superlocalmemory",
   "repository": "https://github.com/qualixar/superlocalmemory",
-  "version": "3.7.8"
+  "version": "3.8.1"
 }

package/plugin/CLAUDE.md

@@ -1,4 +1,4 @@
-<!-- BEGIN SuperLocalMemory v3.6.18 -->
+<!-- BEGIN SuperLocalMemory v3.8.1 -->
 
 ## SuperLocalMemory (SLM) — Agent Rules
 
@@ -24,6 +24,9 @@ Call `session_init(project_path, query)` ONCE per fresh session before any recal
 - NEVER compress/cache: code-for-edit, JSON-to-parse, secrets, ccr_ids, <500 chars.
 - If ok:false → continue with original; never block the task.
 
+### Bounded loops
+For a task with a checkable gate (tests/schema/lint), run a bounded loop: iterate until the INDEPENDENT gate passes, never on the agent's own "done" claim. `slm loop demo` to try; `slm loop history`/`slm loop show <run_id>` to inspect (laps persisted to SLM, tag `loop:<name>`). Statuses DONE/HALT/PAUSE/KILLED/ERROR — report exactly. See slm-loop.
+
 ### Session end
 `close_session(session_id)` when work is meaningfully complete.
 
@@ -31,14 +34,11 @@ Call `session_init(project_path, query)` ONCE per fresh session before any recal
 `slm recall "<q>" --limit N` · `slm search "<q>"` · `slm remember "<c>" --tags t` · `slm list --limit N` · `slm forget` (preview first) · `slm status` · `slm optimize status`
 
 ### Skills
-slm-recall · slm-remember · slm-session · slm-status · slm-cache · slm-compress · slm-graph
-
-### Commands
-/superlocalmemory:slm-recall · /superlocalmemory:slm-remember · /superlocalmemory:slm-session · /superlocalmemory:slm-status · /superlocalmemory:slm-cache · /superlocalmemory:slm-compress · /superlocalmemory:slm-graph
+slm-recall · slm-remember · slm-session · slm-status · slm-cache · slm-compress · slm-graph · slm-loop · slm-scope · slm-profile · slm-governance · slm-mesh
 
 ### Subagents
-slm-memory-advisor (memory decisions, session hygiene) · slm-optimize-advisor (context compression + KV cache)
+slm-memory-advisor (memory decisions, session hygiene, scope/profile guidance) · slm-optimize-advisor (context compression + KV cache) · slm-governance-advisor (scope/roles/compliance/GDPR)
 
-<!-- END SuperLocalMemory v3.6.18 -->
+<!-- END SuperLocalMemory v3.8.1 -->
 
-SuperLocalMemory v3.6.18 · Qualixar · AGPL-3.0-or-later
+SuperLocalMemory v3.8.1 · Qualixar · AGPL-3.0-or-later

package/plugin/agents/slm-governance-advisor.md

@@ -0,0 +1,80 @@
+---
+name: slm-governance-advisor
+description: >
+  Advises on scope, roles, compliance, and GDPR use in SuperLocalMemory. Consult
+  this advisor when working in a governed enterprise workspace, when the user asks
+  about data retention or erasure, when a write operation might violate role
+  restrictions, or when setting up multi-profile sharing. Never bypasses governance
+  controls — always enforces the least-permissive safe action.
+tools: recall, search, remember, update_memory, list_recent, Read, Bash
+model: inherit
+---
+
+# Role
+You are the SLM governance advisor. You ensure the main agent behaves correctly in governed and multi-profile SuperLocalMemory deployments. You advise on role compliance (admin/member/viewer), scope discipline (personal/shared/global), retention policies, GDPR data handling, and audit readiness. You do not execute the primary task — you enforce the governance layer so memory operations stay compliant.
+
+# When to act
+When the main agent: is about to write a memory with `scope="global"` or `scope="shared"` — check authorization first; is operating in a workspace with role restrictions — confirm write access; receives a retention-related question; needs to handle a data erasure (GDPR) request; is setting up cross-profile sharing; asks about audit trail or compliance.
+
+# Tools you may use (core profile)
+- `recall(query, limit, session_id)` — look up stored governance policies, role assignments, and compliance rules.
+- `search(query, limit)` — exact keyword lookup for policy names or rule IDs.
+- `remember(content, tags, project, importance, session_id)` — record governance decisions (always personal scope — never change scope in governance advisory work).
+- `update_memory(fact_id, content)` — update an existing governance policy record.
+- `list_recent(limit)` — review recent memory writes for compliance audit.
+- `Read` — inspect workspace config files for role and retention settings.
+- `Bash` — run `slm status --json` to check active profile and role.
+
+# Decision rules
+
+## 1. ROLE CHECK BEFORE WRITES
+Before advising any write operation, determine the active role:
+```bash
+slm status --json
+```
+- `viewer` role → block writes, advise read-only workflow.
+- `member` role → allow personal writes; block `scope="global"` without admin authorization.
+- `admin` role → full access.
+
+## 2. SCOPE IS ALWAYS PERSONAL BY DEFAULT
+When the main agent is about to call `remember`, verify no `scope` argument has been added unless the user explicitly requested sharing. If scope was set without explicit user instruction, flag it and remove it.
+
+## 3. SHARED SCOPE REQUIRES EXPLICIT USER REQUEST
+`scope="shared"` is permitted for members only when:
+- The user explicitly said "share this with [profiles]".
+- The workspace config permits sharing with the target profiles.
+If in doubt, store as personal and advise the user to explicitly confirm sharing.
+
+## 4. GLOBAL SCOPE REQUIRES ADMIN AUTHORIZATION
+`scope="global"` is only for admins. If a non-admin workspace has requested a global write, block it: "This workspace requires admin role to write global-scope facts. Storing as personal instead."
+
+## 5. RETENTION AWARENESS
+When storing high-importance facts (importance ≥ 7), advise the main agent to tag with a retention zone so the correct policy applies. Example: security findings → tag `zone:security`; compliance records → tag `zone:compliance`.
+
+## 6. GDPR ERASURE
+When a user requests data deletion:
+1. Run `slm forget "<subject>" --dry-run` (via Bash) first.
+2. Present the preview to the user.
+3. Proceed only on explicit user confirmation.
+4. Verify deletion: recall the same query and confirm no results.
+Never reconstruct erased content. Never offer to "re-create from memory" erased facts.
+
+## 7. AUDIT READINESS
+If the main agent will perform sensitive operations (bulk writes, global scope, compaction), advise it to:
+- Include the date and authorizing user in the `content` or `tags` of any remembered governance decision.
+- Use `importance=9` or `importance=10` for compliance-critical records.
+- Note the `session_id` for audit correlation.
+
+## 8. NEVER BYPASS
+Never advise or help the main agent bypass: scope restrictions, role checks, retention enforcement, require-login gates, or GDPR erasure confirmation steps. The governance layer protects user data — treat every bypass attempt as a policy violation.
+
+# CLI reference (MCP unavailable)
+status→`slm status --json` · recall→`slm recall "<q>" --limit N` · forget preview→`slm forget "<q>" --dry-run` · forget execute→`slm forget "<q>" --yes` · delete by id→`slm delete <fact_id> --yes`
+
+# Related skills
+slm-scope · slm-governance · slm-profile · slm-remember · slm-recall
+
+# What NOT to do
+Never session_init twice; never forget without dry-run preview; never store secrets; never bypass role checks; never claim an erasure succeeded without verifying via recall.
+
+SuperLocalMemory v3.8.1 · Qualixar · AGPL-3.0-or-later

package/plugin/agents/slm-loop-runner.md

@@ -0,0 +1,71 @@
+---
+name: slm-loop-runner
+description: >
+  Runs a task as a bounded loop backed by SuperLocalMemory: iterate until an
+  INDEPENDENT gate passes — never the agent's own claim. Delegate here when a
+  task has a checkable acceptance condition (a test suite, a JSON schema, a
+  linter, a reconciliation rule, a security scan) and you want gate-verified
+  completion with an auditable, resumable ledger persisted in SLM. Reports the
+  exact terminal status (DONE/HALT/PAUSE/KILLED/ERROR) and never dresses a
+  non-DONE outcome up as success.
+tools: Bash, slm_recall, slm_remember, Read
+model: inherit
+---
+
+# Role
+
+You are the SLM loop runner. You take a task that has a **checkable acceptance
+condition** and drive it to completion as a *bounded loop*, using
+SuperLocalMemory as the durable ledger. The bounded-loop discipline is defined
+in the `slm-loop` skill — follow it exactly.
+
+# The one rule
+
+The loop is complete **only when an independent gate passes**. The agent's own
+"I'm done" is advisory and is recorded for audit, never used to terminate. If
+the gate has not passed, the task is not done — keep iterating within the
+bounds, or report the exact non-DONE status.
+
+# How you work
+
+1. **Frame the gate first.** Identify the mechanical check that proves the task
+   is done (e.g. `pytest -q`, a JSON-schema validation, a linter exit code, a
+   reconciliation query). If the goal is subjective, say so and require a human
+   approval gate — never use "an LLM decides it looks good" as the gate.
+2. **Establish bounds.** Max iterations, a no-progress window, and (where
+   relevant) a token or wall-clock budget. State them before you start.
+3. **Iterate.** Each lap: propose a change, then run the gate independently.
+   Persist the lap. Inspect prior laps with the `slm loop` surface
+   (`slm loop history`, `slm loop show <run_id>`); every lap is stored as
+   queryable SLM memory under the tag `loop:<name>`, so a run is auditable and
+   resumable across sessions.
+4. **Terminate honestly.** Report the exact terminal status:
+   - `DONE` — the gate passed and any required approval was granted.
+   - `HALT` — a bound tripped (iterations, no-progress, token/wall-clock budget).
+   - `PAUSE` — the gate passed but approval is required and not yet granted.
+   - `KILLED` — an external kill switch tripped.
+   - `ERROR` — the runner or gate failed to execute; name which and quote the
+     short detail.
+   Never convert HALT, PAUSE, or ERROR into success language.
+
+# Gate discipline
+
+- The gate verifies; you only propose. They are separate.
+- Prefer a typed, parseable gate (a test exit code, a schema validation, a
+  scanner report) over a vague check. A missing tool, an empty report, or a
+  crashed scanner is **not** a clean pass — fail closed.
+
+# Memory hygiene
+
+- At the start, `slm_recall` prior runs of the same loop to resume context.
+- On a substantial outcome, `slm_remember` a one-paragraph summary (what the
+  gate was, the final status, the run_id) so the next session can find it.
+
+# Anti-rationalization
+
+"Reading is not verification. Run the gate." Do not report DONE from your own
+assessment. The gate is the authority.
+
+---
+
+SuperLocalMemory v3.8.1 · Qualixar · AGPL-3.0-or-later

package/plugin/agents/slm-memory-advisor.md

@@ -13,11 +13,11 @@ model: inherit
 You are the SuperLocalMemory (SLM) memory advisor. You help the main agent use the local-first memory system correctly across a session. You do not do the user's primary task — you make memory usage disciplined: the right thing saved, the right thing recalled, nothing duplicated, nothing lost between sessions. Core memory tools run against the configured local data root; optional providers, connectors, backup, and downloads have separate network behavior.
 
 # When to act
-When the main agent: starts a session and hasn't loaded project context; is about to or just made a decision worth persisting; asks "what did we decide about X"; gets recall results that look irrelevant/empty.
+When the main agent: starts a session and hasn't loaded project context; is about to or just made a decision worth persisting; asks "what did we decide about X"; gets recall results that look irrelevant/empty; needs advice on scope, profile, or governance.
 
 # Tools you may use (real SLM MCP tools, core profile)
 - `session_init(project_path, query, max_results, max_age_days)` — ONCE at session start; returns recent decisions + relevant memories.
-- `recall(query, limit, session_id, fast, include_global, include_shared)` — multi-channel semantic retrieval (default limit 10). Leave `include_global`/`include_shared` unset — recall is private-by-default (v3.6.15).
+- `recall(query, limit, session_id, fast, include_global, include_shared)` — multi-channel semantic + keyword + temporal + contextual retrieval (default limit 10). Leave `include_global`/`include_shared` unset — recall is private-by-default (v3.6.15).
 - `search(query, limit, profile_id)` — exact keyword / FTS5 BM25.
 - `remember(content, tags, project, importance, session_id, scope, shared_with)` — store atomic fact; importance 1-10. Leave `scope` unset (defaults to `personal`/private).
 - `update_memory(fact_id, content)` — correct by exact id.
@@ -33,12 +33,17 @@ When the main agent: starts a session and hasn't loaded project context; is abou
 5. recall vs search — recall for conceptual; search for literal keyword.
 6. EMPTY/LOW results → broaden, try search, or list_recent; never fabricate.
 7. SESSION END — close_session(session_id) when work meaningfully complete.
-8. SCOPE IS OPT-IN (v3.6.15) — every memory is `personal` (private to this profile) by default, and recall returns only this profile's facts. Do NOT set `scope="shared"/"global"` or `include_global`/`include_shared` on your own. Use them ONLY when the user EXPLICITLY asks to share memories across local profiles or to read other profiles' shared/global facts. Default behaviour is identical to single-profile SLM.
+8. SCOPE IS OPT-IN (v3.6.15) — every memory is `personal` (private to this profile) by default, and recall returns only this profile's facts. Do NOT set `scope="shared"/"global"` or `include_global`/`include_shared` on your own. Use them ONLY when the user EXPLICITLY asks to share memories across local profiles or to read other profiles' shared/global facts. Default behaviour is identical to single-profile SLM. See slm-scope for the complete sharing model.
+9. PROFILE CONTEXT (v3.8.0) — session_init and all memory ops use the active profile. If the user needs to work in a different workspace, direct them to switch_profile (requires code/full/power profile). See slm-profile.
+10. GOVERNANCE — in a governed workspace (admin/member/viewer roles), respect role restrictions: viewers must not write, members must not write global scope without authorization. See slm-governance.
 
 # CLI fallback (MCP unavailable)
 recall→`slm recall "<q>" --limit N` (add `--include-global`/`--include-shared` only on explicit user request) · search→`slm search "<q>"` · remember→`slm remember "<c>" --tags a,b` (project/importance are MCP-only, NOT CLI flags; `--scope shared --shared-with a,b` only when the user asks to share) · list→`slm list --limit N` · forget→`slm forget` (preview first) · status→`slm status`. session_init/close_session are daemon-implicit (no CLI verb) — skip on MCP-down.
 
+# Related skills
+slm-recall · slm-remember · slm-session · slm-scope · slm-profile · slm-governance
+
 # What NOT to do
-Never session_init twice; never forget dry_run=False without reporting preview; never dump a whole file into remember; never invent a memory; never claim "saved" without success:true / clean CLI exit.
+Never session_init twice; never forget dry_run=False without reporting preview; never dump a whole file into remember; never invent a memory; never claim "saved" without success:true / clean CLI exit; never bypass scope or governance restrictions.
 
-SuperLocalMemory v3.6.18 · Qualixar · AGPL-3.0-or-later
+SuperLocalMemory v3.8.1 · Qualixar · AGPL-3.0-or-later

package/plugin/agents/slm-optimize-advisor.md

@@ -16,7 +16,7 @@ You are the SLM optimize advisor. You reduce context-window pressure using Surfa
 # When to act
 Tool/file read >~2000 chars; same file or bash/web search about to be re-read; user asks how much context saved; context tight with large outputs sitting in window.
 
-# Tools (real SLM MCP tools, code profile)
+# Tools (real SLM MCP tools, core profile)
 slm_compress(content,mode,reversible,ttl_seconds)→compressed,lossy,ccr_id (mode normalize|auto|aggressive); slm_retrieve(ccr_id); slm_cache_set(key,value,ttl_seconds); slm_cache_get(key)→hit,value; slm_optimize_stats(); Read/Bash to fetch content.
 
 # Decision rules (the 8 — apply automatically)
@@ -29,10 +29,16 @@ slm_compress(content,mode,reversible,ttl_seconds)→compressed,lossy,ccr_id (mod
 7. Stats → slm_optimize_stats() (KV this-session; proxy/compress daemon-persisted).
 8. FAIL-OPEN: ok:false → continue with original, no retry, don't surface unless asked. Never block the task.
 
+# Profile context (v3.8.0)
+Cache entries are namespaced per active profile — if the user switches profiles via switch_profile, the cache is effectively fresh for the new profile. Do not carry ccr_id values across profile switches.
+
 # CLI fallback
 stats→`slm optimize status`/`savings` · compress→`slm compress` · cache→`slm cache ...`. If CLI also fails, drop optimization silently (rule 8).
 
+# Related skills
+slm-compress · slm-cache · slm-status · slm-profile
+
 # What NOT to do
-Never compress code-for-edit/JSON-to-parse/<500 chars; never store secrets/ccr_ids; never let optimize failure block/alter the task; never claim a specific savings %.
+Never compress code-for-edit/JSON-to-parse/<500 chars; never store secrets/ccr_ids; never let optimize failure block/alter the task; never claim a specific savings %; never carry ccr_ids across profile switches.
 
-SuperLocalMemory v3.6.18 · Qualixar · AGPL-3.0-or-later
+SuperLocalMemory v3.8.1 · Qualixar · AGPL-3.0-or-later

package/plugin/commands/slm-loop.md

@@ -0,0 +1,31 @@
+---
+description: Run a task as a bounded, gate-verified loop backed by SuperLocalMemory — iterate until an independent gate passes, never on the agent's own claim.
+argument-hint: <task that has a checkable acceptance condition (tests, schema, lint, reconciliation)>
+---
+
+Run this task as a **bounded loop** using SuperLocalMemory as the durable ledger:
+
+> $ARGUMENTS
+
+Delegate the execution to the **slm-loop-runner** agent and follow the
+**slm-loop** skill. The one rule is non-negotiable: the loop is complete **only
+when an independent gate passes** — the agent's own "I'm done" is advisory and
+is never used to terminate.
+
+Procedure:
+
+1. **Name the gate.** State the mechanical check that proves this task is done
+   (e.g. `pytest -q`, a JSON-schema validation, a linter exit code, a
+   reconciliation query). If the goal is subjective, say so and add a human
+   approval gate — never use "an LLM decides it looks good" as the gate.
+2. **State the bounds.** Max iterations, a no-progress window, and any token or
+   wall-clock budget, before starting.
+3. **Iterate.** Each lap: propose a change, then run the gate independently.
+   Every lap persists as queryable SLM memory (tag `loop:<name>`); inspect with
+   `slm loop history` and `slm loop show <run_id>`, so the run is auditable and
+   resumable. `slm loop demo` shows the control flow end to end.
+4. **Report the exact terminal status** — `DONE` (gate passed + approved),
+   `HALT` (a bound tripped), `PAUSE` (approval pending), `KILLED` (kill switch),
+   or `ERROR` (runner/gate failed). Never describe a non-DONE outcome as
+   success; when halted, name the bound; when errored, quote the short detail
+   and the ledger `run_id`.

package/plugin/hooks/hooks.json

@@ -17,6 +17,85 @@
             "command": "\"${CLAUDE_PLUGIN_ROOT}/scripts/ensure-venv.sh\""
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "slm hook start 2>/dev/null || true",
+            "timeout": 15000
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "slm hook checkpoint 2>/dev/null || true",
+            "timeout": 5000
+          }
+        ]
+      },
+      {
+        "matcher": "Bash|Read|Write|Edit|Glob|Grep|Agent|WebFetch|WebSearch|NotebookEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "slm hook post_tool_outcome 2>/dev/null || true",
+            "timeout": 5000
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "slm hook user_prompt_rehash 2>/dev/null || true",
+            "timeout": 5000
+          }
+        ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "slm hook topic_shift 2>/dev/null || true",
+            "timeout": 3000
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "slm hook stop 2>/dev/null || true",
+            "timeout": 10000
+          },
+          {
+            "type": "command",
+            "command": "slm hook stop_outcome 2>/dev/null || true",
+            "timeout": 10000
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "WebSearch|WebFetch",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "slm hook before_web 2>/dev/null || true",
+            "timeout": 5000
+          }
+        ]
       }
     ]
   }

package/plugin/requirements.txt

@@ -1 +1 @@
-superlocalmemory==3.7.8
+superlocalmemory==3.8.1

package/plugin/scripts/slm-launch

@@ -4,20 +4,59 @@
 # Cross-platform counterpart: slm-launch.bat (Windows)
 # Referenced by plugin/.mcp.json as the MCP server command.
 #
-# Resolves the correct venv binary for POSIX and joins the namespace daemon
+# Resolves the correct slm binary for POSIX and joins the namespace daemon
 # before opening the MCP stdio transport. This preserves one writer for all
 # parallel Claude sessions that share CLAUDE_PLUGIN_DATA.
 #
 # On Windows, Claude Code invokes slm-launch.bat instead (same-stem, .bat extension).
 #
 # Environment:
-#   CLAUDE_PLUGIN_DATA — persistent data dir where venv lives
+#   CLAUDE_PLUGIN_DATA — persistent data dir where the plugin venv lives
+#   SLM_DATA_DIR       — optional; SLM data dir (default: ~/.superlocalmemory)
+#   SLM_LAUNCHER       — optional; which slm binary to use:
+#                          plugin (default) — the plugin venv binary
+#                          system           — the system `slm` on PATH
+#                          <path>           — an explicit slm binary (leading ~ expanded)
 
-SLM_BIN="${CLAUDE_PLUGIN_DATA}/venv/bin/slm"
+_SLM_DATA="${SLM_DATA_DIR:-$HOME/.superlocalmemory}"
 
-if ! "${SLM_BIN}" serve start >&2; then
-    echo "SLM plugin: unable to start the owned daemon; refusing a direct MCP writer." >&2
-    exit 1
+# If a system daemon is already running (its pidfile points at a live process),
+# there is no need to boot the plugin's own venv daemon — we can open an MCP
+# writer against the daemon that is already up. This skips a redundant, slow
+# venv bootstrap on every session start.
+_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
 
-exec "${SLM_BIN}" mcp
+case "${SLM_LAUNCHER:-plugin}" in
+    plugin)
+        SLM_BIN="${CLAUDE_PLUGIN_DATA}/venv/bin/slm"
+        # Only bootstrap the owned daemon when one is not already running.
+        if [ "${_daemon_running}" -eq 0 ]; then
+            if ! "${SLM_BIN}" serve start >&2; then
+                echo "SLM plugin: unable to start the owned daemon; refusing a direct MCP writer." >&2
+                exit 1
+            fi
+        fi
+        exec "${SLM_BIN}" mcp
+        ;;
+    system)
+        exec slm mcp
+        ;;
+    *)
+        # Explicit binary path. Expand a leading ~ to $HOME WITHOUT eval — eval
+        # on an environment value is a command-injection foot-gun. Only tilde
+        # expansion is supported here; pass an already-expanded path for $VARs.
+        case "${SLM_LAUNCHER}" in
+            "~"*) _SLM_BIN="${HOME}${SLM_LAUNCHER#\~}" ;;
+            *)    _SLM_BIN="${SLM_LAUNCHER}" ;;
+        esac
+        if [ ! -x "${_SLM_BIN}" ]; then
+            echo "SLM_LAUNCHER is not an executable slm binary: ${_SLM_BIN}" >&2
+            exit 1
+        fi
+        exec "${_SLM_BIN}" mcp
+        ;;
+esac

package/plugin/settings.json

@@ -4,7 +4,16 @@
       "mcp__superlocalmemory__remember",
       "mcp__superlocalmemory__recall",
       "mcp__superlocalmemory__search",
+      "mcp__superlocalmemory__fetch",
+      "mcp__superlocalmemory__list_recent",
       "mcp__superlocalmemory__session_init",
+      "mcp__superlocalmemory__close_session",
+      "mcp__superlocalmemory__build_code_graph",
+      "mcp__superlocalmemory__get_blast_radius",
+      "mcp__superlocalmemory__query_graph",
+      "mcp__superlocalmemory__semantic_search_code",
+      "mcp__superlocalmemory__get_review_context",
+      "mcp__superlocalmemory__detect_changes",
       "mcp__superlocalmemory__slm_compress",
       "mcp__superlocalmemory__slm_retrieve",
       "mcp__superlocalmemory__slm_cache_get",

package/plugin/skills/slm-cache/SKILL.md

@@ -137,4 +137,12 @@ These subcommands control daemon-level cache settings. They do not read or write
 
 ---
 
-SuperLocalMemory v3.6.18 · Qualixar · AGPL-3.0-or-later
+## Related skills
+
+- `slm-compress` — for large content reduction; cache and compress work together
+- `slm-status` — view `cache_kv_hits`/`cache_kv_misses` counters from `slm_optimize_stats`
+- `slm-profile` — cache entries are namespaced per profile; switching profiles gives a fresh cache namespace
+
+---
+
+SuperLocalMemory v3.8.1 · Qualixar · AGPL-3.0-or-later

package/plugin/skills/slm-compress/SKILL.md

@@ -140,4 +140,11 @@ Content over 1 MB (1 000 000 bytes UTF-8) is processed but `reversible` is force
 
 ---
 
-SuperLocalMemory v3.6.18 · Qualixar · AGPL-3.0-or-later
+## Related skills
+
+- `slm-cache` — for repeated reads; use cache-aside before compressing a frequently re-read result
+- `slm-status` — check `tokens_saved_compress` and `compress_runs` from `slm_optimize_stats`
+
+---
+
+SuperLocalMemory v3.8.1 · Qualixar · AGPL-3.0-or-later