superlocalmemory 3.7.7 → 3.8.0

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.0 · 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.0 · 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.0 · 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.7
+superlocalmemory==3.8.0

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.0 · 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.0 · Qualixar · AGPL-3.0-or-later

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

@@ -0,0 +1,248 @@
+---
+name: slm-governance
+description: Enterprise compliance and governed workspace behavior for SuperLocalMemory. Covers role-based access (admin/member/viewer), retention policies, audit trail, GDPR data export/erase, and how agents must behave when operating under workspace governance. Requires power MCP profile for audit/retention tools. Agents must never bypass governance controls.
+when_to_use: |
+  - "What can I do in this workspace?" (role check)
+  - "Set a 90-day retention policy on this memory"
+  - "Show the audit trail for recent memory operations"
+  - "Export my data for GDPR compliance"
+  - "Delete all memories for user X (right to erasure)"
+  - "Configure require-login for this workspace"
+  - Enterprise deployment with multi-team shared SLM
+  - Compliance, audit, or data governance task
+allowed-tools: audit_trail, set_retention_policy, get_retention_stats, get_lifecycle_status, recall, search, remember, Bash
+---
+
+# slm-governance — Enterprise Compliance and Governed Workspace Behavior
+
+SuperLocalMemory supports enterprise deployments with role-based access control,
+retention policies, audit logging, and GDPR compliance tooling. This skill
+documents how agents must behave when operating in a governed workspace and how
+to use the governance MCP tools (available in the `power` profile).
+
+---
+
+## Role model
+
+Governed workspaces have three roles:
+
+| Role | Read | Write personal | Write shared/global | Admin operations |
+|------|------|---------------|---------------------|-----------------|
+| `viewer` | Yes | No | No | No |
+| `member` | Yes | Yes | Yes (within access list) | No |
+| `admin` | Yes | Yes | Yes (unrestricted) | Yes |
+
+**Agent behavior by role:**
+
+- **Viewer**: Only call `recall`, `search`, `fetch`, `list_recent`. Never call
+  `remember`, `update_memory`, `forget`, or any write tool. If a write is
+  attempted, fail gracefully: "This workspace is read-only in viewer mode."
+- **Member**: May write personal facts and shared facts with permitted profiles.
+  May NOT write `scope="global"` facts without explicit admin authorization.
+  May NOT call `set_retention_policy`, `audit_trail`, or `compact_memories`.
+- **Admin**: Full access including governance tools in the `power` profile.
+
+An agent operating in a governed workspace must check its role before any write
+operation. Role information is visible in workspace configuration or via
+`slm status --json` (the `role` field, if present).
+
+---
+
+## Retention policies
+
+Retention policies control how long facts are stored before they become eligible
+for decay. Available in the `power` MCP profile.
+
+### Set a retention policy
+
+```
+set_retention_policy(
+  profile_id: str = "",   # "" = active profile
+  days: int = 90,         # facts older than this become decay-eligible
+  zone: str = "default",  # retention zone name
+)
+```
+
+Retention zones let you apply different policies to different fact categories:
+
+```
+# Standard facts: 90-day retention
+set_retention_policy(profile_id="", days=90, zone="default")
+
+# Security findings: 365-day retention (compliance requirement)
+set_retention_policy(profile_id="", days=365, zone="security")
+```
+
+Tag your facts with the zone name to route them to the right policy:
+```
+remember(content="Critical auth bypass in v2.1", tags="security,cve,finding", ...)
+```
+
+### Check retention statistics
+
+```
+get_retention_stats()
+```
+
+Returns zone distribution, average fact age, and decay-eligible counts. Use this
+to verify policies are working as expected.
+
+### Check lifecycle status
+
+```
+get_lifecycle_status()
+```
+
+Reports the state of the retention and decay subsystem — whether decay cycles are
+running, when the next cycle runs, and any backlog.
+
+---
+
+## Audit trail
+
+`audit_trail` is available in the `power` profile. It returns a structured log of
+recent memory operations (writes, reads, profile switches, policy changes).
+
+```
+audit_trail(
+  limit: int = 50,          # number of entries to return
+  operation: str = "",      # filter by operation type (e.g. "remember", "forget")
+  profile_id: str = "",     # filter by profile; "" = active profile
+)
+```
+
+Use this for:
+- Compliance reviews ("what data was written in the last 30 days?")
+- Investigating unexpected memory changes
+- Generating audit reports for data controllers
+
+The audit trail covers MCP and CLI operations. It does not record the content of
+facts by default — only operation type, timestamp, agent ID, and fact ID.
+
+---
+
+## GDPR compliance
+
+### Data export
+
+SLM does not have a dedicated MCP export tool. For GDPR data subject access
+requests, use the CLI:
+
+```bash
+# Export all memories in a profile to JSON
+slm status --json     # confirm active profile
+slm list --limit 9999 --json > export.json
+```
+
+For a complete export including entity graph data, run:
+```bash
+slm status --json
+```
+
+Contact your workspace admin to arrange a full database-level export if the CLI
+output is insufficient for compliance purposes.
+
+### Right to erasure
+
+To erase all memories for a subject or project:
+
+```bash
+# Step 1: preview what will be deleted (ALWAYS do this first)
+slm forget "<subject or project name>" --dry-run --json
+
+# Step 2: review the preview, then execute
+slm forget "<subject or project name>" --yes --json
+```
+
+For targeted deletion by fact ID:
+```bash
+slm delete <fact_id> --yes --json
+```
+
+For data reconstruction prevention: after erasure, confirm the fact is gone by
+running `slm recall "<content>"`. A successful erasure returns no results. Never
+attempt to re-derive erased content from other stored facts.
+
+---
+
+## require-login
+
+When `require_login` is enabled in workspace configuration, agents must
+authenticate before any memory operation. SLM handles authentication at the
+daemon level — agents do not need to pass credentials in tool calls. If an
+agent receives an authentication error from any MCP tool, it must:
+
+1. Stop the current operation immediately.
+2. Report the authentication requirement to the user.
+3. Never cache, retry, or work around the authentication block.
+
+---
+
+## Scope enforcement in governed workspaces
+
+In a governed workspace, scope restrictions are enforced server-side:
+- **Viewers** cannot write any fact regardless of `scope` parameter.
+- **Members** cannot write `scope="global"` unless their access list includes
+  the global scope — attempts return a permission error.
+- **Admins** can write any scope.
+
+Agents must not attempt to work around scope restrictions by splitting a global
+fact into multiple shared facts to accumulate equivalent visibility.
+
+---
+
+## Compact memories (admin-only)
+
+`compact_memories` deduplicates and consolidates stored memories. This is an
+admin operation — it can change fact IDs and remove content.
+
+```
+compact_memories(
+  profile_id: str = "",   # "" = active profile
+  dry_run: bool = True,   # ALWAYS true first — inspect before running
+)
+```
+
+Always run with `dry_run=True` first and review the impact report. Never run
+compaction without admin authorization.
+
+---
+
+## Consistency check (admin-only)
+
+```
+consistency_check(profile_id: str = "")
+```
+
+Verifies data integrity of the memory store — checks for orphaned entities,
+broken references, and index-database mismatches. Use after migrations or
+unexpected shutdowns. Returns a structured report.
+
+---
+
+## Agent checklist for governed workspaces
+
+Before each write operation:
+- [ ] Confirm my role allows writes (viewer → skip; member/admin → proceed)
+- [ ] Confirm scope is appropriate for my role (member → no global)
+- [ ] Set correct tags including zone name if retention policy applies
+- [ ] Pass `session_id` for full audit attribution
+
+Before running any destructive operation (`forget`, `compact_memories`):
+- [ ] Admin authorization confirmed
+- [ ] Ran with `dry_run=True` and reviewed output
+- [ ] GDPR: confirmed the subject or controller authorized the erasure
+
+---
+
+## Related skills
+
+- `slm-scope` — scope model details (personal/shared/global)
+- `slm-profile` — workspace isolation and profile switching
+- `slm-remember` — fact storage reference (includes scope parameters)
+- `slm-recall` — retrieval reference (includes scope read flags)
+- `slm-mesh` — mesh tools (full/power profiles)
+
+---
+
+*SuperLocalMemory v3.8.0 · Qualixar · AGPL-3.0-or-later*

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

