gitmem-mcp 1.4.1 → 1.4.3

package/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.4.3] - 2026-02-24
+
+### Fixed
+- **NULL agent values in query metrics eliminated**: `recordMetrics()` now auto-detects agent via `getAgentIdentity()` when callers don't provide it. Previously 15 of 18 tools omitted the agent field, resulting in NULL values in `gitmem_query_metrics`.
+
+### Performance
+- **session_start ~200-300ms faster**: Sessions and threads queries now run in parallel (`Promise.all`) instead of sequentially inside `loadLastSession`.
+- **session_close transcript upload no longer blocks**: Transcript save moved from blocking `await` to fire-and-forget via effect tracker. Removes 500-5000ms variable cost from `latency_ms`. Claude session ID extraction remains synchronous.
+
+## [1.4.2] - 2026-02-22
+
+### Fixed
+- **Scar usage `execution_successful` nulls eliminated**: N_A confirmations now record `true` (was null/undefined). Q6 text matches now include `execution_successful: true` (was omitted). Fixes 80% null rate in scar effectiveness data.
+- **Auto-bridge fires on all session closes**: Previously required Q6 `scars_applied` to be non-empty. Now fires whenever no explicit `scars_to_record` is provided, ensuring confirmations from `confirm_scars` always get recorded.
+- **Surfaced scars survive MCP restart**: `getSurfacedScars()` now recovers from the active-sessions registry when `currentSession` is null after MCP restart. Scars surfaced early in a session are no longer silently lost.
+- **Session close display shows scar titles**: `reference_context` now leads with the scar title instead of boilerplate. Display uses +/! indicators for applied/refuted scars.
+
 ## [1.4.1] - 2026-02-22
 
 ### Added

package/dist/services/metrics.js

@@ -8,6 +8,7 @@ import { v4 as uuidv4 } from "uuid";
 import * as supabase from "./supabase-client.js";
 import { getEffectTracker } from "./effect-tracker.js";
 import { hasSupabase } from "./tier.js";
+import { getAgentIdentity } from "./agent-detection.js";
 /**
  * Performance targets
  */
