gitmem-mcp 1.6.4 → 1.6.6

package/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.6.6] - 2026-06-27
+
+### Changed
+- **`recall` stubs low-confidence scars to cut wasted tokens**: scars scoring below the `0.55` similarity threshold (already flagged `[low confidence]`, ~66% N/A rate in that band) now render as a one-line stub — title, severity, score, short id, and the `[low confidence]` tag — instead of hydrating their full body (description, counter-arguments, applies-when, why-this-matters, action-protocol, self-check, related triples). High-confidence scars (≥ 0.55) are unchanged, and blocking-verification scars always render in full regardless of score. The `0.55` cutoff is now a single named constant (`LOW_CONFIDENCE_THRESHOLD`) shared by the tag and the stub so they can't drift apart. The scar's id stays visible, so an agent can still pull detail on demand. (GIT-49)
+
+## [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

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/recall.d.ts

@@ -15,6 +15,16 @@
 import type { KnowledgeTriple } from "../services/supabase-client.js";
 import { type ScarWithVariant } from "../services/variant-assignment.js";
 import type { Project, PerformanceData } from "../types/index.js";
+/**
+ * Confidence cutoff for scar rendering.
+ *
+ * Matches below this similarity are flagged `[low confidence]` and, per the
+ * 1.5.0 UX-audit calibration, are N/A ~66% of the time. They pass the pro-tier
+ * 0.45 inclusion filter but are rendered as stubs (header only) rather than full
+ * bodies — the tag boundary and the stub boundary share this constant so they
+ * can never drift apart.
+ */
+export declare const LOW_CONFIDENCE_THRESHOLD = 0.55;
 /**
  * Parameters for recall tool
  */

package/dist/tools/recall.js

@@ -27,6 +27,16 @@ import { getSessionPath } from "../services/gitmem-dir.js";
 import { wrapDisplay, SEV, dimText, ANSI } from "../services/display-protocol.js";
 import { formatNudgeHeader } from "../services/nudge-variants.js";
 import { fetchDismissalCounts } from "../services/behavioral-decay.js";
+/**
+ * Confidence cutoff for scar rendering.
+ *
+ * Matches below this similarity are flagged `[low confidence]` and, per the
+ * 1.5.0 UX-audit calibration, are N/A ~66% of the time. They pass the pro-tier
+ * 0.45 inclusion filter but are rendered as stubs (header only) rather than full
+ * bodies — the tag boundary and the stub boundary share this constant so they
+ * can never drift apart.
+ */
+export const LOW_CONFIDENCE_THRESHOLD = 0.55;
 /**
  * Format scars into a readable response for Claude
  */
@@ -80,8 +90,8 @@ No past lessons match this plan closely enough. Scars accumulate as you work —
     for (const scar of scars) {
         const sev = SEV[scar.severity] || "[?]";
         const starterTag = scar.is_starter ? ` ${dimText("[starter]")}` : "";
-        // Confidence tier: marginal matches (< 0.55) get flagged — 66% N/A rate in this range
-        const confidenceTag = scar.similarity < 0.55 ? ` ${dimText("[low confidence]")}` : "";
+        // Confidence tier: marginal matches get flagged — 66% N/A rate below the threshold
+        const confidenceTag = scar.similarity < LOW_CONFIDENCE_THRESHOLD ? ` ${dimText("[low confidence]")}` : "";
         // Pro: decay tag for scars with reduced behavioral relevance
         const decayTag = hasProInsights() && scar.decay_multiplier !== undefined && scar.decay_multiplier < 0.8
             ? ` ${dimText(`[decay: ${Math.round(scar.decay_multiplier * 100)}%]`)}`
@@ -94,55 +104,61 @@ No past lessons match this plan closely enough. Scars accumulate as you work —
                 lines.push(`  _[dismissed ${counts.dismissed}/${counts.surfaced} times — re-evaluate whether this still applies]_`);
             }
         }
