gitmem-mcp 1.3.3 → 1.3.5

package/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.3.5] - 2026-02-22
+
+### Fixed
+- **Free tier recall→confirm_scars flow broken**: Recall on free tier returned scars to the agent but never tracked them in session state, causing confirm_scars to respond with "No recall-surfaced scars to confirm" even when valid confirmations were submitted. Reported across 3 clean room sessions.
+
+### Added
+- **E2E regression test for recall→confirm_scars**: Verifies the full free tier flow — create scar, recall it, confirm it — catches the session state tracking gap.
+
+## [1.3.4] - 2026-02-22
+
+### Added
+- **Expanded starter scar pack** (7 → 12): Five new community-proposed scars covering multi-agent delegation, memory hygiene, and communication patterns.
+- **Closing payload pre-seeded during init**: `closing-payload.json` template created at install time, preventing Write permission prompt on first session close.
+- **`contribute_feedback` tool**: Agents can submit anonymous feedback (feature requests, bugs, friction) to help improve gitmem.
+
+### Fixed
+- **`is_active` filter for free tier**: `list()` now treats missing `is_active` as `true` instead of filtering out all learnings without the field.
+- **`learning_type` in recall results**: Recall now returns `learning_type` in search results so agents can distinguish scars from wins and patterns.
+- **Explicit `is_active: true` on learning creation**: New learnings are created with `is_active: true` to prevent filter mismatches.
+
 ## [1.3.1] - 2026-02-22
 
 ### Fixed

package/dist/services/local-file-storage.js