@@ -64,10 +65,12 @@ export class Timer {
 export async function recordMetrics(metrics) {
     if (!hasSupabase())
         return; // No-op on free tier — don't record failures
+    // Auto-detect agent if not provided by caller
+    const agent = metrics.agent || getAgentIdentity() || null;
     const record = {
         id: metrics.id,
         session_id: metrics.session_id || null,
-        agent: metrics.agent || null,
+        agent,
         tool_name: metrics.tool_name,
         query_text: metrics.query_text || null,
         tables_searched: metrics.tables_searched || null,

package/dist/services/session-state.js

@@ -12,7 +12,9 @@
  * This allows recall() to always assign variants even without explicit parameters.
  */
 import fs from "fs";
+import * as os from "os";
 import { getSessionPath } from "./gitmem-dir.js";
+import { listActiveSessions } from "./active-sessions.js";
 // Global session state (single active session per MCP server instance)
 let currentSession = null;
 /**
@@ -105,7 +107,7 @@ export function getSurfacedScars() {
     if (currentSession?.surfacedScars && currentSession.surfacedScars.length > 0) {
         return currentSession.surfacedScars;
     }
-    // Fallback: recover from per-session file if in-memory was lost (MCP restart)
+    // Fallback 1: recover from per-session file if in-memory was lost (MCP restart)
     if (currentSession?.sessionId) {
         try {
             const sessionFilePath = getSessionPath(currentSession.sessionId, "session.json");
@@ -122,6 +124,32 @@ export function getSurfacedScars() {
             console.warn("[session-state] Failed to recover surfaced scars from file:", error);
         }
     }
+    // Fallback 2: if currentSession is null (MCP restarted completely), find session from registry.
+    // After MCP restart the PID changes, but the active-sessions registry may still have
+    // the previous session entry (pruneStale adopts dead-PID sessions on same hostname).
+    if (!currentSession) {
+        try {
+            const hostname = os.hostname();
+            const sessions = listActiveSessions();
+            const candidates = sessions
+                .filter(s => s.hostname === hostname)
+                .sort((a, b) => new Date(b.started_at).getTime() - new Date(a.started_at).getTime());
+            if (candidates.length > 0) {
+                const recoveredId = candidates[0].session_id;
+                const sessionFilePath = getSessionPath(recoveredId, "session.json");
+                if (fs.existsSync(sessionFilePath)) {
+                    const data = JSON.parse(fs.readFileSync(sessionFilePath, "utf-8"));
+                    if (data.surfaced_scars && Array.isArray(data.surfaced_scars) && data.surfaced_scars.length > 0) {
+                        console.error(`[session-state] Recovered ${data.surfaced_scars.length} surfaced scars from registry session ${recoveredId.slice(0, 8)}`);
+                        return data.surfaced_scars;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn("[session-state] Failed to recover surfaced scars from registry:", error);
+        }
+    }
     return [];
 }
 /**

package/dist/tools/session-close.js

@@ -53,6 +53,30 @@ function normalizeScarsApplied(scarsApplied) {
 function countScarsApplied(scarsApplied) {
     return normalizeScarsApplied(scarsApplied).length;
 }
+/**
+ * Find transcript file path: explicit param or auto-detect from Claude Code projects dir
+ */
+function findTranscriptPath(explicitPath) {
+    if (explicitPath) {
+        if (fs.existsSync(explicitPath)) {
+            console.error(`[session_close] Using explicit transcript path: ${explicitPath}`);
+            return explicitPath;
+        }
+        console.warn(`[session_close] Explicit transcript path does not exist: ${explicitPath}`);
+    }
+    const homeDir = os.homedir();
+    const projectsDir = path.join(homeDir, ".claude", "projects");
+    const cwd = process.cwd();
+    const projectDirName = path.basename(cwd);
+    const found = findMostRecentTranscript(projectsDir, projectDirName, cwd);
+    if (found) {
+        console.error(`[session_close] Auto-detected transcript: ${found}`);
+    }
+    else {
+        console.error(`[session_close] No transcript file found in ${projectsDir}`);
+    }
+    return found;
+}
 /**
  * Find the most recently modified transcript file in Claude Code projects directory
  * Search by recency, not by filename matching (supports post-compaction)
@@ -288,15 +312,12 @@ function formatCloseDisplay(sessionId, compliance, params, learningsCount, succe
             lines.push(`  ${dimText("d")} ${truncate(d.title, 68)}`);
         }
     }
-    // Scars applied — compact table, only if any were applied
+    // Scars applied — show titles with status indicator
     if (scarsApplied > 0) {
         lines.push("");
         for (const s of params.scars_to_record.filter(s => s.reference_type !== "none")) {
-            const ref = s.reference_type === "explicit" ? "applied" :
-                s.reference_type === "implicit" ? "implicit" :
-                    s.reference_type === "acknowledged" ? "ack'd" :
-                        s.reference_type === "refuted" ? `${ANSI.yellow}REFUTED${ANSI.reset}` : (s.reference_type || "?");
-            lines.push(`  ${dimText(ref.padEnd(8))} ${truncate(s.reference_context || "", 60)}`);
+            const indicator = s.reference_type === "refuted" ? `${ANSI.yellow}!${ANSI.reset}` : STATUS.pass;
+            lines.push(`  ${indicator} ${truncate(s.reference_context || s.scar_identifier || "", 70)}`);
         }
     }
     // Transcript — only on failure
@@ -599,12 +620,13 @@ function bridgeScarsToUsageRecords(normalizedScarsApplied, sessionId, agentIdent
                 if (reflection) {
                     // Reflection provides definitive signal
                     executionSuccessful = reflection.outcome === "OBEYED" ? true : false;
-                    context = `Confirmed: ${confirmation.decision} → Reflected: ${reflection.outcome} — ${reflection.evidence.slice(0, 80)}`;
+                    context = `${scar.scar_title.slice(0, 60)} (${reflection.outcome})`;
                 }
                 else {
-                    // Fall back to confirmation-based default (Option A)
-                    executionSuccessful = confirmation.decision === "APPLYING" ? true : undefined;
-                    context = `Confirmed via confirm_scars: ${confirmation.decision} — ${confirmation.evidence.slice(0, 100)}`;
+                    // Fall back to confirmation-based default
+                    // APPLYING/N_A = task proceeded normally (true), REFUTED = outcome unknown (null)
+                    executionSuccessful = confirmation.decision === "REFUTED" ? undefined : true;
+                    context = `${scar.scar_title.slice(0, 60)} (${confirmation.decision})`;
                 }
                 autoBridgedScars.push({
                     scar_identifier: scar.scar_id,
@@ -636,7 +658,8 @@ function bridgeScarsToUsageRecords(normalizedScarsApplied, sessionId, agentIdent
                     agent: agentIdentity,
                     surfaced_at: match.surfaced_at,
                     reference_type: "acknowledged",
-                    reference_context: `Auto-bridged from Q6 answer: "${scarApplied}"`,
+                    reference_context: `${match.scar_title.slice(0, 60)} (Q6 match)`,
+                    execution_successful: true,
                     variant_id: match.variant_id,
                 });
             }
@@ -651,7 +674,7 @@ function bridgeScarsToUsageRecords(normalizedScarsApplied, sessionId, agentIdent
                     agent: agentIdentity,
                     surfaced_at: scar.surfaced_at,
                     reference_type: "none",
-                    reference_context: `Surfaced during ${scar.source} but not mentioned in closing reflection`,
+                    reference_context: `${scar.scar_title.slice(0, 60)} (not addressed)`,
                     execution_successful: false,
                     variant_id: scar.variant_id,
                 });
@@ -1034,20 +1057,48 @@ export async function sessionClose(params) {
         console.error("[session_close] Failed to prune threads.json (non-fatal):", err);
     }
     // Capture transcript if enabled (default true for CLI/DAC)
+    // Split into two phases: sync ID extraction (fast) + async upload (fire-and-forget)
     let transcriptStatus;
     const shouldCaptureTranscript = params.capture_transcript !== false &&
         (agentIdentity === "cli" || agentIdentity === "desktop");
     if (shouldCaptureTranscript) {
-        const transcriptResult = await captureSessionTranscript(sessionId, params, existingSession, isRetroactive);
-        transcriptStatus = transcriptResult.status;
-        if (transcriptResult.claudeSessionId) {
-            sessionData.claude_code_session_id = transcriptResult.claudeSessionId;
+        // Phase 1: Find transcript and extract Claude session ID (sync, ~10ms)
+        const transcriptFilePath = findTranscriptPath(params.transcript_path);
+        if (transcriptFilePath) {
+            const transcriptContent = fs.readFileSync(transcriptFilePath, "utf-8");
+            const claudeSessionId = extractClaudeSessionId(transcriptContent, transcriptFilePath) || undefined;
+            if (claudeSessionId) {
+                sessionData.claude_code_session_id = claudeSessionId;
+                console.error(`[session_close] Extracted Claude session ID: ${claudeSessionId}`);
+            }
+            // Phase 2: Upload transcript (fire-and-forget — was blocking ~500-5000ms)
+            const transcriptProject = isRetroactive ? "default" : existingSession?.project;
+            getEffectTracker().track("transcript", "session_close", async () => {
+                const saveResult = await saveTranscript({
+                    session_id: sessionId,
+                    transcript: transcriptContent,
+                    format: "json",
+                    project: transcriptProject,
+                });
+                if (saveResult.success && saveResult.transcript_path) {
+                    console.error(`[session_close] Transcript saved: ${saveResult.transcript_path} (${saveResult.size_kb}KB)`);
+                    // Process transcript for semantic search (chained fire-and-forget)
+                    processTranscript(sessionId, transcriptContent, transcriptProject)
+                        .then(result => {
+                        if (result.success) {
+                            console.error(`[session_close] Transcript processed: ${result.chunksCreated} chunks`);
+                        }
+                    })
+                        .catch((err) => console.error("[session_close] Transcript processing failed:", err instanceof Error ? err.message : err));
+                }
+            });
         }
     }
     // Auto-bridge Q6 answers to scar_usage records
     const normalizedScarsApplied = normalizeScarsApplied(params.closing_reflection?.scars_applied);
-    if ((!params.scars_to_record || params.scars_to_record.length === 0) &&
-        normalizedScarsApplied.length > 0) {
+    // Auto-bridge surfaced scars to usage records whenever no explicit scars_to_record.
+    // Fires even when Q6 is empty — Pass 1 matches confirmations, Pass 3 catches ignored scars.
+    if (!params.scars_to_record || params.scars_to_record.length === 0) {
         const bridgedScars = bridgeScarsToUsageRecords(normalizedScarsApplied, sessionId, agentIdentity);
         if (bridgedScars.length > 0) {
             params = { ...params, scars_to_record: bridgedScars };

package/dist/tools/session-start.js

@@ -101,19 +101,20 @@ async function loadLastSession(agent, project) {
         };
     }
     try {
-        // Use _lite view for performance (excludes embedding)
-        // View now includes decisions/open_threads arrays
-        const sessions = await supabase.listRecords({
-            table: getTableName("sessions_lite"),
-            filters: { agent, project },
-            limit: 10, // Get several to find a closed one + aggregate threads
-            orderBy: { column: "created_at", ascending: false },
-        });
-        // Try loading threads from Supabase (source of truth) first
+        // Parallel load: sessions + threads are independent queries
+        // (was sequential — ~200-300ms saved by parallelizing)
+        const [sessions, supabaseThreads] = await Promise.all([
+            supabase.listRecords({
+                table: getTableName("sessions_lite"),
+                filters: { agent, project },
+                limit: 10,
+                orderBy: { column: "created_at", ascending: false },
+            }),
+            loadActiveThreadsFromSupabase(project),
+        ]);
         let aggregated_open_threads;
         let displayInfo = [];
         let threadsFromSupabase = false;
-        const supabaseThreads = await loadActiveThreadsFromSupabase(project);
         if (supabaseThreads !== null) {
             // Supabase is source of truth for threads
             aggregated_open_threads = supabaseThreads.open;

package/package.json

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