gitmem-mcp 1.4.2 → 1.4.4

package/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.4.4] - 2026-03-31
+
+### Fixed
+- **Project drift on session resume eliminated**: When resuming an existing session (same hostname+PID), the stored project now overrides whatever the agent passes. Previously, context compaction could cause agents to send the wrong project (e.g., `orchestra_dev` instead of `weekend_warrior`), creating a session under the wrong project with wrong threads and decisions. The active-sessions registry already stored the correct project — it just wasn't used on resume.
+- **`closing_reflection` array coercion**: Values passed as arrays in `closing_reflection` are now coerced to strings, preventing schema validation errors on session close.
+- **`create_thread` no longer triggers false enforcement warnings**: Removed from `CONSEQUENTIAL_TOOLS` list — creating threads is lightweight and shouldn't require prior recall.
+
+## [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/bin/gitmem.js

@@ -154,9 +154,10 @@ async function cmdInit() {
     // Merge: skip scars that already exist by id
     const existingIds = new Set(existing.map((s) => s.id));
     let added = 0;
+    const now = new Date().toISOString();
     for (const scar of starterScars) {
       if (!existingIds.has(scar.id)) {
-        existing.push(scar);
+        existing.push({ ...scar, created_at: now, source_date: now.slice(0, 10) });
         added++;
         console.log(`  + ${scar.title}`);
       } else {

package/dist/schemas/session-close.d.ts

@@ -13,11 +13,11 @@ export declare const ClosingReflectionSchema: z.ZodObject<{
     wrong_assumption: z.ZodString;
     scars_applied: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
     /** Q7: What from this session should be captured as institutional memory? */
-    institutional_memory_items: z.ZodOptional<z.ZodString>;
+    institutional_memory_items: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodArray<z.ZodString, "many">, string, string[]>]>>;
     /** Q8: How did the human prefer to work this session? */
-    collaborative_dynamic: z.ZodOptional<z.ZodString>;
+    collaborative_dynamic: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodArray<z.ZodString, "many">, string, string[]>]>>;
     /** Q9: What collaborative dynamic worked or didn't work? */
-    rapport_notes: z.ZodOptional<z.ZodString>;
+    rapport_notes: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodArray<z.ZodString, "many">, string, string[]>]>>;
 }, "strip", z.ZodTypeAny, {
     what_broke: string;
     what_took_longer: string;
@@ -35,9 +35,9 @@ export declare const ClosingReflectionSchema: z.ZodObject<{
     what_worked: string;
     wrong_assumption: string;
     scars_applied: string | string[];
-    institutional_memory_items?: string | undefined;
-    collaborative_dynamic?: string | undefined;
-    rapport_notes?: string | undefined;
+    institutional_memory_items?: string | string[] | undefined;
+    collaborative_dynamic?: string | string[] | undefined;
+    rapport_notes?: string | string[] | undefined;
 }>;
 export type ClosingReflection = z.infer<typeof ClosingReflectionSchema>;
 /**
@@ -154,11 +154,11 @@ export declare const SessionCloseParamsSchema: z.ZodObject<{
         wrong_assumption: z.ZodString;
         scars_applied: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
         /** Q7: What from this session should be captured as institutional memory? */
-        institutional_memory_items: z.ZodOptional<z.ZodString>;
+        institutional_memory_items: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodArray<z.ZodString, "many">, string, string[]>]>>;
         /** Q8: How did the human prefer to work this session? */
-        collaborative_dynamic: z.ZodOptional<z.ZodString>;
+        collaborative_dynamic: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodArray<z.ZodString, "many">, string, string[]>]>>;
         /** Q9: What collaborative dynamic worked or didn't work? */
