opencode-semantic-memory 0.8.0__tar.gz → 0.8.3__tar.gz

{opencode_semantic_memory-0.8.0 → opencode_semantic_memory-0.8.3}/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.3] - 2026-06-03
+
+### Fixed
+
+- **Concurrent subagent MCP connections** - Background tasks that spawned multiple
+  subagents at once could fail silently with `MCP error -32000: Connection closed`
+  when their `mcp-remote` clients all performed their startup handshake against the
+  shared HTTP server simultaneously. Two fixes:
+  - `scripts/memory-mcp.sh` now retries `mcp-remote` with exponential backoff
+    (up to 5 attempts) so a transient startup-time connection drop recovers instead
+    of leaving the subagent without memory access.
+  - The HTTP server's rate limiter now exempts loopback addresses (all local
+    sessions are trusted) and keys non-local clients by the `X-OpenCode-Session`
+    header, so concurrent sessions no longer share a single localhost bucket whose
+    limit a startup burst could trip.
+
 ## [0.8.0] - 2026-06-02
 
 ### Added

{opencode_semantic_memory-0.8.0 → opencode_semantic_memory-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-semantic-memory
-Version: 0.8.0
+Version: 0.8.3
 Summary: Persistent semantic memory system for OpenCode sessions
 Author-email: Gregory Havenga <ghavenga@gitlab.com>
 License-Expression: MIT
@@ -172,6 +172,41 @@ args = ["--prompt"]  # prompt is appended after these args
 
 **Note:** The proactive context injection feature (automatic memory loading) currently only works with OpenCode via the plugin system. Other LLM providers can still use all memory tools manually.
 
+## Updating
+
+To update an existing installation, re-run the quick install script. It is idempotent and will pull the latest code, refresh dependencies, and restart the background services:
+
+```bash
+curl -fsSL https://gitlab.com/ghavenga/opencode-memory/-/raw/master/scripts/setup.sh | bash
+```
+
+The update is **non-destructive** for your data:
+
+- Your memory database at `~/.local/share/opencode-memory/memory.db` is not touched
+- Your vector store at `~/.local/share/opencode-memory/vectors/` is not touched
+- Your existing `~/.config/opencode-memory/config.toml` is preserved (the script only writes a default if one does not already exist)
+
+The script's `rm -rf` operations are scoped to the install directory (`~/.local/share/opencode-memory-install`) and only trigger when the git checkout or virtual environment is in a broken state. Any uncommitted local changes inside the install directory will be discarded (`git reset --hard` + `git clean -fd`) before the pull.
+
+If you want to be extra cautious before a major update, snapshot the data directory first:
+
+```bash
+# Consistent SQLite backup (handles WAL files correctly)
+TS=$(date +%Y%m%d-%H%M%S)
+BACKUP_DIR="$HOME/.local/share/opencode-memory-backups/$TS"
+mkdir -p "$BACKUP_DIR"
+sqlite3 "$HOME/.local/share/opencode-memory/memory.db" ".backup '$BACKUP_DIR/memory.db'"
+cp -R "$HOME/.local/share/opencode-memory/vectors" "$BACKUP_DIR/vectors"
+cp "$HOME/.config/opencode-memory/config.toml" "$BACKUP_DIR/config.toml"
+```
+
+After the update, verify the service is healthy:
+
+```bash
+curl -s http://127.0.0.1:9824/health
+# {"status":"ok","server":"opencode-memory","daemon":{"running":true}}
+```
+
 ## Quick Start
 
 ### 1. Start the Memory Services
@@ -263,6 +298,10 @@ The setup script automatically builds and configures the plugin if Node.js 20+ i
 3. Context is injected into the system prompt before LLM call
 4. AI sees relevant history automatically
 
+**Thinking-aware injection:** The plugin also analyzes the assistant's responses to inject context mid-conversation. If the AI is "thinking" about a topic it has prior knowledge of, relevant memories are injected before the next LLM call.
+
+**Relevance filtering:** Items with semantic similarity below 0.35 are filtered out to reduce noise. This threshold was tuned based on effectiveness analysis showing low-relevance items had 0% actual usefulness.
+
 **Note:** If you're using a different LLM provider (Claude, Duo, Ollama), you'll need to call memory tools explicitly - proactive injection only works with the OpenCode plugin.
 
 For more details, see the [plugin documentation](plugin/README.md).
@@ -412,7 +451,8 @@ Work item queue for tracking todos, MRs to review, and authored MRs. Supports P0
 
 | Tool | Description |
 |------|-------------|
-| `memory_effectiveness_report(days?)` | Memory usage patterns and suggestions |
+| `memory_effectiveness_report(days?)` | Memory usage patterns, injection effectiveness, and suggestions |
+| `memory_injection_metrics_trend(days?)` | Daily injection metrics over time for tracking improvements |
 | `memory_background_report(days?)` | Background process activity |
 | `memory_tool_metrics(action?, since_hours?)` | MCP tool call timing metrics |
 | `memory_vector_index(action?)` | Manage vector search index |

{opencode_semantic_memory-0.8.0 → opencode_semantic_memory-0.8.3}/README.md

@@ -137,6 +137,41 @@ args = ["--prompt"]  # prompt is appended after these args
 
 **Note:** The proactive context injection feature (automatic memory loading) currently only works with OpenCode via the plugin system. Other LLM providers can still use all memory tools manually.
 
+## Updating
+
+To update an existing installation, re-run the quick install script. It is idempotent and will pull the latest code, refresh dependencies, and restart the background services:
+
+```bash
+curl -fsSL https://gitlab.com/ghavenga/opencode-memory/-/raw/master/scripts/setup.sh | bash
+```
+
+The update is **non-destructive** for your data:
+
+- Your memory database at `~/.local/share/opencode-memory/memory.db` is not touched
+- Your vector store at `~/.local/share/opencode-memory/vectors/` is not touched
+- Your existing `~/.config/opencode-memory/config.toml` is preserved (the script only writes a default if one does not already exist)
+
+The script's `rm -rf` operations are scoped to the install directory (`~/.local/share/opencode-memory-install`) and only trigger when the git checkout or virtual environment is in a broken state. Any uncommitted local changes inside the install directory will be discarded (`git reset --hard` + `git clean -fd`) before the pull.
+
+If you want to be extra cautious before a major update, snapshot the data directory first:
+
+```bash
+# Consistent SQLite backup (handles WAL files correctly)
+TS=$(date +%Y%m%d-%H%M%S)
+BACKUP_DIR="$HOME/.local/share/opencode-memory-backups/$TS"
+mkdir -p "$BACKUP_DIR"
+sqlite3 "$HOME/.local/share/opencode-memory/memory.db" ".backup '$BACKUP_DIR/memory.db'"
+cp -R "$HOME/.local/share/opencode-memory/vectors" "$BACKUP_DIR/vectors"
+cp "$HOME/.config/opencode-memory/config.toml" "$BACKUP_DIR/config.toml"
+```
+
+After the update, verify the service is healthy:
+
+```bash
+curl -s http://127.0.0.1:9824/health
+# {"status":"ok","server":"opencode-memory","daemon":{"running":true}}
+```
+
 ## Quick Start
 
 ### 1. Start the Memory Services
@@ -228,6 +263,10 @@ The setup script automatically builds and configures the plugin if Node.js 20+ i
 3. Context is injected into the system prompt before LLM call
 4. AI sees relevant history automatically
 
+**Thinking-aware injection:** The plugin also analyzes the assistant's responses to inject context mid-conversation. If the AI is "thinking" about a topic it has prior knowledge of, relevant memories are injected before the next LLM call.
+
+**Relevance filtering:** Items with semantic similarity below 0.35 are filtered out to reduce noise. This threshold was tuned based on effectiveness analysis showing low-relevance items had 0% actual usefulness.
+
 **Note:** If you're using a different LLM provider (Claude, Duo, Ollama), you'll need to call memory tools explicitly - proactive injection only works with the OpenCode plugin.
 
 For more details, see the [plugin documentation](plugin/README.md).
@@ -377,7 +416,8 @@ Work item queue for tracking todos, MRs to review, and authored MRs. Supports P0
 
 | Tool | Description |
 |------|-------------|
-| `memory_effectiveness_report(days?)` | Memory usage patterns and suggestions |
+| `memory_effectiveness_report(days?)` | Memory usage patterns, injection effectiveness, and suggestions |
+| `memory_injection_metrics_trend(days?)` | Daily injection metrics over time for tracking improvements |
 | `memory_background_report(days?)` | Background process activity |
 | `memory_tool_metrics(action?, since_hours?)` | MCP tool call timing metrics |
 | `memory_vector_index(action?)` | Manage vector search index |

{opencode_semantic_memory-0.8.0 → opencode_semantic_memory-0.8.3}/plugin/src/index.ts

@@ -225,6 +225,18 @@ export const server: Plugin = async (input, _options) => {
           for (const item of context.items) {
             sessionIds.add(item.memory_id);
           }
+          
+          // Log user query injection for effectiveness tracking (fire-and-forget)
+          client.logContextEvent({
+            sessionId: sessionID,
+            eventType: 'user_injection',
+            memoryIds: context.items.map((item: { memory_id: number }) => item.memory_id),
+            source: 'user_query',
+            triggerText: userText.slice(0, 500),  // Truncate long queries
+            relevanceScore: context.relevance_summary,
+            query: context.semantic_query,
+            tokens: context.total_tokens,
+          }).catch(() => { /* silent */ });
         }
 
         // Cache proactive context for system.transform hook
@@ -484,6 +496,7 @@ export const server: Plugin = async (input, _options) => {
       // Inject thinking-based context (from semantic analysis of assistant's last response)
       // This enables proactive injection based on what the assistant is thinking about
       const thinkingContext = sessionThinkingContext.get('_last') ?? sessionThinkingContext.get(sessionID);
+      const thinkingTrigger = lastAssistantThinking.get('_last') ?? lastAssistantThinking.get(sessionID);
       if (thinkingContext && thinkingContext.items && thinkingContext.items.length > 0) {
         // Filter out items already injected in this session
         const sessionIds = injectedMemoryIds.get(sessionID) ?? new Set<number>();
@@ -505,11 +518,25 @@ export const server: Plugin = async (input, _options) => {
           for (const item of newItems) {
             updatedSessionIds.add(item.memory_id);
           }
+          
+          // Log the context event for effectiveness tracking (fire-and-forget)
+          client.logContextEvent({
+            sessionId: sessionID,
+            eventType: 'thinking_injection',
+            memoryIds: newItems.map(item => item.memory_id),
+            source: 'thinking',
+            triggerText: thinkingTrigger ?? undefined,
+            relevanceScore: thinkingContext.relevance_summary,
+            query: thinkingContext.semantic_query,
+            tokens: thinkingContext.total_tokens,
+          }).catch(() => { /* silent */ });
         }
         
         // Clear thinking context after injection (one-shot)
         sessionThinkingContext.delete('_last');
         sessionThinkingContext.delete(sessionID);
+        lastAssistantThinking.delete('_last');
+        lastAssistantThinking.delete(sessionID);
       }
     },
   };

