gitmem-mcp 1.4.2 → 1.4.3

package/CHANGELOG.md

@@ -7,6 +7,15 @@ 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

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/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)
@@ -1033,14 +1057,41 @@ 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

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