-        // Use variant enforcement text if available (blind to variant name)
-        if (scar.variant_info?.has_variants && scar.variant_info.variant) {
-            const variantText = formatVariantEnforcement(scar.variant_info.variant, scar.title);
-            lines.push(variantText);
-        }
-        else {
-            // Legacy path: use original scar description
-            lines.push(scar.description);
-        }
-        if (scar.counter_arguments.length > 0) {
-            lines.push("");
-            lines.push("*You might think:*");
-            for (const counter of scar.counter_arguments.slice(0, 2)) {
-                lines.push(`  - ${counter}`);
+        // Stub low-confidence scars: render header only, skip the heavy body.
+        // ~66% of sub-threshold matches are N/A, so their full bodies are wasted
+        // tokens. Blocking-verification scars always render full regardless of score.
+        const isStub = scar.similarity < LOW_CONFIDENCE_THRESHOLD && !scar.required_verification?.blocking;
+        if (!isStub) {
+            // Use variant enforcement text if available (blind to variant name)
+            if (scar.variant_info?.has_variants && scar.variant_info.variant) {
+                const variantText = formatVariantEnforcement(scar.variant_info.variant, scar.title);
+                lines.push(variantText);
             }
-        }
-        if (scar.applies_when.length > 0) {
-            lines.push("");
-            lines.push("*Applies when:* " + scar.applies_when.slice(0, 3).join(", "));
-        }
-        // Render LLM-cooperative enforcement fields
-        if (scar.why_this_matters) {
-            lines.push("");
-            lines.push(`**Why this matters:** ${scar.why_this_matters}`);
-        }
-        if (scar.action_protocol && scar.action_protocol.length > 0) {
-            lines.push("");
-            lines.push("**Action Protocol:**");
-            scar.action_protocol.forEach((step, i) => {
-                lines.push(`  ${i + 1}. ${step}`);
-            });
-        }
-        if (scar.self_check_criteria && scar.self_check_criteria.length > 0) {
-            lines.push("");
-            lines.push("**Self-Check:**");
-            for (const criterion of scar.self_check_criteria) {
-                lines.push(`  - [ ] ${criterion}`);
+            else {
+                // Legacy path: use original scar description
+                lines.push(scar.description);
             }
-        }
-        // Render related knowledge triples
-        if (scar.related_triples && scar.related_triples.length > 0) {
-            lines.push("");
-            lines.push("*Related knowledge:*");
-            for (const triple of scar.related_triples) {
-                lines.push(`  - ${triple.subject} **${triple.predicate}** ${triple.object}`);
+            if (scar.counter_arguments.length > 0) {
+                lines.push("");
+                lines.push("*You might think:*");
+                for (const counter of scar.counter_arguments.slice(0, 2)) {
+                    lines.push(`  - ${counter}`);
+                }
+            }
+            if (scar.applies_when.length > 0) {
+                lines.push("");
+                lines.push("*Applies when:* " + scar.applies_when.slice(0, 3).join(", "));
+            }
+            // Render LLM-cooperative enforcement fields
+            if (scar.why_this_matters) {
+                lines.push("");
+                lines.push(`**Why this matters:** ${scar.why_this_matters}`);
+            }
+            if (scar.action_protocol && scar.action_protocol.length > 0) {
+                lines.push("");
+                lines.push("**Action Protocol:**");
+                scar.action_protocol.forEach((step, i) => {
+                    lines.push(`  ${i + 1}. ${step}`);
+                });
+            }
+            if (scar.self_check_criteria && scar.self_check_criteria.length > 0) {
+                lines.push("");
+                lines.push("**Self-Check:**");
+                for (const criterion of scar.self_check_criteria) {
+                    lines.push(`  - [ ] ${criterion}`);
+                }
+            }
+            // Render related knowledge triples
+            if (scar.related_triples && scar.related_triples.length > 0) {
+                lines.push("");
+                lines.push("*Related knowledge:*");
+                for (const triple of scar.related_triples) {
+                    lines.push(`  - ${triple.subject} **${triple.predicate}** ${triple.object}`);
+                }
+            }
+            if (scar.source_issue) {
+                lines.push(`*Source:* ${scar.source_issue}`);
             }
-        }
-        if (scar.source_issue) {
-            lines.push(`*Source:* ${scar.source_issue}`);
         }
         lines.push("");
         lines.push("---");

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.4",
+  "version": "1.6.6",
   "mcpName": "io.github.gitmem-dev/gitmem",
   "description": "Persistent learning memory for AI coding agents. Memory that compounds.",
   "type": "module",