stackmem 1.0.15 → 1.0.16

package/dist/benchmark.js

@@ -8,7 +8,7 @@ import { execSync } from "node:child_process";
 import nodeFs from "node:fs";
 import nodePath from "node:path";
 import { fileURLToPath } from "node:url";
-import { applyContextBudget, computeDecayScore, containmentScore, decideSaveAction, estimateTokens, extractEntities, scoreMemoryRelevance, } from "./scoring.js";
+import { applyContextBudget, computeDecayScore, decideSaveAction, estimateTokens, extractEntities, hybridScore, scoreMemoryRelevance, } from "./scoring.js";
 import { supabase } from "./storage.js";
 const CONTEXT_BUDGET_TOKENS = 2000;
 const REPO_ROOT = nodePath.join(nodePath.dirname(fileURLToPath(import.meta.url)), "..");
@@ -256,7 +256,16 @@ function benchmarkDuplicateDetection(allMemories, unrelatedPairs) {
 // a harder, unverified case this benchmark doesn't cover.
 const CONTRADICTION_PREFIXES = ["switched from ", "no longer using "];
 function benchmarkContradictionDetection(allMemories, unrelatedPairs) {
-    const baseSample = seededShuffle(allMemories, BENCHMARK_SEED + 2).slice(0, SAMPLE_SIZE / 2);
+    // Hook-generated templates (dependency changes, config/schema/TODO
+    // discoveries) are structural event records, not decisions — decideSaveAction
+    // deliberately exempts dependency templates from ever routing to
+    // "superseded" (see DEPENDENCY_TEMPLATE_RE in scoring.ts), and prepending
+    // "switched from X" to any of these templates isn't a phrase anyone would
+    // actually write. Sampling them here would just measure whether that
+    // exemption holds, not whether contradiction detection works — so they're
+    // excluded, keeping this test on genuine decision/discovery-style content.
+    const contradictableMemories = allMemories.filter((m) => !HOOK_TEMPLATE_PREFIXES.some((p) => m.content.startsWith(p.prefix)));
+    const baseSample = seededShuffle(contradictableMemories, BENCHMARK_SEED + 2).slice(0, SAMPLE_SIZE / 2);
     let tp = 0;
     let fn = 0;
     for (const memory of baseSample) {
@@ -294,6 +303,14 @@ function benchmarkContradictionDetection(allMemories, unrelatedPairs) {
 // exhaustively rather than randomly sampled — at this data size (a few
 // thousand possible pairs at most) exhaustive is cheap and gives a more
 // stable number than a small random draw would.
+//
+// CAVEAT: avgLinkScore below reads memory_links.score as stored — i.e.
+// whatever computeMemoryLinks computed at save time. Rows saved before
+// computeMemoryLinks switched from containmentScore to hybridScore still
+// hold old-formula scores; only the baseline here is guaranteed to reflect
+// the current formula (it's computed live). A mixed-vintage avgLinkScore
+// vs. a current-formula baseline is still the most honest comparison
+// available without backfilling every historical link.
 function benchmarkSemanticLinking(allMemories, allLinks) {
     const avgLinkScore = allLinks.length === 0 ? 0 : allLinks.reduce((sum, l) => sum + l.score, 0) / allLinks.length;
     const linkedPairKeys = new Set(allLinks.map((l) => pairKey(l.source_id, l.target_id)));
@@ -306,13 +323,12 @@ function benchmarkSemanticLinking(allMemories, allLinks) {
     let baselineSum = 0;
     let baselineCount = 0;
     for (const rows of byProject.values()) {
-        const entitiesById = new Map(rows.map((m) => [m.id, extractEntities(m.content)]));
         for (let i = 0; i < rows.length; i++) {
             for (let j = i + 1; j < rows.length; j++) {
                 const key = pairKey(rows[i].id, rows[j].id);
                 if (linkedPairKeys.has(key))
                     continue;
-                baselineSum += containmentScore(entitiesById.get(rows[i].id), entitiesById.get(rows[j].id));
+                baselineSum += hybridScore(rows[i].content, rows[j].content);
                 baselineCount++;
             }
         }

package/dist/cli.js

@@ -234,6 +234,8 @@ async function cmdStart(project) {
     const memories = data ?? [];
     if (memories.length === 0) {
         console.log(`No memories found for "${project}".`);
+        console.log("");
+        console.log("Tip: run 'cm init' to seed tech stack memories from your project files.");
         return;
     }
     const scoredMemories = memories
@@ -310,6 +312,11 @@ async function cmdStart(project) {
     if (omittedCount > 0) {
         console.log(`${omittedCount} memories omitted (budget exceeded)`);
     }
+    const hasTechStackMemory = memories.some((m) => /^tech stack:/i.test(m.content));
+    if (!hasTechStackMemory) {
+        console.log("");
+        console.log("Tip: run 'cm init' to seed tech stack memories from your project files.");
+    }
     const incrementResults = await Promise.all(budgetedMemories.map((memory) => supabase
         .from("memories")
         .update({ access_count: (memory.access_count ?? 0) + 1 })
@@ -1040,6 +1047,21 @@ function writeProjectFile(project, resolvedPath) {
     const stackmemPath = nodePath.join(resolvedPath, STACKMEM_FILE);
     nodeFs.writeFileSync(stackmemPath, `${project}\n`, "utf-8");
 }
+// Shared by every seedMemories check below: skip the insert if this exact
+// content already exists (decideSaveAction's duplicate check) so re-running
+// `cm init` on an already-seeded project doesn't pile up repeats.
+async function trySeedMemory(project, existingMemories, type, content) {
+    const decision = decideSaveAction(content, existingMemories);
+    if (decision.action === "duplicate")
+        return false;
+    const { error } = await supabase.from("memories").insert({
+        project,
+        type,
+        content,
+        device_id: getDeviceId(),
+    });
+    return !error;
+}
 // Scans the freshly-initialized project for a few cheap, high-signal facts
 // and saves them as memories directly (bypassing cmdSave's duplicate/conflict
 // prompt — there's nothing to conflict with yet, and init must stay
@@ -1064,17 +1086,8 @@ async function seedMemories(project, resolvedPath) {
             ];
             if (depNames.length > 0) {
                 const content = `tech stack: ${depNames.join(", ")}`;
-                const decision = decideSaveAction(content, existingMemories);
-                if (decision.action !== "duplicate") {
-                    const { error } = await supabase.from("memories").insert({
-                        project,
-                        type: "discovery",
-                        content,
-                        device_id: getDeviceId(),
-                    });
-                    if (!error)
-                        seededCount++;
-                }
+                if (await trySeedMemory(project, existingMemories, "discovery", content))
+                    seededCount++;
             }
         }
         catch {
@@ -1090,18 +1103,57 @@ async function seedMemories(project, resolvedPath) {
             .map((line) => line.split("=")[0]);
         if (varNames.length > 0) {
             const content = `required env vars: ${varNames.join(", ")}`;
-            const decision = decideSaveAction(content, existingMemories);
-            if (decision.action !== "duplicate") {
-                const { error } = await supabase.from("memories").insert({
-                    project,
-                    type: "constraint",
-                    content,
-                    device_id: getDeviceId(),
-                });
-                if (!error)
+            if (await trySeedMemory(project, existingMemories, "constraint", content))
+                seededCount++;
+        }
+    }
+    const tsconfigPath = nodePath.join(resolvedPath, "tsconfig.json");
+    if (nodeFs.existsSync(tsconfigPath)) {
+        try {
+            const tsconfig = JSON.parse(nodeFs.readFileSync(tsconfigPath, "utf-8"));
+            const target = tsconfig.compilerOptions?.target;
+            const moduleKind = tsconfig.compilerOptions?.module;
+            if (target || moduleKind) {
+                const content = `TypeScript config: target=${target ?? "unspecified"}, module=${moduleKind ?? "unspecified"}`;
+                if (await trySeedMemory(project, existingMemories, "constraint", content))
                     seededCount++;
             }
         }
+        catch {
+            // Malformed tsconfig.json (or JSONC with comments) — skip.
+        }
+    }
+    const readmePath = nodePath.join(resolvedPath, "README.md");
+    if (nodeFs.existsSync(readmePath)) {
+        const words = nodeFs
+            .readFileSync(readmePath, "utf-8")
+            .split(/\s+/)
+            .filter(Boolean)
+            .slice(0, 100);
+        if (words.length > 0) {
+            const content = `project description: ${words.join(" ")}`;
+            if (await trySeedMemory(project, existingMemories, "discovery", content))
+                seededCount++;
+        }
+    }
+    const FRAMEWORK_FILE_INDICATORS = [
+        { file: "next.config.ts", type: "constraint", content: "framework: Next.js" },
+        { file: "next.config.js", type: "constraint", content: "framework: Next.js" },
+        { file: "vite.config.ts", type: "constraint", content: "framework: Vite" },
+        { file: "vite.config.js", type: "constraint", content: "framework: Vite" },
+        { file: "Dockerfile", type: "constraint", content: "containerized: Docker" },
+    ];
+    for (const indicator of FRAMEWORK_FILE_INDICATORS) {
+        if (!nodeFs.existsSync(nodePath.join(resolvedPath, indicator.file)))
+            continue;
+        if (await trySeedMemory(project, existingMemories, indicator.type, indicator.content))
+            seededCount++;
+    }
+    const githubWorkflowsPath = nodePath.join(resolvedPath, ".github", "workflows");
+    if (nodeFs.existsSync(githubWorkflowsPath)) {
+        const content = "CI/CD: GitHub Actions";
+        if (await trySeedMemory(project, existingMemories, "discovery", content))
+            seededCount++;
     }
     analyzeCodebase(resolvedPath);
     return seededCount;

package/dist/index.js

@@ -89,8 +89,12 @@ server.registerTool("session_start", {
     const budgetText = omittedCount > 0
         ? `Loaded ${memories.length} memory row(s) for "${project}" (${tokensUsed}/${CONTEXT_BUDGET_TOKENS} tokens used, ${omittedCount} omitted for budget).`
         : `Loaded ${memories.length} memory row(s) for "${project}" (${tokensUsed}/${CONTEXT_BUDGET_TOKENS} tokens used).`;
+    const hasTechStackMemory = memories.some((m) => /^tech stack:/i.test(m.content));
+    const techStackTip = hasTechStackMemory
+        ? ""
+        : "\n\nTip: run 'cm init' to seed tech stack memories from your project files.";
     return {
-        content: [{ type: "text", text: budgetText }],
+        content: [{ type: "text", text: budgetText + techStackTip }],
         structuredContent: {
             memories: memoriesWithLinks,
             fixes,

package/dist/scoring.js

@@ -3,10 +3,31 @@ const STOP_WORDS = new Set([
     "we", "use", "for", "all", "a", "the", "is", "has", "have", "are", "to",
     "of", "in", "it", "this", "that", "with", "and", "or", "but",
 ]);
+// Bumping this from 5 to 6 was considered (see the benchmark's duplicate-
+// detection findings) but doesn't actually fix anything: "removed" is 7
+// chars and "added"/"dependency" aren't the problem either. The real issue
+// is entity-level, not length-based — see DEPENDENCY_TEMPLATE_RE below.
 const MIN_ENTITY_LENGTH = 5;
+// Hook-generated dependency-change templates ("removed dependency: X" /
+// "added dependency: X") reduce to just {"removed"/"added", "dependency"}
+// under generic word-based extraction below, since package names are often
+// short (node:path, zod, ./device.js — all filtered by MIN_ENTITY_LENGTH).
+// That made two DIFFERENT packages removed in different commits look like
+// duplicates of each other. Special-cased here instead: for these
+// templates, the package name itself is the only entity, so containment
+// (and hybridScore) only agrees when the package name actually matches.
+const DEPENDENCY_TEMPLATE_RE = /^(removed|added) dependency:/i;
+const DEPENDENCY_PACKAGE_RE = /^(?:removed|added) dependency:\s*(.+)$/i;
+function extractDependencyPackageName(content) {
+    const match = DEPENDENCY_PACKAGE_RE.exec(content.trim());
+    return match ? match[1].trim().toLowerCase() : null;
+}
 // Key entities: words longer than 4 characters that aren't stop words.
 // Short/common words carry little identifying signal for a memory.
 export function extractEntities(text) {
+    const packageName = extractDependencyPackageName(text);
+    if (packageName !== null)
+        return new Set([packageName]);
     const entities = new Set();
     for (const word of text.toLowerCase().split(/\W+/)) {
         if (word.length < MIN_ENTITY_LENGTH || STOP_WORDS.has(word))
@@ -29,13 +50,58 @@ export function containmentScore(entitiesA, entitiesB) {
     }
     return shared / smallerSize;
 }
+function trigramSet(text) {
+    const normalized = text.toLowerCase();
+    if (normalized.length < 3) {
+        return normalized.length > 0 ? new Set([normalized]) : new Set();
+    }
+    const trigrams = new Set();
+    for (let i = 0; i <= normalized.length - 3; i++) {
+        trigrams.add(normalized.slice(i, i + 3));
+    }
+    return trigrams;
+}
+// Character-trigram Jaccard overlap: catches surface-level lexical
+// similarity (typos, partial substrings, shared phrasing) that word-based
+// containment misses entirely, since containment only ever compares whole
+// extracted entities.
+function ngramOverlap(a, b) {
+    const trigramsA = trigramSet(a);
+    const trigramsB = trigramSet(b);
+    const union = new Set([...trigramsA, ...trigramsB]);
+    if (union.size === 0)
+        return 0;
+    let shared = 0;
+    for (const trigram of trigramsA) {
+        if (trigramsB.has(trigram))
+            shared++;
+    }
+    return shared / union.size;
+}
+// Blends entity containment (structural: do the two texts share key
+// extracted terms) with character-trigram overlap (lexical: do the two
+// texts look alike as raw strings) so near-duplicates with slightly
+// different wording still score high even when their extracted entities
+// don't line up neatly, and vice versa.
+//
+// NOTE ON THRESHOLDS: DUPLICATE_THRESHOLD (0.85), CONTRADICTION_MIN (0.4),
+// computeMemoryLinks' default (0.15), and CLUSTER_THRESHOLD (0.2) were all
+// tuned against pure containmentScore. The 0.3 trigram component shifts
+// scores upward for almost any pair sharing common substrings (whitespace,
+// "ing", "the", etc.), so these thresholds may need recalibration —
+// re-validate against src/benchmark.ts rather than assuming they still
+// hold as-is.
+export function hybridScore(a, b) {
+    const containment = containmentScore(extractEntities(a), extractEntities(b));
+    const overlap = ngramOverlap(a, b);
+    return containment * 0.7 + overlap * 0.3;
+}
 export function computeMemoryLinks(newMemoryId, newContent, existingMemories, threshold = 0.15) {
-    const newEntities = extractEntities(newContent);
     return existingMemories
         .map((existing) => ({
         source_id: newMemoryId,
         target_id: existing.id,
-        score: containmentScore(newEntities, extractEntities(existing.content)),
+        score: hybridScore(newContent, existing.content),
     }))
         .filter((link) => link.score > threshold);
 }
@@ -52,11 +118,6 @@ function containsNegationWord(text) {
     const lower = text.toLowerCase();
     return NEGATION_WORDS.some((word) => lower.includes(word));
 }
-// Hook-generated dependency-change templates (e.g. "removed dependency: X")
-// are structural facts, not decisions — "removed" trips the negation-word
-// check below, but there's nothing for them to supersede/contradict, so
-// they're exempted up front rather than ever entering the negation branch.
-const DEPENDENCY_TEMPLATE_RE = /^(removed|added) dependency:/i;
 // Decides whether a new memory is a near-duplicate of an existing one
 // (skip it), supersedes an existing one (resolve the old, insert the new),
 // or is genuinely new. A negation word (e.g. "switched", "no longer")
@@ -66,12 +127,15 @@ const DEPENDENCY_TEMPLATE_RE = /^(removed|added) dependency:/i;
 // Scanning finds the best-scoring match in each band rather than stopping
 // at the first hit, so the result doesn't depend on row order.
 export function decideSaveAction(newContent, existingMemories) {
-    const newEntities = extractEntities(newContent);
+    // Dependency-change templates are structural facts, not decisions —
+    // "removed"/"added" would otherwise trip containsNegationWord below, but
+    // there's nothing for them to supersede/contradict, so they're exempted
+    // up front and only ever fall through to the plain duplicate check.
     const hasNegation = DEPENDENCY_TEMPLATE_RE.test(newContent) ? false : containsNegationWord(newContent);
     let bestDuplicate = null;
     let bestSupersede = null;
     for (const existing of existingMemories) {
-        const score = containmentScore(newEntities, extractEntities(existing.content));
+        const score = hybridScore(newContent, existing.content);
         if (score > DUPLICATE_THRESHOLD) {
             if (hasNegation) {
                 if (!bestSupersede || score > bestSupersede.score) {
@@ -144,10 +208,9 @@ export function clusterMemories(memories) {
         if (rootA !== rootB)
             parent[rootA] = rootB;
     }
-    const entities = memories.map((memory) => extractEntities(memory.content));
     for (let i = 0; i < memories.length; i++) {
         for (let j = i + 1; j < memories.length; j++) {
-            if (containmentScore(entities[i], entities[j]) > CLUSTER_THRESHOLD) {
+            if (hybridScore(memories[i].content, memories[j].content) > CLUSTER_THRESHOLD) {
                 union(i, j);
             }
         }
@@ -248,11 +311,12 @@ function splitWords(text) {
         .split(/\s+/)
         .filter((word) => word.length > 0 && !STOP_WORDS.has(word));
 }
-// Blends entity containment (structural overlap) with raw word overlap
-// (surface-level phrasing match) so a memory that shares the task's exact
-// wording scores well even if its extracted entities don't line up neatly.
+// Blends hybrid structural/lexical overlap (see hybridScore) with raw word
+// overlap (surface-level phrasing match) so a memory that shares the task's
+// exact wording scores well even if its extracted entities don't line up
+// neatly.
 export function scoreMemoryRelevance(memoryContent, task) {
-    const containment = containmentScore(extractEntities(memoryContent), extractEntities(task));
+    const structuralScore = hybridScore(memoryContent, task);
     const memoryWords = new Set(splitWords(memoryContent));
     const taskWords = splitWords(task);
     let shared = 0;
@@ -261,6 +325,6 @@ export function scoreMemoryRelevance(memoryContent, task) {
             shared++;
     }
     const wordOverlapRatio = taskWords.length === 0 ? 0 : shared / taskWords.length;
-    return containment * 0.7 + wordOverlapRatio * 0.3;
+    return structuralScore * 0.7 + wordOverlapRatio * 0.3;
 }
 // TODO: optimize the clustering algorithm

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stackmem",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "description": "",
   "main": "index.js",
   "type": "module",

package/src/benchmark.ts

@@ -11,10 +11,10 @@ import { fileURLToPath } from "node:url";
 import {
   applyContextBudget,
   computeDecayScore,
-  containmentScore,
   decideSaveAction,
   estimateTokens,
   extractEntities,
+  hybridScore,
   scoreMemoryRelevance,
   type ExistingMemory,
 } from "./scoring.js";
@@ -407,7 +407,18 @@ function benchmarkContradictionDetection(
   allMemories: MemoryRow[],
   unrelatedPairs: [MemoryRow, MemoryRow][]
 ): ContradictionDetectionResult {
-  const baseSample = seededShuffle(allMemories, BENCHMARK_SEED + 2).slice(0, SAMPLE_SIZE / 2);
+  // Hook-generated templates (dependency changes, config/schema/TODO
+  // discoveries) are structural event records, not decisions — decideSaveAction
+  // deliberately exempts dependency templates from ever routing to
+  // "superseded" (see DEPENDENCY_TEMPLATE_RE in scoring.ts), and prepending
+  // "switched from X" to any of these templates isn't a phrase anyone would
+  // actually write. Sampling them here would just measure whether that
+  // exemption holds, not whether contradiction detection works — so they're
+  // excluded, keeping this test on genuine decision/discovery-style content.
+  const contradictableMemories = allMemories.filter(
+    (m) => !HOOK_TEMPLATE_PREFIXES.some((p) => m.content.startsWith(p.prefix))
+  );
+  const baseSample = seededShuffle(contradictableMemories, BENCHMARK_SEED + 2).slice(0, SAMPLE_SIZE / 2);
 
   let tp = 0;
   let fn = 0;
@@ -457,6 +468,14 @@ interface SemanticLinkingResult {
 // exhaustively rather than randomly sampled — at this data size (a few
 // thousand possible pairs at most) exhaustive is cheap and gives a more
 // stable number than a small random draw would.
+//
+// CAVEAT: avgLinkScore below reads memory_links.score as stored — i.e.
+// whatever computeMemoryLinks computed at save time. Rows saved before
+// computeMemoryLinks switched from containmentScore to hybridScore still
+// hold old-formula scores; only the baseline here is guaranteed to reflect
+// the current formula (it's computed live). A mixed-vintage avgLinkScore
+// vs. a current-formula baseline is still the most honest comparison
+// available without backfilling every historical link.
 function benchmarkSemanticLinking(allMemories: MemoryRow[], allLinks: MemoryLinkRow[]): SemanticLinkingResult {
   const avgLinkScore =
     allLinks.length === 0 ? 0 : allLinks.reduce((sum, l) => sum + l.score, 0) / allLinks.length;
@@ -472,12 +491,11 @@ function benchmarkSemanticLinking(allMemories: MemoryRow[], allLinks: MemoryLink
   let baselineSum = 0;
   let baselineCount = 0;
   for (const rows of byProject.values()) {
-    const entitiesById = new Map(rows.map((m) => [m.id, extractEntities(m.content)]));
     for (let i = 0; i < rows.length; i++) {
       for (let j = i + 1; j < rows.length; j++) {
         const key = pairKey(rows[i].id, rows[j].id);
         if (linkedPairKeys.has(key)) continue;
-        baselineSum += containmentScore(entitiesById.get(rows[i].id)!, entitiesById.get(rows[j].id)!);
+        baselineSum += hybridScore(rows[i].content, rows[j].content);
         baselineCount++;
       }
     }

package/src/cli.ts

@@ -270,6 +270,8 @@ async function cmdStart(project: string) {
   const memories = data ?? [];
   if (memories.length === 0) {
     console.log(`No memories found for "${project}".`);
+    console.log("");
+    console.log("Tip: run 'cm init' to seed tech stack memories from your project files.");
     return;
   }
 
@@ -358,6 +360,12 @@ async function cmdStart(project: string) {
     console.log(`${omittedCount} memories omitted (budget exceeded)`);
   }
 
+  const hasTechStackMemory = memories.some((m) => /^tech stack:/i.test(m.content));
+  if (!hasTechStackMemory) {
+    console.log("");
+    console.log("Tip: run 'cm init' to seed tech stack memories from your project files.");
+  }
+
   const incrementResults = await Promise.all(
     budgetedMemories.map((memory) =>
       supabase
@@ -1189,6 +1197,27 @@ function writeProjectFile(project: string, resolvedPath: string): void {
   nodeFs.writeFileSync(stackmemPath, `${project}\n`, "utf-8");
 }
 
+// Shared by every seedMemories check below: skip the insert if this exact
+// content already exists (decideSaveAction's duplicate check) so re-running
+// `cm init` on an already-seeded project doesn't pile up repeats.
+async function trySeedMemory(
+  project: string,
+  existingMemories: { id: string; content: string }[],
+  type: MemoryType,
+  content: string
+): Promise<boolean> {
+  const decision = decideSaveAction(content, existingMemories);
+  if (decision.action === "duplicate") return false;
+
+  const { error } = await supabase.from("memories").insert({
+    project,
+    type,
+    content,
+    device_id: getDeviceId(),
+  });
+  return !error;
+}
+
 // Scans the freshly-initialized project for a few cheap, high-signal facts
 // and saves them as memories directly (bypassing cmdSave's duplicate/conflict
 // prompt — there's nothing to conflict with yet, and init must stay
@@ -1216,16 +1245,7 @@ async function seedMemories(project: string, resolvedPath: string): Promise<numb
       ];
       if (depNames.length > 0) {
         const content = `tech stack: ${depNames.join(", ")}`;
-        const decision = decideSaveAction(content, existingMemories);
-        if (decision.action !== "duplicate") {
-          const { error } = await supabase.from("memories").insert({
-            project,
-            type: "discovery",
-            content,
-            device_id: getDeviceId(),
-          });
-          if (!error) seededCount++;
-        }
+        if (await trySeedMemory(project, existingMemories, "discovery", content)) seededCount++;
       }
     } catch {
       // Malformed package.json — skip the tech-stack memory.
@@ -1242,19 +1262,56 @@ async function seedMemories(project: string, resolvedPath: string): Promise<numb
 
     if (varNames.length > 0) {
       const content = `required env vars: ${varNames.join(", ")}`;
-      const decision = decideSaveAction(content, existingMemories);
-      if (decision.action !== "duplicate") {
-        const { error } = await supabase.from("memories").insert({
-          project,
-          type: "constraint",
-          content,
-          device_id: getDeviceId(),
-        });
-        if (!error) seededCount++;
+      if (await trySeedMemory(project, existingMemories, "constraint", content)) seededCount++;
+    }
+  }
+
+  const tsconfigPath = nodePath.join(resolvedPath, "tsconfig.json");
+  if (nodeFs.existsSync(tsconfigPath)) {
+    try {
+      const tsconfig = JSON.parse(nodeFs.readFileSync(tsconfigPath, "utf-8"));
+      const target = tsconfig.compilerOptions?.target;
+      const moduleKind = tsconfig.compilerOptions?.module;
+      if (target || moduleKind) {
+        const content = `TypeScript config: target=${target ?? "unspecified"}, module=${moduleKind ?? "unspecified"}`;
+        if (await trySeedMemory(project, existingMemories, "constraint", content)) seededCount++;
       }
+    } catch {
+      // Malformed tsconfig.json (or JSONC with comments) — skip.
+    }
+  }
+
+  const readmePath = nodePath.join(resolvedPath, "README.md");
+  if (nodeFs.existsSync(readmePath)) {
+    const words = nodeFs
+      .readFileSync(readmePath, "utf-8")
+      .split(/\s+/)
+      .filter(Boolean)
+      .slice(0, 100);
+    if (words.length > 0) {
+      const content = `project description: ${words.join(" ")}`;
+      if (await trySeedMemory(project, existingMemories, "discovery", content)) seededCount++;
     }
   }
 
+  const FRAMEWORK_FILE_INDICATORS: { file: string; type: MemoryType; content: string }[] = [
+    { file: "next.config.ts", type: "constraint", content: "framework: Next.js" },
+    { file: "next.config.js", type: "constraint", content: "framework: Next.js" },
+    { file: "vite.config.ts", type: "constraint", content: "framework: Vite" },
+    { file: "vite.config.js", type: "constraint", content: "framework: Vite" },
+    { file: "Dockerfile", type: "constraint", content: "containerized: Docker" },
+  ];
+  for (const indicator of FRAMEWORK_FILE_INDICATORS) {
+    if (!nodeFs.existsSync(nodePath.join(resolvedPath, indicator.file))) continue;
+    if (await trySeedMemory(project, existingMemories, indicator.type, indicator.content)) seededCount++;
+  }
+
+  const githubWorkflowsPath = nodePath.join(resolvedPath, ".github", "workflows");
+  if (nodeFs.existsSync(githubWorkflowsPath)) {
+    const content = "CI/CD: GitHub Actions";
+    if (await trySeedMemory(project, existingMemories, "discovery", content)) seededCount++;
+  }
+
   analyzeCodebase(resolvedPath);
 
   return seededCount;

package/src/index.ts

@@ -129,8 +129,13 @@ server.registerTool(
         ? `Loaded ${memories.length} memory row(s) for "${project}" (${tokensUsed}/${CONTEXT_BUDGET_TOKENS} tokens used, ${omittedCount} omitted for budget).`
         : `Loaded ${memories.length} memory row(s) for "${project}" (${tokensUsed}/${CONTEXT_BUDGET_TOKENS} tokens used).`;
 
+    const hasTechStackMemory = memories.some((m) => /^tech stack:/i.test(m.content));
+    const techStackTip = hasTechStackMemory
+      ? ""
+      : "\n\nTip: run 'cm init' to seed tech stack memories from your project files.";
+
     return {
-      content: [{ type: "text", text: budgetText }],
+      content: [{ type: "text", text: budgetText + techStackTip }],
       structuredContent: {
         memories: memoriesWithLinks,
         fixes,

package/src/scoring.ts

@@ -5,11 +5,34 @@ const STOP_WORDS = new Set([
   "of", "in", "it", "this", "that", "with", "and", "or", "but",
 ]);
 
+// Bumping this from 5 to 6 was considered (see the benchmark's duplicate-
+// detection findings) but doesn't actually fix anything: "removed" is 7
+// chars and "added"/"dependency" aren't the problem either. The real issue
+// is entity-level, not length-based — see DEPENDENCY_TEMPLATE_RE below.
 const MIN_ENTITY_LENGTH = 5;
 
+// Hook-generated dependency-change templates ("removed dependency: X" /
+// "added dependency: X") reduce to just {"removed"/"added", "dependency"}
+// under generic word-based extraction below, since package names are often
+// short (node:path, zod, ./device.js — all filtered by MIN_ENTITY_LENGTH).
+// That made two DIFFERENT packages removed in different commits look like
+// duplicates of each other. Special-cased here instead: for these
+// templates, the package name itself is the only entity, so containment
+// (and hybridScore) only agrees when the package name actually matches.
+const DEPENDENCY_TEMPLATE_RE = /^(removed|added) dependency:/i;
+const DEPENDENCY_PACKAGE_RE = /^(?:removed|added) dependency:\s*(.+)$/i;
+
+function extractDependencyPackageName(content: string): string | null {
+  const match = DEPENDENCY_PACKAGE_RE.exec(content.trim());
+  return match ? match[1].trim().toLowerCase() : null;
+}
+
 // Key entities: words longer than 4 characters that aren't stop words.
 // Short/common words carry little identifying signal for a memory.
 export function extractEntities(text: string): Set<string> {
+  const packageName = extractDependencyPackageName(text);
+  if (packageName !== null) return new Set([packageName]);
+
   const entities = new Set<string>();
   for (const word of text.toLowerCase().split(/\W+/)) {
     if (word.length < MIN_ENTITY_LENGTH || STOP_WORDS.has(word)) continue;
@@ -33,6 +56,55 @@ export function containmentScore(entitiesA: Set<string>, entitiesB: Set<string>)
   return shared / smallerSize;
 }
 
+function trigramSet(text: string): Set<string> {
+  const normalized = text.toLowerCase();
+  if (normalized.length < 3) {
+    return normalized.length > 0 ? new Set([normalized]) : new Set();
+  }
+
+  const trigrams = new Set<string>();
+  for (let i = 0; i <= normalized.length - 3; i++) {
+    trigrams.add(normalized.slice(i, i + 3));
+  }
+  return trigrams;
+}
+
+// Character-trigram Jaccard overlap: catches surface-level lexical
+// similarity (typos, partial substrings, shared phrasing) that word-based
+// containment misses entirely, since containment only ever compares whole
+// extracted entities.
+function ngramOverlap(a: string, b: string): number {
+  const trigramsA = trigramSet(a);
+  const trigramsB = trigramSet(b);
+  const union = new Set([...trigramsA, ...trigramsB]);
+  if (union.size === 0) return 0;
+
+  let shared = 0;
+  for (const trigram of trigramsA) {
+    if (trigramsB.has(trigram)) shared++;
+  }
+  return shared / union.size;
+}
+
+// Blends entity containment (structural: do the two texts share key
+// extracted terms) with character-trigram overlap (lexical: do the two
+// texts look alike as raw strings) so near-duplicates with slightly
+// different wording still score high even when their extracted entities
+// don't line up neatly, and vice versa.
+//
+// NOTE ON THRESHOLDS: DUPLICATE_THRESHOLD (0.85), CONTRADICTION_MIN (0.4),
+// computeMemoryLinks' default (0.15), and CLUSTER_THRESHOLD (0.2) were all
+// tuned against pure containmentScore. The 0.3 trigram component shifts
+// scores upward for almost any pair sharing common substrings (whitespace,
+// "ing", "the", etc.), so these thresholds may need recalibration —
+// re-validate against src/benchmark.ts rather than assuming they still
+// hold as-is.
+export function hybridScore(a: string, b: string): number {
+  const containment = containmentScore(extractEntities(a), extractEntities(b));
+  const overlap = ngramOverlap(a, b);
+  return containment * 0.7 + overlap * 0.3;
+}
+
 // --- memory links ------------------------------------------------------
 
 export interface ExistingMemory {
@@ -52,12 +124,11 @@ export function computeMemoryLinks(
   existingMemories: ExistingMemory[],
   threshold = 0.15
 ): MemoryLink[] {
-  const newEntities = extractEntities(newContent);
   return existingMemories
     .map((existing) => ({
       source_id: newMemoryId,
       target_id: existing.id,
-      score: containmentScore(newEntities, extractEntities(existing.content)),
+      score: hybridScore(newContent, existing.content),
     }))
     .filter((link) => link.score > threshold);
 }
@@ -79,12 +150,6 @@ function containsNegationWord(text: string): boolean {
   return NEGATION_WORDS.some((word) => lower.includes(word));
 }
 
-// Hook-generated dependency-change templates (e.g. "removed dependency: X")
-// are structural facts, not decisions — "removed" trips the negation-word
-// check below, but there's nothing for them to supersede/contradict, so
-// they're exempted up front rather than ever entering the negation branch.
-const DEPENDENCY_TEMPLATE_RE = /^(removed|added) dependency:/i;
-
 export type SaveAction =
   | { action: "duplicate"; matchedId: string }
   | { action: "superseded"; oldId: string }
@@ -102,14 +167,17 @@ export function decideSaveAction(
   newContent: string,
   existingMemories: ExistingMemory[]
 ): SaveAction {
-  const newEntities = extractEntities(newContent);
+  // Dependency-change templates are structural facts, not decisions —
+  // "removed"/"added" would otherwise trip containsNegationWord below, but
+  // there's nothing for them to supersede/contradict, so they're exempted
+  // up front and only ever fall through to the plain duplicate check.
   const hasNegation = DEPENDENCY_TEMPLATE_RE.test(newContent) ? false : containsNegationWord(newContent);
 
   let bestDuplicate: { id: string; score: number } | null = null;
   let bestSupersede: { id: string; score: number } | null = null;
 
   for (const existing of existingMemories) {
-    const score = containmentScore(newEntities, extractEntities(existing.content));
+    const score = hybridScore(newContent, existing.content);
 
     if (score > DUPLICATE_THRESHOLD) {
       if (hasNegation) {
@@ -192,11 +260,9 @@ export function clusterMemories(memories: any[]): any[][] {
     if (rootA !== rootB) parent[rootA] = rootB;
   }
 
-  const entities = memories.map((memory) => extractEntities(memory.content));
-
   for (let i = 0; i < memories.length; i++) {
     for (let j = i + 1; j < memories.length; j++) {
-      if (containmentScore(entities[i], entities[j]) > CLUSTER_THRESHOLD) {
+      if (hybridScore(memories[i].content, memories[j].content) > CLUSTER_THRESHOLD) {
         union(i, j);
       }
     }
@@ -313,11 +379,12 @@ function splitWords(text: string): string[] {
     .filter((word) => word.length > 0 && !STOP_WORDS.has(word));
 }
 
-// Blends entity containment (structural overlap) with raw word overlap
-// (surface-level phrasing match) so a memory that shares the task's exact
-// wording scores well even if its extracted entities don't line up neatly.
+// Blends hybrid structural/lexical overlap (see hybridScore) with raw word
+// overlap (surface-level phrasing match) so a memory that shares the task's
+// exact wording scores well even if its extracted entities don't line up
+// neatly.
 export function scoreMemoryRelevance(memoryContent: string, task: string): number {
-  const containment = containmentScore(extractEntities(memoryContent), extractEntities(task));
+  const structuralScore = hybridScore(memoryContent, task);
 
   const memoryWords = new Set(splitWords(memoryContent));
   const taskWords = splitWords(task);
@@ -328,6 +395,6 @@ export function scoreMemoryRelevance(memoryContent: string, task: string): numbe
   }
   const wordOverlapRatio = taskWords.length === 0 ? 0 : shared / taskWords.length;
 
-  return containment * 0.7 + wordOverlapRatio * 0.3;
+  return structuralScore * 0.7 + wordOverlapRatio * 0.3;
 }
 // TODO: optimize the clustering algorithm