superlocalmemory 4.1.22 → 4.1.23

package/antigravity-plugin/commands/slm-loop.md

@@ -0,0 +1,33 @@
+---
+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.
+   A command gate (tests, schema, lint) you run yourself; SLM does not execute
+   commands. To wait for a memory another agent will write, use the
+   `slm_loop_run` MCP tool, whose laps persist as queryable SLM memory (tag
+   `loop:<name>`); inspect runs with `slm loop history` and
+   `slm loop show <run_id>`. `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/antigravity-plugin/hooks/hooks.json

@@ -0,0 +1,59 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "slm hook mandate 2>/dev/null || true",
+            "timeout": 5
+          }
+        ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "slm hook start 2>/dev/null || true",
+            "timeout": 15
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "WebSearch|WebFetch",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "slm hook before_web 2>/dev/null || true",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "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": 5
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "slm hook stop_outcome 2>/dev/null || true",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/antigravity-plugin/hooks.json

@@ -0,0 +1,42 @@
+{
+  "slm-lifecycle": {
+    "PreInvocation": [
+      {
+        "type": "command",
+        "command": "python3 ./scripts/antigravity_hook_adapter.py pre-invocation",
+        "timeout": 15
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "web_search|web_fetch",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ./scripts/antigravity_hook_adapter.py pre-tool",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "view_file|write_to_file|replace_file_content|run_command|search_files|web_fetch|web_search|invoke_subagent|generate_image",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ./scripts/antigravity_hook_adapter.py post-tool",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "type": "command",
+        "command": "python3 ./scripts/antigravity_hook_adapter.py stop",
+        "timeout": 10
+      }
+    ]
+  }
+}

package/antigravity-plugin/mcp_config.json

@@ -0,0 +1,14 @@
+{
+  "mcpServers": {
+    "superlocalmemory": {
+      "command": "slm",
+      "args": [
+        "mcp"
+      ],
+      "env": {
+        "SLM_AGENT_ID": "antigravity",
+        "SLM_MCP_PROFILE": "power"
+      }
+    }
+  }
+}

package/antigravity-plugin/plugin.json

@@ -0,0 +1,25 @@
+{
+  "name": "superlocalmemory",
+  "version": "4.1.23",
+  "description": "Local-first agent memory with auditable hybrid retrieval. Remember decisions and recall them by asking, entirely on your machine.",
+  "author": {
+    "name": "Qualixar",
+    "email": "varun.pratap.bhardwaj@gmail.com",
+    "url": "https://github.com/qualixar"
+  },
+  "homepage": "https://qualixar.com",
+  "repository": "https://github.com/qualixar/superlocalmemory",
+  "license": "AGPL-3.0-or-later",
+  "keywords": [
+    "memory",
+    "mcp",
+    "agents",
+    "local-first",
+    "context-compression"
+  ],
+  "skills": "./skills/",
+  "agents": "./agents/",
+  "commands": "./commands/",
+  "hooks": "./hooks/hooks.json",
+  "mcpServers": "./mcp_config.json"
+}

package/antigravity-plugin/scripts/antigravity_hook_adapter.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+import json
+import hashlib
+import os
+import subprocess
+import sys
+import tempfile
+
+
+def payload():
+    try:
+        value = json.load(sys.stdin)
+        return value if isinstance(value, dict) else {}
+    except Exception:
+        return {}
+
+
+def slm(action, data):
+    workspace_paths = data.get("workspacePaths")
+    env = dict(os.environ)
+    if isinstance(workspace_paths, list) and workspace_paths and isinstance(workspace_paths[0], str):
+        env["CLAUDE_PROJECT_DIR"] = workspace_paths[0]
+    try:
+        result = subprocess.run(
+            ["slm", "hook", action], input=json.dumps(data), text=True,
+            capture_output=True, timeout=8, env=env,
+        )
+        return result.stdout.strip()
+    except Exception:
+        return ""
+
+
+def lifecycle_marker(data):
+    conversation_id = data.get("conversationId")
+    if not isinstance(conversation_id, str) or not conversation_id:
+        return None
+    digest = hashlib.sha256(conversation_id.encode("utf-8")).hexdigest()[:16]
+    return os.path.join(tempfile.gettempdir(), "slm-antigravity-" + digest)
+
+
+def main():
+    event = sys.argv[1] if len(sys.argv) == 2 else ""
+    data = payload()
+    if event == "pre-invocation":
+        marker = lifecycle_marker(data)
+        if marker and os.path.exists(marker):
+            print(json.dumps({"injectSteps": []}))
+            return
+        context = "\n\n".join(part for part in (slm("mandate", data), slm("start", data)) if part)
+        if marker:
+            try:
+                with open(marker, "x", encoding="utf-8"):
+                    pass
+            except FileExistsError:
+                print(json.dumps({"injectSteps": []}))
+                return
+        print(json.dumps({"injectSteps": [{"ephemeralMessage": context}]} if context else {"injectSteps": []}))
+    elif event == "pre-tool":
+        tool_call = data.get("toolCall") if isinstance(data.get("toolCall"), dict) else {}
+        slm("before_web", {"tool_input": tool_call.get("args", {})})
+        print(json.dumps({"decision": "allow"}))
+    elif event == "post-tool":
+        tool_call = data.get("toolCall") if isinstance(data.get("toolCall"), dict) else {}
+        slm("post_tool_outcome", {
+            "tool_name": tool_call.get("name", ""),
+            "tool_input": tool_call.get("args", {}),
+            "tool_response": data.get("toolResponse", data.get("error", "")),
+        })
+        print("{}")
+    elif event == "stop":
+        slm("stop", data)
+        slm("stop_outcome", data)
+        marker = lifecycle_marker(data)
+        if marker:
+            try:
+                os.remove(marker)
+            except OSError:
+                pass
+        print(json.dumps({"decision": "allow"}))
+    else:
+        print("{}")
+
+
+if __name__ == "__main__":
+    main()

package/antigravity-plugin/skills/slm-bot-memory/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: slm-bot-memory
+description: Cross-bot memory on a shared computer (Grok Bot, Cursor plugin, any host where several agents share one machine). Explains agent_id attribution vs. profile/scope access, how to namespace by agent_id + profile + scope, and what must never be written to memory. Read this before the first remember/recall on a new Grok-Bot-style host.
+when_to_use: |
+  - First session on a Grok Bot computer or any shared-bot host
+  - "Will my other bots see this memory?"
+  - "How do I keep this bot's notes separate from that one?"
+  - Deciding whether to store something that looks like a secret or personal data
+  - Setting up a second bot on a computer that already has SLM configured
+allowed-tools: remember, recall, search, session_init, switch_profile
+---
+
+# slm-bot-memory — Cross-Bot Memory on a Shared Host
+
+SuperLocalMemory ships as an MCP server. On a single-user laptop, one bot is
+the only thing talking to it. On a **shared-bot host** — Grok Bot's "one
+computer, shared by all your Bots" model, several Cursor windows, or any
+setup where more than one agent process points at the same install — several
+agents can reach the same memory store at once. This skill is about that
+case: what is actually isolated, what is not, and what must never be written
+regardless.
+
+---
+
+## Three things that sound like isolation and are not the same
+
+| Setting | What it controls | Does it hide memories from another bot? |
+|---|---|---|
+| `SLM_AGENT_ID` | **Attribution** — who gets credit for a memory in logs and summaries | **No.** It is metadata, never an authenticated principal (verified in `mcp/agent_context.py`'s own docstring). Any bot that can query the same store can read a memory written under a different `agent_id`. |
+| `SLM_DATA_DIR` (profile root) | **Which database file** the daemon opens | **Yes.** Two bots pointed at different `SLM_DATA_DIR` values have fully separate, independent memory stores — nothing is shared unless you explicitly configure sharing. |
+| `scope` (`personal` / `shared` / `global`, see `slm-scope`) | **Visibility inside one store**, between profiles that share that store | Only the way you set it. `personal` (the default) stays within the writing profile; `shared`/`global` are explicit, user-initiated opt-ins. |
+
+A memory profile (the namespace `profile_id` and `switch_profile` select) is not
+a fourth kind of isolation between bots. Any local caller that can name a profile
+can read it, and `switch_profile` moves the active profile for every bot on the
+computer. Treat profiles as organisation, not privacy.
+
+The practical rule: **`SLM_AGENT_ID` tells you who wrote something; `SLM_DATA_DIR`
+and `scope` decide who can read it.** If two bots on the same Grok Bot computer
+use the same `SLM_DATA_DIR` (the common case — it is a shared filesystem, and
+nothing in Grok Bot's plugin model points different bots at different data
+directories by default), they see each other's `personal`-scope memories too,
+the same way two terminal sessions on one laptop would. Giving two bots
+different `SLM_AGENT_ID` values does not change that — it only changes whose
+name shows up on the memory.
+
+If you need one bot's memories genuinely unreachable from another, that bot
+needs its **own `SLM_DATA_DIR`** (or a store where company mode with roles is
+configured — see `slm-governance`), not just its own `SLM_AGENT_ID` or its own
+profile.
+
+---
+
+## Namespacing that actually works
+
+Use all three dimensions together, each for what it is good at:
+
+1. **`agent_id`** (`SLM_AGENT_ID` env, or the `agent_id` parameter on
+   `remember`/`recall` directly) — so a human or another agent reading
+   `get_memory_summary` or the stored facts later can tell which bot said
+   what. Set it to something stable and specific: `grok_bot_support`,
+   `grok_bot_release_notes`, not a generic `bot`.
+2. **`SLM_DATA_DIR`** — the real isolation boundary. One store per bot that
+   genuinely needs privacy from the others. A `profile_id` inside a shared store
+   groups memories but does not hide them.
+3. **`scope`** (see `slm-scope`) — inside a store two or more bots
+   legitimately share, keep writes `personal` by default and only promote to
+   `shared`/`global` when a fact is meant for every bot on that store.
+
+```
+remember(
+  content="Deploy window for the support bot is Tue/Thu 14:00-16:00 UTC",
+  tags="ops,schedule",
+  agent_id="grok_bot_support",
+  session_id="<sid>",
+)
+```
+
+```
+recall(
+  query="deploy window",
+  agent_id="grok_bot_support",
+  session_id="<sid>",
+)
+```
+
+Recall is not filtered by `agent_id` automatically — it is attribution on the
+written record. If you need "only what this bot wrote", pass
+`saved_by="grok_bot_support"` to `recall` (or `--saved-by` on `slm recall`),
+which keeps only memories saved by that agent id. It filters; it does not
+protect, because another bot can leave it out.
+
+---
+
+## What never goes into memory, on any host
+
+This is not Grok-Bot-specific — it is the baseline for every SLM host — but
+it matters more here because a shared computer means a shared blast radius if
+it is violated:
+
+- **Secrets, API keys, tokens, passwords, certificates.** Never pass them to
+  `remember`, even "just this once" or "temporarily." If a fact needs to
+  reference that a credential exists, store the *fact of its existence and
+  where to rotate it*, never the value.
+- **Personal data about identifiable people** that was not already something
+  the user explicitly asked to be remembered about themselves (names,
+  emails, addresses, health, financial details of third parties).
+- **Anything from Grok Bot's shared filesystem you did not write yourself**
+  and were not asked to remember. "Files are visible to every Bot" on that
+  computer (Grok Bot's own docs) — a file being readable is not the same as
+  having permission to copy its contents into long-term memory that other
+  bots and later sessions will see.
+- **Command-line credentials.** Grok Bot's own docs note these are shared
+  across bots on the computer; SLM must not become a second, more durable
+  copy of them.
+
+If you are unsure whether something is a secret, treat it as one and ask the
+user before storing anything derived from it.
+
+---
+
+## Checklist for a new bot on an existing shared host
+
+1. Confirm `SLM_DATA_DIR` — is this bot meant to share the existing store, or
+   does it need its own? (`slm status --json` on the computer shows `data.base_dir`
+   and `data.db_path`.)
+2. Set a specific `SLM_AGENT_ID` for this bot before the first `remember`.
+3. Read `slm-scope` before writing anything with `scope="shared"` or
+   `scope="global"` — those are machine-wide, not just cross-bot.
+4. Read the "never goes into memory" list above once, out loud if you are
+   unsure, before the first write on this host.
+
+---
+
+## Related skills
+
+- `slm-getting-started-bot` — first-session setup for a headless bot host
+- `slm-scope` — the personal/shared/global visibility model this skill
+  namespaces on top of
+- `slm-profile` — memory profiles versus tool sets, and what switching does
+- `slm-governance` — role-based access when a store has multiple human/bot
+  members and real access control, not just convention
+
+---
+
+*SuperLocalMemory v4.1.23 · Qualixar · AGPL-3.0-or-later*

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

@@ -0,0 +1,147 @@
+---
+name: slm-cache
+description: KV cache for repeated reads — call slm_cache_get(key) first; on a miss do the expensive operation then slm_cache_set(key, value, ttl_seconds) to store it; on a hit use the returned value directly; always fail-open (hit:false on any error, never raises); saves tokens when the same file, query result, or tool output is read more than once in a session.
+when_to_use: "cache file, avoid re-reading, repeated read, cache result, cache tool output, save re-read, reuse across session, cache check, cache hit, cache miss"
+allowed-tools: slm_cache_set, slm_cache_get, Bash
+---
+
+# slm-cache — KV Cache for Repeated Reads (Surface B)
+
+## Purpose
+
+When the same file, query result, or expensive tool output is needed more than once in a session, fetching it again wastes tokens and time. `slm_cache_set` stores a result under a stable key; `slm_cache_get` retrieves it on subsequent calls. The cache is agent-scoped (automatically namespaced by tenant/agent ID), TTL-bounded, and fail-open.
+
+This is an agent-routed cache — it caches results the agent explicitly routes through SLM. It cannot cache Claude conversation turns.
+
+## Tool: slm_cache_set
+
+```
+slm_cache_set(
+    key:          str,          # required — cache key (max 512 chars)
+    value:        str,          # required — value to store (max 1 MB)
+    ttl_seconds:  int = 86400,  # time-to-live in seconds (default 24 h)
+) -> dict
+```
+
+### Return dict
+
+| Key | Type | Meaning |
+|-----|------|---------|
+| `ok` | bool | `True` on success; `False` on validation error or internal error |
+| `stored` | bool | `True` when the value was written to the cache |
+| `note` | str \| None | Error detail or `None` on success |
+
+Keys are SHA-256-hashed internally per agent so they do not collide across agents. The raw key string you supply is the only handle you need. The namespace is the calling agent (`SLM_AGENT_ID`, or the `/mcp/<agent>` path), not the memory profile, so switching profiles does not give you a fresh cache. A caller on another computer gets its own namespace, keyed by its access key, and can never see a local agent's entries.
+
+## Tool: slm_cache_get
+
+```
+slm_cache_get(
+    key: str,   # required — same key used in slm_cache_set
+) -> dict
+```
+
+### Return dict
+
+| Key | Type | Meaning |
+|-----|------|---------|
+| `ok` | bool | `True` on clean execution (including miss); `False` on internal error |
+| `hit` | bool | `True` when the key exists and has not expired |
+| `value` | str \| None | The stored value on a hit; `None` on miss |
+| `note` | str \| None | Error detail or `None` |
+
+`value` is the string you stored. A miss returns `{"ok": true, "hit": false, "value": null, "note": null}`. `ok: false` means something went wrong internally but the miss behaviour is the same — treat both as a cache miss and proceed with the real fetch.
+
+## Standard Pattern: Cache-Aside
+
+Always check the cache first, then fill on miss:
+
+```python
+# 1. Check cache
+cached = await slm_cache_get(key="file:/absolute/path/to/config.json")
+
+if cached["hit"]:
+    content = cached["value"]
+else:
+    # 2. Expensive operation (file read, search, API call)
+    content = read_file("/absolute/path/to/config.json")
+
+    # 3. Store for the rest of the session
+    await slm_cache_set(
+        key="file:/absolute/path/to/config.json",
+        value=content,
+        ttl_seconds=3600,   # 1 h — adjust to data volatility
+    )
+
+# 4. Use content
+```
+
+## Key Naming Convention
+
+Use a stable, human-readable prefix so keys are recognisable in stats and won't collide accidentally:
+
+| Content type | Suggested prefix | Example |
+|---|---|---|
+| File read | `file:` | `file:/repo/src/config.py` |
+| Search result | `search:` | `search:recall:session_init_context` |
+| Tool output | `tool:` | `tool:build_code_graph:/repo` |
+| External fetch | `url:` | `url:https://api.example.com/v1/data` |
+
+Key length cap: 512 characters. Keys longer than that are rejected (`ok: false`).
+
+## When Caching Pays Off
+
+**Cache when:**
+- You will read the same file more than once in a session.
+- A search or recall result is reused across multiple reasoning steps.
+- An expensive MCP tool call (graph build, semantic search) produces output that is stable for the session duration.
+
+**Do NOT cache:**
+- Volatile data (live API responses that change minute-to-minute, current timestamps, streaming output).
+- Secrets, credentials, tokens, or `ccr_id` values (CCR already handles its own storage).
+- Data that must be fresh for correctness — a stale cache is worse than a cache miss.
+- Intermediate scratchpad text you will discard.
+
+## Fail-Open Guarantee
+
+Neither tool raises an exception. On any internal error:
+
+- `slm_cache_get` returns `{"ok": false, "hit": false, "value": null, ...}` — treat as a miss and proceed with the real fetch.
+- `slm_cache_set` returns `{"ok": false, "stored": false, ...}` — log the note if useful, but continue; the value is still available in memory this step.
+
+Never block a task on a cache failure.
+
+## TTL Guidance
+
+| Data type | Suggested TTL |
+|---|---|
+| Static config / generated file | 86400 s (24 h — the default) |
+| Session-specific tool output | 3600 s (1 h) |
+| Rapidly changing API data | Do not cache, or 60–300 s |
+
+Set `ttl_seconds` to match how long the data remains valid. After expiry `slm_cache_get` returns a miss automatically.
+
+## Secondary CLI (fallback when MCP is unavailable)
+
+Prefer the MCP tools above. If you must use the command line:
+
+```bash
+slm cache status [--json] [--tenant default]
+slm cache clear [--json] [--tenant default]
+slm cache invalidate --tag <tag> [--json] [--tenant default]
+slm cache ttl --set <seconds> [--semantic <seconds>] [--json] [--tenant default]
+slm cache semantic on|off [--json] [--tenant default]
+```
+
+These subcommands control daemon-level cache settings and bulk removal. They do not read or write individual entries — use the MCP tools for that. Entries written by `slm_cache_set` carry the tag `mcp-kv`, so `slm cache invalidate --tag mcp-kv` removes them, and `slm cache clear` deletes every entry for the tenant.
+
+---
+
+## Related skills
+
+- `slm-compress` — for large content reduction; cache and compress work together
+- `slm-status` — view `cache_kv_hits`/`cache_kv_misses` counters (daemon-persisted totals) from `slm_optimize_stats`
+
+---
+
+SuperLocalMemory v4.1.23 · Qualixar · AGPL-3.0-or-later