superlocalmemory 3.8.0 → 3.8.2

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

@@ -1,71 +0,0 @@
----
-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-src/agents/slm-memory-advisor.md

@@ -1,49 +0,0 @@
----
-name: slm-memory-advisor
-description: >
-  Advises the main agent on using SuperLocalMemory well — when to call
-  session_init, remember, recall, and search; how to phrase queries; and how
-  to keep memory clean. Delegate here for any "should I save/recall this?"
-  decision or when memory results look wrong.
-tools: session_init, recall, search, remember, update_memory, forget, list_recent, Read
-model: inherit
----
-
-# Role
-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; 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 + 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.
-- `forget(profile_id, dry_run)` — decay cycle; ALWAYS dry_run=True first, report, never apply blind.
-- `list_recent(limit)` — newest first.
-- `Read` — inspect a file before deciding what to remember.
-
-# Decision rules
-1. SESSION_INIT FIRST — once, before any recall/remember in a fresh session. Never skip; never twice.
-2. RECALL BEFORE REMEMBER — if it exists, update_memory instead of duplicating.
-3. REMEMBER ATOMIC DURABLE FACTS ONLY — decisions/conventions/constraints/gotchas/stable prefs; one per call; add tags+project; importance 7-10 for blockers/security/architecture.
-4. QUERY PHRASING — concept phrases not vague words; pass session_id when available.
-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. 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 bypass scope or governance restrictions.
-
-SuperLocalMemory v3.8.0 · Qualixar · AGPL-3.0-or-later

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

@@ -1,44 +0,0 @@
----
-name: slm-optimize-advisor
-description: >
-  Applies SuperLocalMemory's context-optimization rules — reversible
-  compression of large tool output and KV-caching of repeated reads/searches —
-  to stretch the context window with no proxy. Delegate here when context is
-  filling up or the same files/searches are read repeatedly. Strictly advisory
-  and fail-open: optimization must never block the primary task.
-tools: slm_compress, slm_retrieve, slm_cache_set, slm_cache_get, slm_optimize_stats, Read, Bash
-model: inherit
----
-
-# Role
-You are the SLM optimize advisor. You reduce context-window pressure using Surface-B tools: reversible compression (CCR) and a per-agent KV cache. No proxy; full 1M window preserved on any plan. You apply the same rules as the slm-compress and slm-cache skills. You cannot cache the primary Claude turn (needs a proxy) — only content the agent routes through SLM.
-
-# 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, 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)
-1. CLAUDE.md >3000 chars → slm_compress(mode="normalize", reversible=False), use compressed IN CONTEXT ONLY; never modify the file.
-2. Tool output >2000 chars → slm_compress(mode="auto", reversible=True); work from compressed; keep ccr_id if lossy.
-3. Repeated file reads → slm_cache_get("file:<path>") first; on miss Read then slm_cache_set("file:<path>", ttl 1800); invalidate on Edit/Write.
-4. Repeated bash/web → slm_cache_set("bash:<cmd[:64]>", ttl 600); web ttl 3600.
-5. Retrieve original only when byte-identical needed.
-6. NEVER compress/cache: code for Edit/Write; JSON to parse; secrets/keys/tokens; ccr_ids; <500 chars.
-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 carry ccr_ids across profile switches.
-
-SuperLocalMemory v3.8.0 · Qualixar · AGPL-3.0-or-later

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

@@ -1,31 +0,0 @@
----
-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-src/hooks/hooks.json

@@ -1,102 +0,0 @@
-{
-  "hooks": {
-    "SessionStart": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "slm hook mandate 2>/dev/null || true",
-            "timeout": 5000
-          }
-        ]
-      },
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "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-src/manifest.json

@@ -1,30 +0,0 @@
-{
-  "version": "3.8.0",
-  "pluginName": "superlocalmemory",
-  "displayName": "SuperLocalMemory",
-  "repository": "https://github.com/qualixar/superlocalmemory",
-  "keywords": ["memory", "mcp", "agents", "local-first", "context-compression"],
-  "skills": [
-    { "name": "slm-cache", "hasReadme": false },
-    { "name": "slm-compress", "hasReadme": false },
-    { "name": "slm-governance", "hasReadme": false },
-    { "name": "slm-graph", "hasReadme": false },
-    { "name": "slm-loop", "hasReadme": false },
-    { "name": "slm-mesh", "hasReadme": false },
-    { "name": "slm-profile", "hasReadme": false },
-    { "name": "slm-recall", "hasReadme": false },
-    { "name": "slm-remember", "hasReadme": false },
-    { "name": "slm-scope", "hasReadme": false },
-    { "name": "slm-session", "hasReadme": false },
-    { "name": "slm-status", "hasReadme": false }
-  ],
-  "targets": {
-    "plugin": "plugin/.claude-plugin/plugin.json"
-  },
-  "marketplace": {
-    "owner": "qualixar",
-    "ownerEmail": "varun.pratap.bhardwaj@gmail.com",
-    "repo": "superlocalmemory",
-    "description": "Local-first agent memory + reversible context compression and KV cache, as an MCP server. 21-tool code profile with graph intelligence."
-  }
-}