@@ -285,7 +285,8 @@ If `build_code_graph` returns `files_parsed: 0`, no supported source files were
 
 ## Profile Requirement
 
-This skill uses graph tools that are only active under the `code` MCP profile. Your plugin `.mcp.json` must include:
+This skill uses graph tools that are only active under the `code` MCP profile
+(or `full` / `power`). Your plugin `.mcp.json` must include:
 
 ```json
 "env": {
@@ -293,8 +294,21 @@ This skill uses graph tools that are only active under the `code` MCP profile. Y
 }
 ```
 
-Without this, the six graph tools are not registered and will appear as unknown tools. Run `slm status` to confirm the active profile.
+Without this, the six graph tools are not registered and will appear as unknown
+tools. Run `slm status` to confirm the active profile.
+
+**Switching profiles at runtime (v3.8.0+):** Use `switch_profile("code")` via
+MCP to activate the code profile in a session that started with a different
+profile. See `slm-profile` for the full profile switching workflow.
+
+---
+
+## Related skills
+
+- `slm-profile` — workspace isolation and profile switching (required for code tools)
+- `slm-recall` — retrieve architectural decisions before graph queries
+- `slm-status` — confirm the active profile and graph index health
 
 ---
 
-SuperLocalMemory v3.6.18 · Qualixar · AGPL-3.0-or-later
+SuperLocalMemory v3.8.0 · Qualixar · AGPL-3.0-or-later