@@ -64,7 +64,13 @@ export class LocalFileStorage {
         if (options.filters) {
             for (const [key, value] of Object.entries(options.filters)) {
                 const cleanValue = value.startsWith("eq.") ? value.slice(3) : value;
-                records = records.filter((r) => String(r[key]) === cleanValue);
+                if (key === "is_active" && cleanValue === "true") {
+                    // is_active defaults to true when not explicitly set
+                    records = records.filter((r) => r[key] !== false);
+                }
+                else {
+                    records = records.filter((r) => String(r[key]) === cleanValue);
+                }
             }
         }
         // Apply ordering
@@ -150,6 +156,7 @@ export class LocalFileStorage {
             mapped.push({
                 id: r.id,
                 title: String(l.title),
+                learning_type: String(l.learning_type || "scar"),
                 description: String(l.description),
                 severity: String(l.severity || "medium"),
                 counter_arguments: l.counter_arguments || [],

package/dist/tools/create-learning.js

@@ -87,6 +87,7 @@ export async function createLearning(params) {
         created_at: new Date().toISOString(),
         persona_name: agentIdentity,
         source_date: new Date().toISOString().split("T")[0],
+        is_active: true,
         // LLM-cooperative enforcement fields (optional)
         ...(params.why_this_matters && { why_this_matters: params.why_this_matters }),
         ...(params.action_protocol && { action_protocol: params.action_protocol }),

package/dist/tools/recall.js

@@ -201,6 +201,16 @@ export async function recall(params) {
                 similarityScores: scars.map((s) => s.similarity),
                 search_mode: "local",
             });
+            // Track surfaced scars for confirm_scars (same as pro tier path)
+            const recallSurfacedAt = new Date().toISOString();
+            const recallSurfacedScars = scars.map((scar) => ({
+                scar_id: scar.id,
+                scar_title: scar.title,
+                scar_severity: scar.severity || "medium",
+                surfaced_at: recallSurfacedAt,
+                source: "recall",
+            }));
+            addSurfacedScars(recallSurfacedScars);
             const freeFormatted = formatResponse(scars, plan);
             return {
                 activated: scars.length > 0,

package/package.json

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

package/schema/starter-scars.json

@@ -124,5 +124,95 @@
     "project": "default",
     "source_date": "2026-01-01",
     "created_at": "2026-01-01T00:00:00Z"
+  },
+  {
+    "id": "5c1111a9-c161-4b2d-83f9-063780164b7c",
+    "learning_type": "scar",
+    "title": "Sub-agents Start With Zero Context — Always Inject Memory",
+    "description": "When you spawn a sub-agent (Task tool), it starts with a blank slate — no conversation history, no institutional memory, no project context. If you don't explicitly inject context via prepare_context or a detailed prompt, the sub-agent will repeat mistakes the team already learned from. The 2-3 seconds to prepare context prevents minutes of wasted work.",
+    "severity": "high",
+    "scar_type": "process",
+    "is_starter": true,
+    "counter_arguments": [
+      "The sub-agent has access to the same tools so it can figure things out — but without memory context it will rediscover pitfalls the hard way",
+      "Injecting context slows down spawning — but 2-3 seconds of prep prevents full task re-runs when the agent hits a known issue"
+    ],
+    "keywords": ["sub-agent", "task-tool", "context", "delegation", "multi-agent", "prepare-context"],
+    "domain": ["multi-agent", "delegation"],
+    "project": "default",
+    "source_date": "2026-02-22",
+    "created_at": "2026-02-22T00:00:00Z"
+  },
+  {
+    "id": "f7d1dcb8-dcf1-48fb-9ab0-e682cd704530",
+    "learning_type": "scar",
+    "title": "Sub-agents Cannot See Your Conversation — Spell Out Everything",
+    "description": "Sub-agents spawned via the Task tool do not inherit the parent conversation. They cannot see what the user asked, what files were discussed, or what decisions were made. Every requirement, file path, and constraint must be explicitly stated in the task prompt. Vague delegation like 'fix the bug we discussed' will fail because the sub-agent has no idea what was discussed.",
+    "severity": "high",
+    "scar_type": "process",
+    "is_starter": true,
+    "counter_arguments": [
+      "The sub-agent description says it has 'access to current context' — but only certain agent types do, and even then the full nuance of the conversation may not transfer",
+      "I can just tell it to 'continue the work' — but without explicit requirements the sub-agent will interpret 'the work' differently than you intended"
+    ],
+    "keywords": ["sub-agent", "delegation", "prompt", "requirements", "context-loss", "multi-agent"],
+    "domain": ["multi-agent", "delegation"],
+    "project": "default",
+    "source_date": "2026-02-22",
+    "created_at": "2026-02-22T00:00:00Z"
+  },
+  {
+    "id": "060389aa-c0fa-445d-bbfd-5d9250dc1e73",
+    "learning_type": "scar",
+    "title": "Don't Pre-read Files Before Delegating — Let the Sub-agent Read Them",
+    "description": "Reading files into your context before spawning a sub-agent wastes your context window and doesn't help the sub-agent (it can't see what you read). Instead, tell the sub-agent which files to read. The sub-agent has its own context budget and its own file access. Pre-reading just burns tokens twice.",
+    "severity": "medium",
+    "scar_type": "process",
+    "is_starter": true,
+    "counter_arguments": [
+      "I need to understand the code before I can write a good prompt — true for architecture decisions, but for 'read and fix' tasks the sub-agent can do its own reading",
+      "What if the sub-agent reads the wrong files — provide specific file paths in the prompt rather than reading them yourself"
+    ],
+    "keywords": ["sub-agent", "context-window", "delegation", "file-reading", "tokens", "multi-agent"],
+    "domain": ["multi-agent", "efficiency"],
+    "project": "default",
+    "source_date": "2026-02-22",
+    "created_at": "2026-02-22T00:00:00Z"
+  },
+  {
+    "id": "55b25d2e-41ad-47f4-8723-569b78586dff",
+    "learning_type": "scar",
+    "title": "Search Memory Before Creating Learnings — Duplicates Dilute Recall",
+    "description": "Before creating a new scar, win, or pattern, search existing memory first. Duplicate entries dilute recall quality — when the same lesson exists three times with slightly different wording, search results waste slots on redundant matches instead of surfacing diverse, relevant knowledge. One well-written scar beats three near-duplicates.",
+    "severity": "medium",
+    "scar_type": "process",
+    "is_starter": true,
+    "counter_arguments": [
+      "Creating duplicates reinforces the lesson — but recall is similarity-based, so duplicates just crowd out other useful results",
+      "My wording is better than the existing one — then update the existing entry instead of creating a new one"
+    ],
+    "keywords": ["memory", "search", "duplicates", "recall", "learning", "scar-creation"],
+    "domain": ["memory-hygiene", "gitmem"],
+    "project": "default",
+    "source_date": "2026-02-22",
+    "created_at": "2026-02-22T00:00:00Z"
+  },
+  {
+    "id": "867cf3f6-a0e5-4ca2-8d4d-43cb1f10d94d",
+    "learning_type": "scar",
+    "title": "Ask Clarifying Questions Before Coding — 5 Seconds Prevents a Rewrite",
+    "description": "When requirements are ambiguous, ask a clarifying question before writing code. A 5-second question like 'Should this handle both cases or just the first?' prevents building the wrong thing and having to rewrite. Assumptions that seem obvious are often wrong. The cost of asking is near-zero; the cost of a wrong assumption is a full task redo.",
+    "severity": "high",
+    "scar_type": "process",
+    "is_starter": true,
+    "counter_arguments": [
+      "Asking too many questions slows things down — but one targeted question is faster than a rewrite after building the wrong thing",
+      "I can just build both options and let the user pick — but that's double the work and the user wanted a decision, not a menu"
+    ],
+    "keywords": ["requirements", "clarification", "assumptions", "communication", "rewrite"],
+    "domain": ["communication", "planning"],
+    "project": "default",
+    "source_date": "2026-02-22",
+    "created_at": "2026-02-22T00:00:00Z"
   }
 ]