package/plugin-src/requirements.txt

@@ -1 +0,0 @@
-superlocalmemory==3.8.0

package/plugin-src/rules/CLAUDE.md.fragment

@@ -1,44 +0,0 @@
-<!-- BEGIN SuperLocalMemory v3.8.0 -->
-
-## SuperLocalMemory (SLM) — Agent Rules
-
-SLM is local-first memory for agents. All tools run on the user's machine; no cloud calls.
-
-### Session start
-Call `session_init(project_path, query)` ONCE per fresh session before any recall/remember. Never twice.
-
-### Remember
-- Atomic durable facts only (decisions, conventions, constraints, gotchas). One fact per call.
-- Recall-before-remember: `recall(query, 5)` first; use `update_memory` if near-match found.
-- Always supply tags + project + importance (7–10 for blockers/security/architecture).
-- Never dump a whole file; never claim "saved" without success:true.
-- Scope is opt-in (v3.6.15): writes are `personal`/private by default. Only use `scope="shared"/"global"` (or recall's `include_global`/`include_shared`) when the user explicitly asks to share across local profiles.
-
-### Recall
-- `recall` for conceptual/semantic queries; `search` for exact keywords.
-- Phrase as concepts; pass session_id when available. Never fabricate.
-
-### Optimize (fail-open)
-- Output >2000 chars → `slm_compress(mode="auto", reversible=True)`; keep ccr_id if lossy.
-- Repeated reads → `slm_cache_get("file:<path>")` first; on miss cache with ttl=1800.
-- 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.
-
-### CLI fallback (MCP down)
-`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 · slm-loop · slm-scope · slm-profile · slm-governance · slm-mesh
-
-### Subagents
-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.8.0 -->
-
-SuperLocalMemory v3.8.0 · Qualixar · AGPL-3.0-or-later

package/plugin-src/scripts/ensure-venv.bat

@@ -1,122 +0,0 @@
-@echo off
-:: ensure-venv.bat — WP-F SuperLocalMemory plugin venv bootstrap (Windows)
-::
-:: Windows equivalent of ensure-venv.sh. Called by Claude Code SessionStart hook
-:: on Windows hosts. Idempotent: fast-path exits quickly when requirements.txt
-:: is unchanged (sentinel file guards reinstall).
-::
-:: 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   non-0 = failure (logged to stderr)
-:: All informational output goes to stderr (stdout reserved for MCP stdio protocol).
-::
-:: Requires: Python 3.11+ on PATH, pip, standard Windows cmd.exe
-
-setlocal EnableDelayedExpansion
-
-:: ---------------------------------------------------------------------------
-:: Guard: required env vars must be set
-:: ---------------------------------------------------------------------------
-if not defined CLAUDE_PLUGIN_ROOT (
-    echo ERROR: CLAUDE_PLUGIN_ROOT must be set ^(plugin installation directory^) >&2
-    exit /b 1
-)
-if not defined CLAUDE_PLUGIN_DATA (
-    echo ERROR: CLAUDE_PLUGIN_DATA must be set ^(plugin persistent data directory^) >&2
-    exit /b 1
-)
-
-:: ---------------------------------------------------------------------------
-:: Python >= 3.11 guard
-:: ---------------------------------------------------------------------------
-python -c "import sys; sys.exit(0 if sys.version_info >= (3, 11) else 1)" 2>nul
-if errorlevel 1 (
-    for /f "tokens=*" %%v in ('python --version 2^>^&1') do set PY_VER=%%v
-    echo ERROR: SuperLocalMemory plugin requires Python ^>= 3.11, found: !PY_VER! >&2
-    echo Install Python 3.11+ and ensure it is first on PATH. >&2
-    exit /b 1
-)
-
-:: ---------------------------------------------------------------------------
-:: Paths
-:: ---------------------------------------------------------------------------
-set "REQ=%CLAUDE_PLUGIN_ROOT%\requirements.txt"
-set "VENV=%CLAUDE_PLUGIN_DATA%\venv"
-set "VENV_SCRIPTS=%VENV%\Scripts"
-set "SENTINEL=%CLAUDE_PLUGIN_DATA%\.venv-reqs.sha256"
-set "VENV_TMP=%CLAUDE_PLUGIN_DATA%\venv.tmp"
-
-:: ---------------------------------------------------------------------------
-:: Compute sha256 of requirements.txt using PowerShell (built-in on Windows 10+)
-:: Output: hex string of SHA256 hash
-:: ---------------------------------------------------------------------------
-for /f "usebackq tokens=*" %%h in (
-    `powershell -NoProfile -Command "(Get-FileHash -Algorithm SHA256 '%REQ%').Hash.ToLower()"`
-) do set "NEW_HASH=%%h"
-
-if "!NEW_HASH!"=="" (
-    echo ERROR: Could not compute sha256 of requirements.txt >&2
-    exit /b 1
-)
-
-:: ---------------------------------------------------------------------------
-:: Fast-path: venv Scripts\python.exe exists AND sentinel matches
-:: ---------------------------------------------------------------------------
-set "VENV_PYTHON=%VENV_SCRIPTS%\python.exe"
-if exist "%VENV_PYTHON%" (
-    if exist "%SENTINEL%" (
-        set /p "CURRENT_HASH=" < "%SENTINEL%"
-        if "!CURRENT_HASH!"=="!NEW_HASH!" (
-            echo SLM plugin: venv up-to-date, skipping install. >&2
-            exit /b 0
-        )
-    )
-)
-
-:: ---------------------------------------------------------------------------
-:: 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
-
-:: Clean up any partial previous attempt
-if exist "%VENV_TMP%" rmdir /s /q "%VENV_TMP%"
-
-:: Create fresh venv
-python -m venv "%VENV_TMP%"
-if errorlevel 1 (
-    echo ERROR: python -m venv failed >&2
-    exit /b 1
-)
-
-:: Upgrade pip first
-"%VENV_TMP%\Scripts\pip.exe" install --upgrade pip --prefer-binary --quiet
-if errorlevel 1 (
-    echo ERROR: pip upgrade failed >&2
-    exit /b 1
-)
-
-:: Install requirements
-"%VENV_TMP%\Scripts\pip.exe" install --require-virtualenv --prefer-binary --quiet -r "%REQ%"
-if errorlevel 1 (
-    echo ERROR: pip install requirements failed >&2
-    exit /b 1
-)
-
-echo SLM plugin: install complete, activating venv. >&2
-
-:: Atomic swap: remove old venv (if any), rename tmp into place
-if exist "%VENV%" rmdir /s /q "%VENV%"
-move "%VENV_TMP%" "%VENV%"
-if errorlevel 1 (
-    echo ERROR: Could not move venv.tmp to venv >&2
-    exit /b 1
-)
-
-:: Write sentinel LAST — guarantees that a crash before this line triggers rebuild
-echo !NEW_HASH!>"%SENTINEL%"
-
-echo SLM plugin: venv ready at %VENV%\Scripts\slm.exe >&2
-exit /b 0

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

@@ -1,105 +0,0 @@
-#!/usr/bin/env bash
-# ensure-venv.sh — WP-06 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   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
-
-# ---------------------------------------------------------------------------
-# Python >= 3.11 guard
-# ---------------------------------------------------------------------------
-if ! python3 -c "import sys; sys.exit(0 if sys.version_info >= (3, 11) else 1)" 2>/dev/null; then
-    PY_VER=$(python3 --version 2>&1 || echo "unknown")
-    echo "ERROR: SuperLocalMemory plugin requires Python >= 3.11, found: ${PY_VER}" >&2
-    echo "Install Python 3.11+ and ensure it is first on PATH." >&2
-    exit 1
-fi
-
-# ---------------------------------------------------------------------------
-# Paths
-# ---------------------------------------------------------------------------
-REQ="${CLAUDE_PLUGIN_ROOT}/requirements.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 (cross-platform: prefer sha256sum, fall back to shasum -a 256)
-# ---------------------------------------------------------------------------
-hash_req() {
-    if command -v sha256sum >/dev/null 2>&1; then
-        sha256sum "${REQ}" | awk '{print $1}'
-    else
-        shasum -a 256 "${REQ}" | 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
-
-# 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