-        rapport_notes: z.ZodOptional<z.ZodString>;
+        rapport_notes: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodArray<z.ZodString, "many">, string, string[]>]>>;
     }, "strip", z.ZodTypeAny, {
         what_broke: string;
         what_took_longer: string;
@@ -176,9 +176,9 @@ export declare const SessionCloseParamsSchema: z.ZodObject<{
         what_worked: string;
         wrong_assumption: string;
         scars_applied: string | string[];
-        institutional_memory_items?: string | undefined;
-        collaborative_dynamic?: string | undefined;
-        rapport_notes?: string | undefined;
+        institutional_memory_items?: string | string[] | undefined;
+        collaborative_dynamic?: string | string[] | undefined;
+        rapport_notes?: string | string[] | undefined;
     }>>;
     human_corrections: z.ZodOptional<z.ZodString>;
     decisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -343,9 +343,9 @@ export declare const SessionCloseParamsSchema: z.ZodObject<{
         what_worked: string;
         wrong_assumption: string;
         scars_applied: string | string[];
-        institutional_memory_items?: string | undefined;
-        collaborative_dynamic?: string | undefined;
-        rapport_notes?: string | undefined;
+        institutional_memory_items?: string | string[] | undefined;
+        collaborative_dynamic?: string | string[] | undefined;
+        rapport_notes?: string | string[] | undefined;
     } | undefined;
     human_corrections?: string | undefined;
     scars_to_record?: {

package/dist/schemas/session-close.js

@@ -15,11 +15,11 @@ export const ClosingReflectionSchema = z.object({
     wrong_assumption: z.string(),
     scars_applied: z.union([z.string(), z.array(z.string())]),
     /** Q7: What from this session should be captured as institutional memory? */
-    institutional_memory_items: z.string().optional(),
+    institutional_memory_items: z.union([z.string(), z.array(z.string()).transform((arr) => arr.join(". "))]).optional(),
     /** Q8: How did the human prefer to work this session? */
-    collaborative_dynamic: z.string().optional(),
+    collaborative_dynamic: z.union([z.string(), z.array(z.string()).transform((arr) => arr.join(". "))]).optional(),
     /** Q9: What collaborative dynamic worked or didn't work? */
-    rapport_notes: z.string().optional(),
+    rapport_notes: z.union([z.string(), z.array(z.string()).transform((arr) => arr.join(". "))]).optional(),
 });
 /**
  * Task completion proof schema

package/dist/services/enforcement.js

@@ -37,7 +37,6 @@ const SESSION_REQUIRED_TOOLS = new Set([
 const CONSEQUENTIAL_TOOLS = new Set([
     "create_learning", "gitmem-cl", "gm-scar",
     "create_decision", "gitmem-cd",
-    "create_thread", "gitmem-ct", "gm-thread-new",
     "session_close", "gitmem-sc", "gm-close",
 ]);
 /**

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;
@@ -502,6 +503,7 @@ function restoreSessionState(existing, fallbackAgent) {
         agent: existing.agent || fallbackAgent,
         linearIssue: existing.linear_issue,
         startedAt,
+        project: existing.project,
     };
 }
 /**
@@ -742,10 +744,20 @@ export async function sessionStart(params) {
     // 1. Detect agent (or use provided)
     const env = detectAgent();
     const agent = params.agent_identity || env.agent;
-    const project = params.project || getConfigProject() || "default";
+    let project = params.project || getConfigProject() || "default";
     // Check for existing active session — reuse session_id but still load full context
     const existingSession = checkExistingSession(agent, params.force);
     const isResuming = existingSession !== null;
+    // When resuming, prefer the stored project from the existing session.
+    // This prevents project drift after context compaction — the agent may pass
+    // the wrong project (e.g., from CLAUDE.md defaults) but the stored session
+    // knows the real project.
+    if (isResuming && existingSession?.project) {
+        if (existingSession.project !== project) {
+            console.error(`[session_start] Project override on resume: ${project} → ${existingSession.project} (from stored session)`);
+        }
+        project = existingSession.project;
+    }
     // t-f7c2fa01: When force:true kills an existing session, carry forward its startedAt
     // so session_close duration reflects the full conversation, not just the new session.
     // Also carry forward activity counts (recalls, observations) so standard close isn't rejected.

package/package.json

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