gitmem-mcp 1.6.3 → 1.6.5

package/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.6.5] - 2026-06-27
+
+### Fixed
+- **`resolve_thread` can now resolve threads created by other sessions**: `list_threads` reads the Supabase source-of-truth, but `resolve_thread` previously matched only the local/session cache — so a thread created by another session showed up in `list_threads` yet returned "Thread not found" when you tried to resolve it. These "visible-but-unresolvable" threads piled up across sessions. `resolve_thread` now falls back to looking the thread up in Supabase (by ID, or by text for `text_match`) before failing, resolves it in the source-of-truth, and syncs the local cache. (GIT-46)
+
+## [1.6.4] - 2026-06-11
+
+### Fixed
+- **Init wizard upgrades stale configs**: Running `npx gitmem-mcp@latest init` on a project with an existing gitmem config now detects `"gitmem-mcp"` without `@latest` in the args and upgrades it in-place. Previously it skipped with "already configured" and left the stale reference untouched.
+
 ## [1.6.3] - 2026-06-11
 
 ### Fixed

package/bin/init-wizard.js

@@ -555,6 +555,18 @@ async function stepMcpServer() {
   const hasGitmem = existing?.mcpServers?.gitmem || existing?.mcpServers?.["gitmem-mcp"];
 
   if (hasGitmem) {
+    // Check if existing config uses stale "gitmem-mcp" without @latest
+    const entry = existing.mcpServers.gitmem || existing.mcpServers["gitmem-mcp"];
+    const args = entry?.args;
+    if (Array.isArray(args)) {
+      const idx = args.indexOf("gitmem-mcp");
+      if (idx !== -1) {
+        args[idx] = "gitmem-mcp@latest";
+        writeJson(mcpPath, existing);
+        log(CHECK, `Updated MCP args to use gitmem-mcp@latest ${C.dim}(prevents stale npx cache)${C.reset}`);
+        return { done: true };
+      }
+    }
     log(CHECK, `MCP server already configured ${C.dim}(${mcpName})${C.reset}`);
     return { done: false };
   }

package/dist/services/thread-supabase.d.ts

@@ -63,6 +63,20 @@ export declare function resolveThreadInSupabase(threadId: string, options?: {
     resolutionNote?: string;
     resolvedBySession?: string;
 }): Promise<boolean>;
+/**
+ * Fetch a single thread from Supabase by its thread_id ("t-XXXX").
+ *
+ * Used by resolve_thread's cross-session fallback (GIT-46): a thread can live
+ * in the Supabase source-of-truth (and show up in list_threads) while being
+ * absent from this session's local cache because another session created it.
+ *
+ * Deliberately NOT scoped by project — thread_id is globally unique, and
+ * scoping would re-introduce the "can only resolve threads I own" constraint
+ * this fallback exists to remove.
+ *
+ * Returns the mapped ThreadObject, or null if not found / Supabase unavailable.
+ */
+export declare function getThreadFromSupabaseById(threadId: string): Promise<ThreadObject | null>;
 /**
  * List threads from Supabase with project filter.
  * Uses threads_lite view (no embedding column).

package/dist/services/thread-supabase.js

@@ -145,6 +145,38 @@ export async function resolveThreadInSupabase(threadId, options = {}) {
         return false;
     }
 }
+/**
+ * Fetch a single thread from Supabase by its thread_id ("t-XXXX").
+ *
+ * Used by resolve_thread's cross-session fallback (GIT-46): a thread can live
+ * in the Supabase source-of-truth (and show up in list_threads) while being
+ * absent from this session's local cache because another session created it.
+ *
+ * Deliberately NOT scoped by project — thread_id is globally unique, and
+ * scoping would re-introduce the "can only resolve threads I own" constraint
+ * this fallback exists to remove.
+ *
+ * Returns the mapped ThreadObject, or null if not found / Supabase unavailable.
+ */
+export async function getThreadFromSupabaseById(threadId) {
+    if (!hasSupabase() || !supabase.isConfigured()) {
+        return null;
+    }
+    try {
+        const rows = await supabase.directQuery(getTableName("threads_lite"), {
+            select: "*",
+            filters: { thread_id: threadId },
+            limit: 1,
+        });
+        if (rows.length === 0)
+            return null;
+        return rowToThreadObject(rows[0]);
+    }
+    catch (error) {
+        console.error("[thread-supabase] Failed to get thread by id:", error instanceof Error ? error.message : error);
+        return null;
+    }
+}
 /**
  * List threads from Supabase with project filter.
  * Uses threads_lite view (no embedding column).

package/dist/tools/resolve-thread.js

@@ -13,9 +13,9 @@
  */
 import { v4 as uuidv4 } from "uuid";
 import { getTableName } from "../services/tier.js";
-import { getThreads, getCurrentSession } from "../services/session-state.js";
-import { resolveThread as resolveThreadInList, findThreadById, loadThreadsFile, saveThreadsFile, } from "../services/thread-manager.js";
-import { resolveThreadInSupabase } from "../services/thread-supabase.js";
+import { getThreads, getCurrentSession, getProject } from "../services/session-state.js";
+import { resolveThread as resolveThreadInList, findThreadById, findThreadByText, loadThreadsFile, saveThreadsFile, } from "../services/thread-manager.js";
+import { resolveThreadInSupabase, getThreadFromSupabaseById, listThreadsFromSupabase, } from "../services/thread-supabase.js";
 import { writeTriplesForThreadResolution } from "../services/triple-writer.js";
 import { getEffectTracker } from "../services/effect-tracker.js";
 import { getAgentIdentity } from "../services/agent-detection.js";
@@ -66,12 +66,32 @@ export async function resolveThread(params) {
         effectiveTextMatch = undefined;
     }
     // Resolve the thread locally (in-memory / file)
-    const resolved = resolveThreadInList(threads, {
+    let resolved = resolveThreadInList(threads, {
         threadId: effectiveThreadId,
         textMatch: effectiveTextMatch,
         sessionId,
         resolutionNote: params.resolution_note,
     });
+    // GIT-46: cross-session fallback. list_threads reads the Supabase
+    // source-of-truth, but the local match above only sees threads this session
+    // created/cached — so a thread created by another session is visible in
+    // list_threads yet "not found" here. Before failing, hydrate the thread from
+    // Supabase, splice it into the working set, and retry. The downstream flow
+    // (local cache write + Supabase resolve + metrics/triples) then proceeds
+    // unchanged, syncing the previously-diverged local cache back to the SOT.
+    if (!resolved) {
+        const hydrated = await hydrateThreadFromSupabase(effectiveThreadId, effectiveTextMatch);
+        if (hydrated) {
+            if (!findThreadById(threads, hydrated.id)) {
+                threads.push(hydrated);
+            }
+            resolved = resolveThreadInList(threads, {
+                threadId: hydrated.id,
+                sessionId,
+                resolutionNote: params.resolution_note,
+            });
+        }
+    }
     if (!resolved) {
         const latencyMs = timer.stop();
         const searchKey = params.thread_id || params.text_match;
@@ -172,4 +192,28 @@ export async function resolveThread(params) {
         display: wrapDisplay(resolveMsg),
     };
 }
+/**
+ * GIT-46: fetch a thread from the Supabase source-of-truth when it isn't in
+ * the local/session cache (e.g. created by another session).
+ *
+ * - By thread_id: direct, project-agnostic lookup (thread_id is globally unique).
+ * - By text_match: scan the project's open threads and substring-match, mirroring
+ *   the local findThreadByText behavior.
+ *
+ * Returns null when Supabase is unavailable or no thread matches — callers then
+ * fall through to the normal "Thread not found" path.
+ */
+async function hydrateThreadFromSupabase(threadId, textMatch) {
+    if (threadId) {
+        return await getThreadFromSupabaseById(threadId);
+    }
+    if (textMatch) {
+        const project = getProject() || "default";
+        const openThreads = await listThreadsFromSupabase(project, { statusFilter: "open" });
+        if (openThreads) {
+            return findThreadByText(openThreads, textMatch);
+        }
+    }
+    return null;
+}
 //# sourceMappingURL=resolve-thread.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitmem-mcp",
-  "version": "1.6.3",
+  "version": "1.6.5",
   "mcpName": "io.github.gitmem-dev/gitmem",
   "description": "Persistent learning memory for AI coding agents. Memory that compounds.",
   "type": "module",