{opencode_semantic_memory-0.8.0 → opencode_semantic_memory-0.8.3}/plugin/src/memory-client.ts

@@ -324,6 +324,48 @@ export class MemoryClient {
       clearTimeout(timeoutId);
     }
   }
+
+  /**
+   * Log a context event for effectiveness tracking.
+   * Supports both user-triggered and thinking-triggered injections.
+   */
+  async logContextEvent(params: LogContextEventParams): Promise<void> {
+    // Fire and forget - don't block on logging
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 2000);
+
+    try {
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+      };
+      
+      if (this.apiKey) {
+        headers['Authorization'] = `Bearer ${this.apiKey}`;
+      }
+
+      await fetch(`${this.baseUrl}/context-event`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          session_id: params.sessionId,
+          event_type: params.eventType,
+          memory_ids: params.memoryIds,
+          source: params.source,
+          trigger_text: params.triggerText,
+          relevance_score: params.relevanceScore,
+          query: params.query,
+          turn_number: params.turnNumber,
+          tokens: params.tokens,
+        }),
+        signal: controller.signal,
+      });
+      // Ignore response - fire and forget
+    } catch {
+      // Silent failure - logging shouldn't break the plugin
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
 }
 
 export interface WorkspaceInitResponse {
@@ -351,6 +393,18 @@ export interface LogInjectionParams {
   itemsCount?: number;
 }
 
+export interface LogContextEventParams {
+  sessionId: string;
+  eventType: 'injection' | 'thinking_injection' | 'user_injection' | 'boot' | 'recall';
+  memoryIds: number[];
+  source?: 'user' | 'user_query' | 'thinking' | 'boot' | 'explicit';
+  triggerText?: string;
+  relevanceScore?: string;
+  query?: string;
+  turnNumber?: number;
+  tokens?: number;
+}
+
 export interface BootContextIdsResponse {
   memory_ids: number[];
 }

{opencode_semantic_memory-0.8.0 → opencode_semantic_memory-0.8.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "opencode-semantic-memory"
-version = "0.8.0"
+version = "0.8.3"
 description = "Persistent semantic memory system for OpenCode sessions"
 readme = "README.md"
 license = "MIT"
@@ -52,6 +52,8 @@ opencode-memory = "opencode_memory.cli:main"
 opencode-memory-server = "opencode_memory.http_server:main"
 opencode-memory-daemon = "opencode_memory.daemon:main"
 opencode-memory-worker = "opencode_memory.background_worker:main"
+# New job-based worker (Sidekiq-like)
+opencode-memory-job-worker = "opencode_memory.jobs.worker:main"
 # Bulk ingestion commands
 opencode-memory-bulk-ingest = "opencode_memory.bulk_ingest.cli:main"
 opencode-memory-bulk-ingest-daemon = "opencode_memory.bulk_ingest.daemon:main"

opencode_semantic_memory-0.8.3/scripts/memory-mcp.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+# Wrapper script for opencode-memory MCP server
+# Connects to the HTTP server via mcp-remote
+#
+# Prerequisites:
+#   Linux: systemctl --user enable --now opencode-memory
+#   macOS: launchctl load ~/Library/LaunchAgents/com.opencode.memory.plist
+
+set -e
+
+SERVER_URL="http://localhost:9824"
+
+# Quick health check (fail fast if server not running)
+if ! curl -s --max-time 1 "$SERVER_URL/health" >/dev/null 2>&1; then
+    OS="$(uname -s)"
+    case "$OS" in
+        Linux*)
+            echo "Memory server not running. Start it with: systemctl --user start opencode-memory" >&2
+            ;;
+        Darwin*)
+            echo "Memory server not running. Start it with: launchctl load ~/Library/LaunchAgents/com.opencode.memory.plist" >&2
+            ;;
+        *)
+            echo "Memory server not running at $SERVER_URL" >&2
+            ;;
+    esac
+    exit 1
+fi
+
+# Resolve the mcp-remote command (locally installed is faster than npx)
+if [ -x "$HOME/.local/bin/mcp-remote" ]; then
+    MCP_REMOTE=("$HOME/.local/bin/mcp-remote")
+elif command -v mcp-remote >/dev/null 2>&1; then
+    MCP_REMOTE=(mcp-remote)
+else
+    MCP_REMOTE=(npx --yes mcp-remote)
+fi
+
+# Start mcp-remote with retry/backoff to absorb transient "Connection closed"
+# failures that occur when many subagents start concurrently (thundering herd
+# against the shared HTTP server). A clean long-running proxy never returns 0
+# here, so a fast non-zero exit means a startup-time connection drop worth retrying.
+MAX_ATTEMPTS=5
+attempt=1
+while true; do
+    start_ts=$(date +%s)
+    # Disable errexit around the proxy call; we handle its exit code explicitly.
+    set +e
+    "${MCP_REMOTE[@]}" "$SERVER_URL/mcp"
+    exit_code=$?
+    set -e
+    elapsed=$(( $(date +%s) - start_ts ))
+
+    # Exited cleanly, or ran long enough to be a real session (not a startup
+    # collision): propagate the exit code and stop.
+    if [ "$exit_code" -eq 0 ] || [ "$elapsed" -ge 10 ] || [ "$attempt" -ge "$MAX_ATTEMPTS" ]; then
+        exit "$exit_code"
+    fi
+
+    # Transient startup failure: back off (2s, 4s, 6s, 8s) and retry.
+    backoff=$(( attempt * 2 ))
+    echo "memory-mcp: mcp-remote exited ($exit_code) after ${elapsed}s on attempt ${attempt}; retrying in ${backoff}s" >&2
+    sleep "$backoff"
+    attempt=$(( attempt + 1 ))
+done