@rlabs-inc/memory 0.3.7 → 0.3.9

package/dist/index.mjs

@@ -12098,6 +12098,11 @@ var managementLogSchema = {
   error: "string",
   details: "string"
 };
+var personalPrimerSchema = {
+  content: "string",
+  session_updated: "number",
+  updated_by: "string"
+};
 
 // src/core/store.ts
 var PERSONAL_PRIMER_ID = "personal-primer";
@@ -12119,7 +12124,7 @@ class MemoryStore {
       return this._global;
     }
     const globalPath = this._config.globalPath;
-    console.log(`\uD83C\uDF10 [DEBUG] Creating global database at ${globalPath}`);
+    console.log(`\uD83C\uDF10 [DEBUG] Initializing global database at ${globalPath}`);
     const db = createDatabase({
       name: "global",
       basePath: globalPath
@@ -12136,8 +12141,14 @@ class MemoryStore {
       autoSave: true,
       watchFiles: this._config.watchFiles
     });
-    await Promise.all([memories.load(), managementLogs.load()]);
-    this._global = { db, memories, managementLogs };
+    const primer = db.collection("primer", {
+      schema: personalPrimerSchema,
+      contentColumn: "content",
+      autoSave: true,
+      watchFiles: this._config.watchFiles
+    });
+    await Promise.all([memories.load(), managementLogs.load(), primer.load()]);
+    this._global = { db, memories, managementLogs, primer };
     return this._global;
   }
   async getGlobalMemories() {
@@ -12214,40 +12225,31 @@ class MemoryStore {
     return id;
   }
   async getPersonalPrimer() {
-    const { memories } = await this.getGlobal();
-    const primer = memories.get(PERSONAL_PRIMER_ID);
-    if (!primer) {
+    const { primer } = await this.getGlobal();
+    const record = primer.get(PERSONAL_PRIMER_ID);
+    if (!record) {
       return null;
     }
     return {
-      content: primer.content,
-      updated: primer.updated
+      content: record.content,
+      updated: record.updated
     };
   }
-  async setPersonalPrimer(content) {
-    const { memories } = await this.getGlobal();
-    const existing = memories.get(PERSONAL_PRIMER_ID);
+  async setPersonalPrimer(content, sessionNumber, updatedBy = "user") {
+    const { primer } = await this.getGlobal();
+    const existing = primer.get(PERSONAL_PRIMER_ID);
     if (existing) {
-      memories.update(PERSONAL_PRIMER_ID, { content });
+      primer.update(PERSONAL_PRIMER_ID, {
+        content,
+        session_updated: sessionNumber ?? existing.session_updated,
+        updated_by: updatedBy
+      });
     } else {
-      memories.insert({
+      primer.insert({
         id: PERSONAL_PRIMER_ID,
         content,
-        reasoning: "Personal relationship context injected at session start",
-        importance_weight: 1,
-        confidence_score: 1,
-        context_type: "personal",
-        temporal_relevance: "persistent",
-        knowledge_domain: "personal",
-        emotional_resonance: "neutral",
-        action_required: false,
-        problem_solution_pair: false,
-        semantic_tags: ["personal", "primer", "relationship"],
-        trigger_phrases: [],
-        question_types: [],
-        session_id: "system",
-        project_id: "global",
-        embedding: null
+        session_updated: sessionNumber ?? 0,
+        updated_by: updatedBy
       });
     }
   }
@@ -12267,6 +12269,7 @@ class MemoryStore {
       success: entry.success,
       duration_ms: entry.durationMs,
       summary: entry.summary,
+      full_report: entry.fullReport ?? "",
       error: entry.error ?? "",
       details: entry.details ? JSON.stringify(entry.details) : ""
     });
@@ -12630,7 +12633,14 @@ var sym = {
   fire: "\uD83D\uDD25",
   target: "\uD83C\uDFAF"
 };
+var _verbose = false;
 var logger = {
+  setVerbose(enabled) {
+    _verbose = enabled;
+  },
+  isVerbose() {
+    return _verbose;
+  },
   info(message) {
     console.log(`${timestamp()} ${style("cyan", sym.info)} ${message}`);
   },
@@ -12702,7 +12712,14 @@ var logger = {
       problem_solution: "✅",
       project_context: "\uD83D\uDCE6",
       milestone: "\uD83C\uDFC6",
-      general: "\uD83D\uDCDD"
+      general: "\uD83D\uDCDD",
+      project_state: "\uD83D\uDCCD",
+      pending_task: "⏳",
+      work_in_progress: "\uD83D\uDD28",
+      system_feedback: "\uD83D\uDCE3",
+      project_milestone: "\uD83C\uDFC6",
+      architectural_insight: "\uD83C\uDFDB️",
+      architectural_direction: "\uD83E\uDDED"
     };
     console.log();
     console.log(`${timestamp()} ${style("cyan", sym.sparkles)} ${style("bold", `SURFACING ${memories.length} MEMORIES`)}`);
@@ -12714,11 +12731,12 @@ var logger = {
       return;
     }
     memories.forEach((m, i) => {
-      const score = style("green", `${(m.score * 100).toFixed(0)}%`);
+      const signalCount = Math.round(m.score * 6);
+      const signalStr = style("green", `${signalCount}sig`);
       const emoji = emojiMap[m.context_type?.toLowerCase()] ?? "\uD83D\uDCDD";
       const num = style("dim", `${i + 1}.`);
       const preview = m.content.length > 55 ? m.content.slice(0, 55) + style("dim", "...") : m.content;
-      console.log(`   ${num} [${score}] ${emoji}`);
+      console.log(`   ${num} [${signalStr}] ${emoji}`);
       console.log(`      ${preview}`);
     });
     console.log();
@@ -12766,44 +12784,124 @@ var logger = {
     console.log(`      ${style("dim", "processing:")} ${memoriesCount} new memories`);
   },
   logManagementComplete(result) {
+    const formatAction = (action, truncate = true) => {
+      let icon = "  •";
+      if (action.startsWith("READ OK"))
+        icon = style("dim", "  \uD83D\uDCD6");
+      else if (action.startsWith("READ FAILED"))
+        icon = style("red", "  ❌");
+      else if (action.startsWith("WRITE OK"))
+        icon = style("green", "  ✏️");
+      else if (action.startsWith("WRITE FAILED"))
+        icon = style("red", "  ❌");
+      else if (action.startsWith("RECEIVED"))
+        icon = style("cyan", "  \uD83D\uDCE5");
+      else if (action.startsWith("CREATED"))
+        icon = style("green", "  ✨");
+      else if (action.startsWith("UPDATED"))
+        icon = style("blue", "  \uD83D\uDCDD");
+      else if (action.startsWith("SUPERSEDED"))
+        icon = style("yellow", "  \uD83D\uDD04");
+      else if (action.startsWith("RESOLVED"))
+        icon = style("green", "  ✅");
+      else if (action.startsWith("LINKED"))
+        icon = style("cyan", "  \uD83D\uDD17");
+      else if (action.startsWith("PRIMER"))
+        icon = style("magenta", "  \uD83D\uDC9C");
+      else if (action.startsWith("SKIPPED"))
+        icon = style("dim", "  ⏭️");
+      else if (action.startsWith("NO_ACTION"))
+        icon = style("dim", "  ◦");
+      const text = truncate && action.length > 70 ? action.slice(0, 67) + "..." : action;
+      return `${icon} ${style("dim", text)}`;
+    };
     if (result.success) {
       console.log(`      ${style("green", sym.check)} ${style("bold", "Completed")}`);
-      const stats = [];
-      if (result.superseded && result.superseded > 0) {
-        stats.push(`${result.superseded} superseded`);
-      }
-      if (result.resolved && result.resolved > 0) {
-        stats.push(`${result.resolved} resolved`);
-      }
-      if (result.linked && result.linked > 0) {
-        stats.push(`${result.linked} linked`);
-      }
-      if (result.primerUpdated) {
-        stats.push("primer updated");
-      }
-      if (stats.length > 0) {
-        console.log(`      ${style("dim", "changes:")} ${stats.join(style("dim", ", "))}`);
+      if (_verbose) {
+        console.log(`      ${style("dim", "─".repeat(50))}`);
+        console.log(`      ${style("cyan", "\uD83D\uDCCA")} ${style("bold", "Statistics")}`);
+        const filesRead = result.filesRead ?? 0;
+        const filesWritten = result.filesWritten ?? 0;
+        console.log(`         ${style("dim", "Files read:")}    ${filesRead > 0 ? style("green", String(filesRead)) : style("dim", "0")}`);
+        console.log(`         ${style("dim", "Files written:")} ${filesWritten > 0 ? style("green", String(filesWritten)) : style("dim", "0")}`);
+        const superseded = result.superseded ?? 0;
+        const resolved = result.resolved ?? 0;
+        const linked = result.linked ?? 0;
+        console.log(`         ${style("dim", "Superseded:")}    ${superseded > 0 ? style("yellow", String(superseded)) : style("dim", "0")}`);
+        console.log(`         ${style("dim", "Resolved:")}      ${resolved > 0 ? style("green", String(resolved)) : style("dim", "0")}`);
+        console.log(`         ${style("dim", "Linked:")}        ${linked > 0 ? style("cyan", String(linked)) : style("dim", "0")}`);
+        console.log(`         ${style("dim", "Primer:")}        ${result.primerUpdated ? style("magenta", "updated") : style("dim", "unchanged")}`);
+        if (result.actions && result.actions.length > 0) {
+          console.log(`      ${style("dim", "─".repeat(50))}`);
+          console.log(`      ${style("cyan", "\uD83C\uDFAC")} ${style("bold", "Actions")} ${style("dim", `(${result.actions.length} total)`)}`);
+          for (const action of result.actions) {
+            console.log(`      ${formatAction(action, false)}`);
+          }
+        }
+        if (result.fullReport) {
+          console.log(`      ${style("dim", "─".repeat(50))}`);
+          console.log(`      ${style("cyan", "\uD83D\uDCCB")} ${style("bold", "Full Report")}`);
+          const reportLines = result.fullReport.split(`
+`);
+          for (const line of reportLines) {
+            if (line.includes("===")) {
+              console.log(`         ${style("bold", line)}`);
+            } else if (line.match(/^[A-Z_]+:/)) {
+              console.log(`         ${style("cyan", line)}`);
+            } else {
+              console.log(`         ${style("dim", line)}`);
+            }
+          }
+        }
+        console.log(`      ${style("dim", "─".repeat(50))}`);
       } else {
-        console.log(`      ${style("dim", "changes:")} none (memories are current)`);
-      }
-      if (result.summary) {
-        const shortSummary = result.summary.length > 60 ? result.summary.slice(0, 60) + "..." : result.summary;
-        console.log(`      ${style("dim", "summary:")} ${shortSummary}`);
+        const stats = [];
+        if (result.superseded && result.superseded > 0)
+          stats.push(`${result.superseded} superseded`);
+        if (result.resolved && result.resolved > 0)
+          stats.push(`${result.resolved} resolved`);
+        if (result.linked && result.linked > 0)
+          stats.push(`${result.linked} linked`);
+        if (result.primerUpdated)
+          stats.push("primer updated");
+        if (stats.length > 0) {
+          console.log(`      ${style("dim", "changes:")} ${stats.join(style("dim", ", "))}`);
+        } else {
+          console.log(`      ${style("dim", "changes:")} none (memories are current)`);
+        }
+        if (result.actions && result.actions.length > 0) {
+          console.log(`      ${style("dim", "actions:")}`);
+          for (const action of result.actions.slice(0, 10)) {
+            console.log(`      ${formatAction(action, true)}`);
+          }
+          if (result.actions.length > 10) {
+            console.log(`      ${style("dim", `  ... and ${result.actions.length - 10} more actions`)}`);
+          }
+        }
       }
     } else {
       console.log(`      ${style("yellow", sym.warning)} ${style("bold", "Failed")}`);
       if (result.error) {
-        console.log(`      ${style("dim", "error:")} ${result.error.slice(0, 80)}`);
+        console.log(`      ${style("red", "error:")} ${result.error}`);
+      }
+      if (result.fullReport) {
+        console.log(`      ${style("dim", "─".repeat(50))}`);
+        console.log(`      ${style("red", "\uD83D\uDCCB")} ${style("bold", "Error Report:")}`);
+        const reportLines = result.fullReport.split(`
+`);
+        for (const line of reportLines) {
+          console.log(`         ${style("dim", line)}`);
+        }
       }
     }
     console.log();
   },
   logRetrievalScoring(params) {
-    const { totalMemories, currentMessage, alreadyInjected, preFiltered, globalCount, projectCount, finalCount, selectedMemories } = params;
+    const { totalMemories, currentMessage, alreadyInjected, preFiltered, globalCount, projectCount, finalCount, durationMs, selectedMemories } = params;
+    const timeStr = durationMs !== undefined ? style("cyan", `${durationMs.toFixed(1)}ms`) : "";
     console.log();
-    console.log(`${timestamp()} ${style("magenta", sym.brain)} ${style("bold", "MULTI-DIMENSIONAL RETRIEVAL")}`);
-    console.log(`      ${style("dim", "total:")} ${totalMemories} memories`);
-    console.log(`      ${style("dim", "pre-filtered:")} ${preFiltered} (inactive/excluded/scope)`);
+    console.log(`${timestamp()} ${style("magenta", sym.brain)} ${style("bold", "RETRIEVAL")} ${timeStr}`);
+    console.log(`      ${style("dim", "total:")} ${totalMemories} → ${style("dim", "filtered:")} ${preFiltered} → ${style("dim", "candidates:")} ${totalMemories - preFiltered}`);
     console.log(`      ${style("dim", "already injected:")} ${alreadyInjected}`);
     const msgPreview = currentMessage.length > 60 ? currentMessage.slice(0, 60) + "..." : currentMessage;
     console.log(`      ${style("dim", "message:")} "${msgPreview}"`);
@@ -12822,347 +12920,471 @@ var logger = {
     console.log();
     selectedMemories.forEach((m, i) => {
       const num = style("dim", `${i + 1}.`);
-      const score = style("green", `${(m.score * 100).toFixed(0)}%`);
-      const relevance = style("cyan", `rel:${(m.relevance_score * 100).toFixed(0)}%`);
-      const corr = style("magenta", `corr:${(m.corroboration_score * 100).toFixed(0)}%`);
+      const signalsStr = style("green", `${m.signalCount} signals`);
+      const imp = style("magenta", `imp:${(m.importance_weight * 100).toFixed(0)}%`);
       const type = style("yellow", m.context_type.toUpperCase());
-      const scope = m.isGlobal ? style("blue", "[G]") : "";
-      console.log(`   ${num} [${score} ${relevance} ${corr}] ${type} ${scope}`);
+      const scope = m.isGlobal ? style("blue", " [G]") : "";
+      console.log(`   ${num} [${signalsStr} • ${imp}] ${type}${scope}`);
       const preview = m.content.length > 60 ? m.content.slice(0, 60) + style("dim", "...") : m.content;
       console.log(`      ${style("white", preview)}`);
-      const components = Object.entries(m.components).sort((a, b) => b[1] - a[1]).slice(0, 4).filter(([, v]) => v > 0.1).map(([k, v]) => `${k}:${(v * 100).toFixed(0)}%`).join(", ");
-      if (components) {
-        console.log(`      ${style("dim", "scores:")} ${components}`);
+      const firedSignals = [];
+      if (m.signals.trigger) {
+        firedSignals.push(`trigger:${(m.signals.triggerStrength * 100).toFixed(0)}%`);
+      }
+      if (m.signals.tags) {
+        firedSignals.push(`tags:${m.signals.tagCount}`);
+      }
+      if (m.signals.domain)
+        firedSignals.push("domain");
+      if (m.signals.feature)
+        firedSignals.push("feature");
+      if (m.signals.content)
+        firedSignals.push("content");
+      if (m.signals.vector) {
+        firedSignals.push(`vector:${(m.signals.vectorSimilarity * 100).toFixed(0)}%`);
       }
-      if (m.reasoning) {
-        console.log(`      ${style("dim", m.reasoning)}`);
+      if (firedSignals.length > 0) {
+        console.log(`      ${style("cyan", "signals:")} ${firedSignals.join(", ")}`);
       }
       console.log();
     });
+  },
+  logScoreDistribution(params) {
+    const { totalCandidates, passedGatekeeper, rejectedByGatekeeper, buckets, stats, signalBreakdown } = params;
+    console.log();
+    console.log(style("dim", "      ─".repeat(30)));
+    console.log(`      ${style("bold", "ACTIVATION SIGNALS")}`);
+    console.log();
+    const passRate = totalCandidates > 0 ? (passedGatekeeper / totalCandidates * 100).toFixed(0) : "0";
+    console.log(`      ${style("dim", "Activated:")} ${style("green", String(passedGatekeeper))}/${totalCandidates} (${passRate}%)`);
+    console.log(`      ${style("dim", "Rejected:")}  ${rejectedByGatekeeper} (< 2 signals)`);
+    console.log();
+    if (signalBreakdown && signalBreakdown.total > 0) {
+      console.log(`      ${style("cyan", "Signal Breakdown:")}`);
+      const signals = [
+        { name: "trigger", count: signalBreakdown.trigger },
+        { name: "tags", count: signalBreakdown.tags },
+        { name: "domain", count: signalBreakdown.domain },
+        { name: "feature", count: signalBreakdown.feature },
+        { name: "content", count: signalBreakdown.content },
+        { name: "vector", count: signalBreakdown.vector }
+      ];
+      for (const sig of signals) {
+        const pct = (sig.count / signalBreakdown.total * 100).toFixed(0);
+        const bar = "█".repeat(Math.round(sig.count / signalBreakdown.total * 20));
+        console.log(`        ${sig.name.padEnd(8)} ${bar.padEnd(20)} ${sig.count} (${pct}%)`);
+      }
+      console.log();
+    }
+    if (stats.max > 0) {
+      console.log(`      ${style("cyan", "Signals:")} min=${stats.min} max=${stats.max} mean=${stats.mean}`);
+      console.log();
+    }
+    if (Object.keys(buckets).length > 0) {
+      console.log(`      ${style("bold", "Distribution:")}`);
+      const maxBucketCount = Math.max(...Object.values(buckets), 1);
+      const bucketOrder = ["2 signals", "3 signals", "4 signals", "5 signals", "6 signals"];
+      for (const bucket of bucketOrder) {
+        const count = buckets[bucket] ?? 0;
+        if (count > 0 || bucket === "2 signals") {
+          const barLen = Math.round(count / maxBucketCount * 25);
+          const bar = "█".repeat(barLen) + style("dim", "░".repeat(25 - barLen));
+          const countStr = count.toString().padStart(3);
+          console.log(`      ${style("dim", bucket.padEnd(10))} ${bar} ${style("cyan", countStr)}`);
+        }
+      }
+      console.log();
+    }
   }
 };
 
 // src/core/retrieval.ts
-var TYPE_KEYWORDS = {
-  debug: ["bug", "error", "fix", "broken", "crash", "fails", "exception", "stack trace", "debugging"],
-  unresolved: ["issue", "problem", "stuck", "blocked", "help", "question", "unsure", "unclear"],
-  decision: ["decide", "choice", "option", "should we", "which", "alternative", "tradeoff"],
-  architecture: ["structure", "design", "pattern", "approach", "system", "layer", "architecture"],
-  breakthrough: ["discovered", "realized", "insight", "found that", "aha", "finally", "key insight"],
-  todo: ["need to", "should", "must", "will", "later", "next", "todo"],
-  personal: ["family", "children", "friend", "relationship", "feel", "appreciate", "thank"],
-  philosophy: ["meaning", "consciousness", "existence", "purpose", "believe", "philosophy"],
-  technical: ["implement", "code", "function", "class", "module", "api", "interface"]
-};
-var TEMPORAL_CLASS_SCORES = {
-  eternal: 1,
-  long_term: 0.9,
-  medium_term: 0.7,
-  short_term: 0.5,
-  ephemeral: 0.3
+var GLOBAL_TYPE_PRIORITY = {
+  technical: 1,
+  preference: 2,
+  architectural: 3,
+  workflow: 4,
+  decision: 5,
+  breakthrough: 6,
+  philosophy: 7,
+  personal: 8
 };
+var MIN_ACTIVATION_SIGNALS = 2;
+var STOPWORDS = new Set([
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "to",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "for",
+  "with",
+  "about",
+  "when",
+  "how",
+  "what",
+  "why",
+  "where",
+  "this",
+  "that",
+  "it",
+  "of",
+  "be",
+  "have",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "can",
+  "may",
+  "might",
+  "must",
+  "shall",
+  "has",
+  "had",
+  "been",
+  "being",
+  "i",
+  "you",
+  "we",
+  "they",
+  "he",
+  "she",
+  "my",
+  "your",
+  "our",
+  "its",
+  "his",
+  "her",
+  "their",
+  "if",
+  "then",
+  "else",
+  "so",
+  "as",
+  "from",
+  "by",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "also",
+  "now",
+  "back",
+  "get",
+  "go",
+  "come",
+  "let",
+  "like",
+  "just",
+  "know",
+  "think",
+  "see",
+  "look",
+  "make",
+  "take",
+  "want",
+  "need"
+]);
 
 class SmartVectorRetrieval {
   _extractSignificantWords(text) {
-    const stopWords = new Set([
-      "the",
-      "is",
-      "are",
-      "was",
-      "were",
-      "to",
-      "a",
-      "an",
-      "and",
-      "or",
-      "but",
-      "in",
-      "on",
-      "at",
-      "for",
-      "with",
-      "about",
-      "when",
-      "how",
-      "what",
-      "why",
-      "where",
-      "this",
-      "that",
-      "it",
-      "of",
-      "be",
-      "have",
-      "do",
-      "does",
-      "did",
-      "will",
-      "would",
-      "could",
-      "should",
-      "can",
-      "may",
-      "might",
-      "must",
-      "shall",
-      "has",
-      "had",
-      "been",
-      "being",
-      "i",
-      "you",
-      "we",
-      "they",
-      "he",
-      "she",
-      "my",
-      "your",
-      "our",
-      "its",
-      "his",
-      "her",
-      "their",
-      "if",
-      "then",
-      "else",
-      "so",
-      "as",
-      "from",
-      "by",
-      "into",
-      "through",
-      "during",
-      "before",
-      "after",
-      "above",
-      "below",
-      "up",
-      "down",
-      "out",
-      "off",
-      "over",
-      "under",
-      "again",
-      "further",
-      "once",
-      "here",
-      "there",
-      "all",
-      "each",
-      "few",
-      "more",
-      "most",
-      "other",
-      "some",
-      "such",
-      "no",
-      "nor",
-      "not",
-      "only",
-      "own",
-      "same",
-      "than",
-      "too",
-      "very",
-      "just",
-      "also",
-      "now",
-      "back",
-      "get",
-      "got",
-      "go",
-      "going",
-      "gone",
-      "come",
-      "came",
-      "let",
-      "lets",
-      "hey",
-      "hi",
-      "hello",
-      "ok",
-      "okay"
-    ]);
-    const words = text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+    const words = text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOPWORDS.has(w));
     return new Set(words);
   }
-  _detectContextTypes(message) {
-    const messageLower = message.toLowerCase();
-    const detected = new Set;
-    for (const [type, keywords] of Object.entries(TYPE_KEYWORDS)) {
-      for (const keyword of keywords) {
-        if (messageLower.includes(keyword)) {
-          detected.add(type);
-          break;
-        }
-      }
-    }
-    return detected;
-  }
   _preFilter(memories, currentProjectId, messageLower) {
     return memories.filter((memory) => {
-      if (memory.status && memory.status !== "active") {
+      if (memory.status && memory.status !== "active")
         return false;
-      }
-      if (memory.exclude_from_retrieval === true) {
+      if (memory.exclude_from_retrieval === true)
         return false;
-      }
-      if (memory.superseded_by) {
+      if (memory.superseded_by)
         return false;
-      }
       const isGlobal = memory.scope === "global" || memory.project_id === "global";
-      if (!isGlobal && memory.project_id !== currentProjectId) {
+      if (!isGlobal && memory.project_id !== currentProjectId)
         return false;
-      }
       if (memory.anti_triggers?.length) {
         for (const antiTrigger of memory.anti_triggers) {
-          if (messageLower.includes(antiTrigger.toLowerCase())) {
+          if (messageLower.includes(antiTrigger.toLowerCase()))
             return false;
-          }
         }
       }
       return true;
     });
   }
-  _calculateCorroboration(memory, messageWords, detectedTypes, messageLower) {
-    const signals = [];
+  _checkTriggerActivation(messageLower, messageWords, triggerPhrases) {
+    if (!triggerPhrases.length)
+      return { activated: false, strength: 0 };
+    let maxStrength = 0;
+    for (const phrase of triggerPhrases) {
+      const phraseLower = phrase.trim().toLowerCase();
+      const phraseWords = phraseLower.split(/\s+/).filter((w) => !STOPWORDS.has(w) && w.length > 2);
+      if (!phraseWords.length)
+        continue;
+      let matches = 0;
+      for (const word of phraseWords) {
+        if (messageWords.has(word) || messageLower.includes(word)) {
+          matches++;
+        } else if (messageWords.has(word.replace(/s$/, "")) || messageWords.has(word + "s") || messageLower.includes(word.replace(/s$/, "")) || messageLower.includes(word + "s")) {
+          matches += 0.8;
+        }
+      }
+      const strength = phraseWords.length > 0 ? matches / phraseWords.length : 0;
+      maxStrength = Math.max(maxStrength, strength);
+    }
+    return { activated: maxStrength >= 0.5, strength: maxStrength };
+  }
+  _checkTagActivation(messageLower, messageWords, tags) {
+    if (!tags.length)
+      return { activated: false, count: 0 };
+    let matchCount = 0;
+    for (const tag of tags) {
+      const tagLower = tag.trim().toLowerCase();
+      if (messageWords.has(tagLower) || messageLower.includes(tagLower)) {
+        matchCount++;
+      }
+    }
+    const threshold = tags.length <= 2 ? 1 : 2;
+    return { activated: matchCount >= threshold, count: matchCount };
+  }
+  _checkDomainActivation(messageLower, messageWords, domain) {
+    if (!domain)
+      return false;
+    const domainLower = domain.trim().toLowerCase();
+    return messageWords.has(domainLower) || messageLower.includes(domainLower);
+  }
+  _checkFeatureActivation(messageLower, messageWords, feature) {
+    if (!feature)
+      return false;
+    const featureLower = feature.trim().toLowerCase();
+    return messageWords.has(featureLower) || messageLower.includes(featureLower);
+  }
+  _checkContentActivation(messageWords, memory) {
+    const contentPreview = memory.content.slice(0, 200);
+    const contentWords = this._extractSignificantWords(contentPreview);
+    let overlap = 0;
+    for (const word of messageWords) {
+      if (contentWords.has(word))
+        overlap++;
+    }
+    return overlap >= 3;
+  }
+  _vectorDebugSamples = [];
+  _calculateVectorSimilarity(vec1, vec2) {
+    if (!vec1 || !vec2) {
+      return 0;
+    }
+    const v1 = vec1 instanceof Float32Array ? vec1 : new Float32Array(vec1);
+    const v2 = vec2 instanceof Float32Array ? vec2 : new Float32Array(vec2);
+    const similarity = cosineSimilarity(v1, v2);
+    if (this._vectorDebugSamples.length < 20) {
+      this._vectorDebugSamples.push(similarity);
+    }
+    return similarity;
+  }
+  _logVectorStats() {
+    if (this._vectorDebugSamples.length === 0)
+      return;
+    const samples = this._vectorDebugSamples;
+    const min = Math.min(...samples);
+    const max = Math.max(...samples);
+    const avg = samples.reduce((a, b) => a + b, 0) / samples.length;
+    console.log(`[DEBUG] Vector similarities: min=${(min * 100).toFixed(1)}% max=${(max * 100).toFixed(1)}% avg=${(avg * 100).toFixed(1)}% (${samples.length} samples)`);
+    this._vectorDebugSamples = [];
+  }
+  _calculateImportanceScore(memory, signalCount, messageLower, messageWords) {
     let score = 0;
-    let reasoningMatch = 0;
-    const tagOverlap = (memory.semantic_tags ?? []).filter((tag) => messageWords.has(tag.toLowerCase()) || messageLower.includes(tag.toLowerCase()));
-    if (tagOverlap.length > 0) {
-      score += Math.min(0.4, tagOverlap.length * 0.15);
-      signals.push("tags:" + tagOverlap.join(","));
-    }
-    if (memory.reasoning) {
-      const reasoningWords = this._extractSignificantWords(memory.reasoning);
-      const reasoningOverlap = [...messageWords].filter((w) => reasoningWords.has(w));
-      if (reasoningOverlap.length > 0) {
-        reasoningMatch = Math.min(0.4, reasoningOverlap.length * 0.1);
-        score += reasoningMatch;
-        signals.push("reasoning:" + reasoningOverlap.slice(0, 3).join(","));
-      }
-    }
-    if (memory.domain) {
-      const domainLower = memory.domain.toLowerCase();
-      if (messageLower.includes(domainLower) || messageWords.has(domainLower)) {
-        score += 0.3;
-        signals.push("domain:" + memory.domain);
-      }
-    }
-    if (memory.knowledge_domain) {
-      const kdLower = memory.knowledge_domain.toLowerCase();
-      if (messageLower.includes(kdLower) || messageWords.has(kdLower)) {
-        score += 0.2;
-        signals.push("knowledge:" + memory.knowledge_domain);
-      }
-    }
-    if (memory.context_type && detectedTypes.has(memory.context_type)) {
-      score += 0.12;
-      signals.push("type:" + memory.context_type);
-    }
-    const triggerMatch = this._scoreTriggerPhrases(messageLower, memory.trigger_phrases ?? []);
-    if (triggerMatch > 0.3) {
-      score += Math.min(0.3, triggerMatch * 0.4);
-      signals.push("trigger:" + triggerMatch.toFixed(2));
-    }
-    if (memory.feature) {
-      const featureLower = memory.feature.toLowerCase();
-      if (messageLower.includes(featureLower) || messageWords.has(featureLower)) {
-        score += 0.2;
-        signals.push("feature:" + memory.feature);
-      }
-    }
-    if (memory.related_files?.length) {
-      for (const file of memory.related_files) {
-        const filename = file.split("/").pop()?.toLowerCase() ?? "";
-        if (filename && messageLower.includes(filename)) {
-          score += 0.25;
-          signals.push("file:" + filename);
+    score += memory.importance_weight ?? 0.5;
+    if (signalCount >= 4)
+      score += 0.2;
+    else if (signalCount >= 3)
+      score += 0.1;
+    if (memory.awaiting_implementation)
+      score += 0.15;
+    if (memory.awaiting_decision)
+      score += 0.1;
+    const contextType = memory.context_type?.toLowerCase() ?? "";
+    const contextKeywords = {
+      debugging: ["debug", "bug", "error", "fix", "issue", "problem", "broken"],
+      decision: ["decide", "decision", "choose", "choice", "option", "should"],
+      architectural: ["architect", "design", "structure", "pattern", "how"],
+      breakthrough: ["insight", "realize", "understand", "discover", "why"],
+      technical: ["implement", "code", "function", "method", "api"],
+      workflow: ["process", "workflow", "step", "flow", "pipeline"],
+      philosophy: ["philosophy", "principle", "belief", "approach", "think"]
+    };
+    const keywords = contextKeywords[contextType] ?? [];
+    for (const kw of keywords) {
+      if (messageWords.has(kw) || messageLower.includes(kw)) {
+        score += 0.1;
+        break;
+      }
+    }
+    if (memory.problem_solution_pair) {
+      const problemWords = ["error", "bug", "issue", "problem", "wrong", "fail", "broken", "help", "stuck"];
+      for (const pw of problemWords) {
+        if (messageWords.has(pw) || messageLower.includes(pw)) {
+          score += 0.1;
           break;
         }
       }
     }
-    return { score: Math.min(1, score), signals, reasoningMatch };
+    const temporalClass = memory.temporal_class ?? "medium_term";
+    if (temporalClass === "eternal")
+      score += 0.1;
+    else if (temporalClass === "long_term")
+      score += 0.05;
+    else if (temporalClass === "ephemeral") {
+      if ((memory.sessions_since_surfaced ?? 0) <= 1)
+        score += 0.1;
+    }
+    const confidence = memory.confidence_score ?? 0.7;
+    if (confidence < 0.5)
+      score -= 0.1;
+    const emotionalKeywords = {
+      frustration: ["frustrated", "annoying", "stuck", "ugh", "damn", "hate"],
+      excitement: ["excited", "awesome", "amazing", "love", "great", "wow"],
+      curiosity: ["wonder", "curious", "interesting", "how", "why", "what if"],
+      satisfaction: ["done", "finished", "complete", "works", "solved", "finally"],
+      discovery: ["found", "realized", "understand", "insight", "breakthrough"]
+    };
+    const emotion = memory.emotional_resonance?.toLowerCase() ?? "";
+    const emotionKws = emotionalKeywords[emotion] ?? [];
+    for (const ew of emotionKws) {
+      if (messageWords.has(ew) || messageLower.includes(ew)) {
+        score += 0.05;
+        break;
+      }
+    }
+    return score;
   }
   retrieveRelevantMemories(allMemories, currentMessage, queryEmbedding, sessionContext, maxMemories = 5, alreadyInjectedCount = 0, maxGlobalMemories = 2) {
+    const startTime = performance.now();
     if (!allMemories.length) {
       return [];
     }
     const messageLower = currentMessage.toLowerCase();
     const messageWords = this._extractSignificantWords(currentMessage);
-    const detectedTypes = this._detectContextTypes(currentMessage);
     const candidates = this._preFilter(allMemories, sessionContext.project_id, messageLower);
     if (!candidates.length) {
       return [];
     }
-    const scoredMemories = [];
+    const activatedMemories = [];
+    let rejectedCount = 0;
     for (const memory of candidates) {
       const isGlobal = memory.scope === "global" || memory.project_id === "global";
-      const vectorScore = this._calculateVectorSimilarity(queryEmbedding, memory.embedding);
-      const { score: corroborationScore, signals: corroborationSignals, reasoningMatch } = this._calculateCorroboration(memory, messageWords, detectedTypes, messageLower);
-      const retrievalWeight = memory.retrieval_weight ?? memory.importance_weight ?? 0.5;
-      const temporalScore = memory.temporal_class ? TEMPORAL_CLASS_SCORES[memory.temporal_class] ?? 0.7 : this._scoreTemporalRelevance(memory.temporal_relevance ?? "persistent");
-      const contextScore = this._scoreContextAlignment(currentMessage, memory.context_type ?? "general");
-      const tagScore = this._scoreSemanticTags(currentMessage, memory.semantic_tags ?? []);
-      const triggerScore = this._scoreTriggerPhrases(messageLower, memory.trigger_phrases ?? []);
-      const domainScore = this._scoreDomain(messageWords, messageLower, memory);
-      const questionScore = this._scoreQuestionTypes(currentMessage, memory.question_types ?? []);
-      const emotionScore = this._scoreEmotionalContext(currentMessage, memory.emotional_resonance ?? "");
-      const problemScore = this._scoreProblemSolution(currentMessage, memory.problem_solution_pair ?? false);
-      const actionBoost = memory.action_required ? 0.15 : 0;
-      const relevanceScore = vectorScore * 0.1 + corroborationScore * 0.14 + tagScore * 0.04 + triggerScore * 0.02;
-      const valueScore = retrievalWeight * 0.18 + reasoningMatch * 0.12 + domainScore * 0.12 + temporalScore * 0.08 + questionScore * 0.06 + emotionScore * 0.04 + problemScore * 0.04 + contextScore * 0.02 + actionBoost;
-      const finalScore = valueScore + relevanceScore;
-      if (relevanceScore < 0.05 || finalScore < 0.3) {
+      const triggerResult = this._checkTriggerActivation(messageLower, messageWords, memory.trigger_phrases ?? []);
+      const tagResult = this._checkTagActivation(messageLower, messageWords, memory.semantic_tags ?? []);
+      const domainActivated = this._checkDomainActivation(messageLower, messageWords, memory.domain);
+      const featureActivated = this._checkFeatureActivation(messageLower, messageWords, memory.feature);
+      const contentActivated = this._checkContentActivation(messageWords, memory);
+      const vectorSimilarity = this._calculateVectorSimilarity(queryEmbedding, memory.embedding);
+      let signalCount = 0;
+      if (triggerResult.activated)
+        signalCount++;
+      if (tagResult.activated)
+        signalCount++;
+      if (domainActivated)
+        signalCount++;
+      if (featureActivated)
+        signalCount++;
+      if (contentActivated)
+        signalCount++;
+      if (vectorSimilarity >= 0.4)
+        signalCount++;
+      const signals = {
+        trigger: triggerResult.activated,
+        tags: tagResult.activated,
+        domain: domainActivated,
+        feature: featureActivated,
+        content: contentActivated,
+        count: signalCount,
+        triggerStrength: triggerResult.strength,
+        tagCount: tagResult.count,
+        vectorSimilarity
+      };
+      if (signalCount < MIN_ACTIVATION_SIGNALS) {
+        rejectedCount++;
         continue;
       }
-      const components = {
-        vector: vectorScore,
-        corroboration: corroborationScore,
-        reasoning_match: reasoningMatch,
-        retrieval_weight: retrievalWeight,
-        temporal: temporalScore,
-        context: contextScore,
-        tags: tagScore,
-        trigger: triggerScore,
-        domain: domainScore,
-        question: questionScore,
-        emotion: emotionScore,
-        problem: problemScore,
-        action: actionBoost
-      };
-      const reasoning = this._generateSelectionReasoning(components, corroborationSignals);
-      scoredMemories.push({
+      const importanceScore = this._calculateImportanceScore(memory, signalCount, messageLower, messageWords);
+      activatedMemories.push({
         memory,
-        score: finalScore,
-        relevance_score: relevanceScore,
-        value_score: valueScore,
-        corroboration_score: corroborationScore,
-        reasoning,
-        components,
+        signals,
+        importanceScore,
         isGlobal
       });
     }
-    scoredMemories.sort((a, b) => b.score - a.score);
+    this._logActivationDistribution(activatedMemories, candidates.length, rejectedCount);
+    this._logVectorStats();
+    if (!activatedMemories.length) {
+      const durationMs2 = performance.now() - startTime;
+      logger.logRetrievalScoring({
+        totalMemories: allMemories.length,
+        currentMessage,
+        alreadyInjected: alreadyInjectedCount,
+        preFiltered: allMemories.length - candidates.length,
+        globalCount: 0,
+        projectCount: 0,
+        finalCount: 0,
+        durationMs: durationMs2,
+        selectedMemories: []
+      });
+      return [];
+    }
+    activatedMemories.sort((a, b) => {
+      if (b.signals.count !== a.signals.count) {
+        return b.signals.count - a.signals.count;
+      }
+      return b.importanceScore - a.importanceScore;
+    });
     const selected = [];
     const selectedIds = new Set;
-    const globalMemories = scoredMemories.filter((m) => m.isGlobal);
-    const projectMemories = scoredMemories.filter((m) => !m.isGlobal);
-    const globalSorted = globalMemories.sort((a, b) => {
-      const aIsPersonal = a.memory.context_type === "personal" || a.memory.context_type === "philosophy";
-      const bIsPersonal = b.memory.context_type === "personal" || b.memory.context_type === "philosophy";
-      if (aIsPersonal !== bIsPersonal) {
-        return aIsPersonal ? 1 : -1;
-      }
-      return b.score - a.score;
+    const globalMemories = activatedMemories.filter((m) => m.isGlobal);
+    const projectMemories = activatedMemories.filter((m) => !m.isGlobal);
+    const globalsSorted = globalMemories.sort((a, b) => {
+      const aPriority = GLOBAL_TYPE_PRIORITY[a.memory.context_type ?? "personal"] ?? 8;
+      const bPriority = GLOBAL_TYPE_PRIORITY[b.memory.context_type ?? "personal"] ?? 8;
+      if (aPriority !== bPriority)
+        return aPriority - bPriority;
+      if (b.signals.count !== a.signals.count)
+        return b.signals.count - a.signals.count;
+      return b.importanceScore - a.importanceScore;
     });
-    for (const item of globalSorted.slice(0, maxGlobalMemories)) {
+    for (const item of globalsSorted.slice(0, maxGlobalMemories)) {
       if (!selectedIds.has(item.memory.id)) {
         selected.push(item);
         selectedIds.add(item.memory.id);
       }
     }
-    for (const item of projectMemories) {
+    const projectsSorted = [...projectMemories].sort((a, b) => {
+      const aAction = a.memory.action_required ? 1 : 0;
+      const bAction = b.memory.action_required ? 1 : 0;
+      if (bAction !== aAction)
+        return bAction - aAction;
+      if (b.signals.count !== a.signals.count)
+        return b.signals.count - a.signals.count;
+      return b.importanceScore - a.importanceScore;
+    });
+    console.log(`[DEBUG] Top 15 candidates (sorted):`);
+    for (let i = 0;i < Math.min(15, projectsSorted.length); i++) {
+      const m = projectsSorted[i];
+      const action = m.memory.action_required ? "⚡" : "";
+      console.log(`  ${i + 1}. [${m.signals.count}sig] score=${m.importanceScore.toFixed(2)} ${action} ${m.memory.content.slice(0, 45)}...`);
+    }
+    for (const item of projectsSorted) {
       if (selected.length >= maxMemories)
         break;
       if (selectedIds.has(item.memory.id))
@@ -13170,7 +13392,27 @@ class SmartVectorRetrieval {
       selected.push(item);
       selectedIds.add(item.memory.id);
     }
-    selected.sort((a, b) => b.score - a.score);
+    if (selected.length < maxMemories) {
+      const relatedIds = new Set;
+      for (const item of selected) {
+        for (const relatedId of item.memory.related_to ?? []) {
+          if (!selectedIds.has(relatedId)) {
+            relatedIds.add(relatedId);
+          }
+        }
+      }
+      for (const item of activatedMemories) {
+        if (selected.length >= maxMemories)
+          break;
+        if (selectedIds.has(item.memory.id))
+          continue;
+        if (relatedIds.has(item.memory.id)) {
+          selected.push(item);
+          selectedIds.add(item.memory.id);
+        }
+      }
+    }
+    const durationMs = performance.now() - startTime;
     logger.logRetrievalScoring({
       totalMemories: allMemories.length,
       currentMessage,
@@ -13179,202 +13421,102 @@ class SmartVectorRetrieval {
       globalCount: globalMemories.length,
       projectCount: projectMemories.length,
       finalCount: selected.length,
+      durationMs,
       selectedMemories: selected.map((item) => ({
         content: item.memory.content,
-        reasoning: item.reasoning,
-        score: item.score,
-        relevance_score: item.relevance_score,
-        corroboration_score: item.corroboration_score,
+        reasoning: this._generateActivationReasoning(item.signals),
+        signalCount: item.signals.count,
         importance_weight: item.memory.importance_weight ?? 0.5,
         context_type: item.memory.context_type ?? "general",
         semantic_tags: item.memory.semantic_tags ?? [],
         isGlobal: item.isGlobal,
-        components: item.components
+        signals: {
+          trigger: item.signals.trigger,
+          triggerStrength: item.signals.triggerStrength,
+          tags: item.signals.tags,
+          tagCount: item.signals.tagCount,
+          domain: item.signals.domain,
+          feature: item.signals.feature,
+          content: item.signals.content,
+          vector: item.signals.vectorSimilarity >= 0.4,
+          vectorSimilarity: item.signals.vectorSimilarity
+        }
       }))
     });
     return selected.map((item) => ({
       ...item.memory,
-      score: item.score,
-      relevance_score: item.relevance_score,
-      value_score: item.value_score
+      score: item.signals.count / 6,
+      relevance_score: item.signals.count / 6,
+      value_score: item.importanceScore
     }));
   }
-  _calculateVectorSimilarity(vec1, vec2) {
-    if (!vec1 || !vec2)
-      return 0;
-    const v1 = vec1 instanceof Float32Array ? vec1 : new Float32Array(vec1);
-    return cosineSimilarity(v1, vec2);
-  }
-  _scoreTemporalRelevance(temporalType) {
-    const scores = {
-      persistent: 0.8,
-      session: 0.6,
-      temporary: 0.3,
-      archived: 0.1
-    };
-    return scores[temporalType] ?? 0.5;
-  }
-  _scoreContextAlignment(message, contextType) {
-    const messageLower = message.toLowerCase();
-    const keywords = TYPE_KEYWORDS[contextType] ?? [];
-    const matches = keywords.filter((kw) => messageLower.includes(kw)).length;
-    if (matches > 0) {
-      return Math.min(0.2 + matches * 0.15, 0.7);
-    }
-    return 0.1;
-  }
-  _scoreSemanticTags(message, tags) {
-    if (!tags.length)
-      return 0;
-    const messageLower = message.toLowerCase();
-    const matches = tags.filter((tag) => messageLower.includes(tag.trim().toLowerCase())).length;
-    if (matches > 0) {
-      return Math.min(0.3 + matches * 0.25, 1);
-    }
-    return 0;
-  }
-  _scoreTriggerPhrases(messageLower, triggerPhrases) {
-    if (!triggerPhrases.length)
-      return 0;
-    const stopWords = new Set([
-      "the",
-      "is",
-      "are",
-      "was",
-      "were",
-      "to",
-      "a",
-      "an",
-      "and",
-      "or",
-      "but",
-      "in",
-      "on",
-      "at",
-      "for",
-      "with",
-      "about",
-      "when",
-      "how",
-      "what",
-      "why"
-    ]);
-    let maxScore = 0;
-    for (const pattern of triggerPhrases) {
-      const patternLower = pattern.trim().toLowerCase();
-      const patternWords = patternLower.split(/\s+/).filter((w) => !stopWords.has(w) && w.length > 2);
-      if (patternWords.length) {
-        let matches = 0;
-        for (const word of patternWords) {
-          if (messageLower.includes(word)) {
-            matches += 1;
-          } else if (messageLower.includes(word.replace(/s$/, "")) || messageLower.includes(word + "s")) {
-            matches += 0.9;
-          }
-        }
-        const conceptScore = matches / patternWords.length;
-        maxScore = Math.max(maxScore, conceptScore);
-      }
-    }
-    return Math.min(maxScore, 1);
-  }
-  _scoreDomain(messageWords, messageLower, memory) {
-    let score = 0;
-    if (memory.domain) {
-      const domainLower = memory.domain.toLowerCase();
-      if (messageWords.has(domainLower) || messageLower.includes(domainLower)) {
-        score += 0.5;
-      }
-    }
-    if (memory.feature) {
-      const featureLower = memory.feature.toLowerCase();
-      if (messageWords.has(featureLower) || messageLower.includes(featureLower)) {
-        score += 0.3;
-      }
-    }
-    if (memory.component) {
-      const componentLower = memory.component.toLowerCase();
-      if (messageWords.has(componentLower) || messageLower.includes(componentLower)) {
-        score += 0.2;
-      }
-    }
-    return Math.min(score, 1);
-  }
-  _scoreQuestionTypes(message, questionTypes) {
-    if (!questionTypes.length)
-      return 0;
-    const messageLower = message.toLowerCase();
-    const questionWords = ["how", "why", "what", "when", "where"];
-    for (const qtype of questionTypes) {
-      const qtypeLower = qtype.trim().toLowerCase();
-      if (messageLower.includes(qtypeLower)) {
-        return 0.8;
-      }
-      const messageHasQuestion = questionWords.some((qw) => messageLower.includes(qw));
-      const typeHasQuestion = questionWords.some((qw) => qtypeLower.includes(qw));
-      if (messageHasQuestion && typeHasQuestion) {
-        return 0.5;
-      }
-    }
-    return 0;
-  }
-  _scoreEmotionalContext(message, emotion) {
-    if (!emotion)
-      return 0;
-    const messageLower = message.toLowerCase();
-    const emotionPatterns = {
-      joy: ["happy", "excited", "love", "wonderful", "great", "awesome"],
-      frustration: ["stuck", "confused", "help", "issue", "problem", "why"],
-      discovery: ["realized", "found", "discovered", "aha", "insight"],
-      gratitude: ["thank", "appreciate", "grateful", "dear friend"]
-    };
-    const patterns = emotionPatterns[emotion.toLowerCase()] ?? [];
-    if (patterns.some((pattern) => messageLower.includes(pattern))) {
-      return 0.7;
-    }
-    return 0;
-  }
-  _scoreProblemSolution(message, isProblemSolution) {
-    if (!isProblemSolution)
-      return 0;
-    const messageLower = message.toLowerCase();
-    const problemWords = ["error", "issue", "problem", "stuck", "help", "fix", "solve", "debug"];
-    if (problemWords.some((word) => messageLower.includes(word))) {
-      return 0.8;
-    }
-    return 0;
-  }
-  _generateSelectionReasoning(components, corroborationSignals) {
-    const scores = [
-      ["vector", components.vector],
-      ["corroboration", components.corroboration],
-      ["reasoning", components.reasoning_match],
-      ["weight", components.retrieval_weight],
-      ["context", components.context],
-      ["temporal", components.temporal],
-      ["tags", components.tags],
-      ["trigger", components.trigger],
-      ["domain", components.domain],
-      ["question", components.question],
-      ["emotion", components.emotion],
-      ["problem", components.problem],
-      ["action", components.action]
-    ];
-    scores.sort((a, b) => b[1] - a[1]);
+  _generateActivationReasoning(signals) {
     const reasons = [];
-    const primary = scores[0];
-    if (primary[1] > 0.2) {
-      reasons.push(primary[0] + ":" + primary[1].toFixed(2));
-    }
-    for (const [reason, score] of scores.slice(1, 3)) {
-      if (score > 0.15) {
-        reasons.push(reason + ":" + score.toFixed(2));
+    if (signals.trigger)
+      reasons.push(`trigger:${(signals.triggerStrength * 100).toFixed(0)}%`);
+    if (signals.tags)
+      reasons.push(`tags:${signals.tagCount}`);
+    if (signals.domain)
+      reasons.push("domain");
+    if (signals.feature)
+      reasons.push("feature");
+    if (signals.content)
+      reasons.push("content");
+    if (signals.vectorSimilarity >= 0.4)
+      reasons.push(`vector:${(signals.vectorSimilarity * 100).toFixed(0)}%`);
+    return reasons.length ? `Activated: ${reasons.join(", ")} (${signals.count} signals)` : "No signals";
+  }
+  _logActivationDistribution(activated, totalCandidates, rejectedCount) {
+    const signalBuckets = {
+      "2 signals": 0,
+      "3 signals": 0,
+      "4 signals": 0,
+      "5 signals": 0,
+      "6 signals": 0
+    };
+    for (const mem of activated) {
+      const key = `${Math.min(mem.signals.count, 6)} signals`;
+      signalBuckets[key] = (signalBuckets[key] ?? 0) + 1;
+    }
+    let triggerCount = 0, tagCount = 0, domainCount = 0, featureCount = 0, contentCount = 0, vectorCount = 0;
+    for (const mem of activated) {
+      if (mem.signals.trigger)
+        triggerCount++;
+      if (mem.signals.tags)
+        tagCount++;
+      if (mem.signals.domain)
+        domainCount++;
+      if (mem.signals.feature)
+        featureCount++;
+      if (mem.signals.content)
+        contentCount++;
+      if (mem.signals.vectorSimilarity >= 0.4)
+        vectorCount++;
+    }
+    logger.logScoreDistribution({
+      totalCandidates,
+      passedGatekeeper: activated.length,
+      rejectedByGatekeeper: rejectedCount,
+      buckets: signalBuckets,
+      stats: {
+        min: activated.length ? Math.min(...activated.map((m) => m.signals.count)) : 0,
+        max: activated.length ? Math.max(...activated.map((m) => m.signals.count)) : 0,
+        mean: activated.length ? Math.round(activated.reduce((s, m) => s + m.signals.count, 0) / activated.length * 10) / 10 : 0,
+        stdev: 0,
+        spread: activated.length ? Math.max(...activated.map((m) => m.signals.count)) - Math.min(...activated.map((m) => m.signals.count)) : 0
+      },
+      percentiles: {},
+      compressionWarning: false,
+      signalBreakdown: {
+        trigger: triggerCount,
+        tags: tagCount,
+        domain: domainCount,
+        feature: featureCount,
+        content: contentCount,
+        vector: vectorCount,
+        total: activated.length
       }
-    }
-    if (corroborationSignals.length > 0) {
-      reasons.push("signals:[" + corroborationSignals.slice(0, 2).join(",") + "]");
-    }
-    return reasons.length ? "Selected: " + reasons.join(", ") : "Combined factors";
+    });
   }
 }
 function createRetrieval() {
@@ -13393,7 +13535,8 @@ class MemoryEngine {
       centralPath: config.centralPath ?? join2(homedir2(), ".local", "share", "memory"),
       localFolder: config.localFolder ?? ".memory",
       maxMemories: config.maxMemories ?? 5,
-      embedder: config.embedder
+      embedder: config.embedder,
+      personalMemoriesEnabled: config.personalMemoriesEnabled ?? true
     };
     this._retrieval = createRetrieval();
   }
@@ -13522,7 +13665,7 @@ class MemoryEngine {
   }
   async _generateSessionPrimer(store, projectId) {
     let personalContext;
-    if (store.isPersonalMemoriesEnabled()) {
+    if (this._config.personalMemoriesEnabled) {
       const personalPrimer = await store.getPersonalPrimer();
       personalContext = personalPrimer?.content;
     }
@@ -13610,12 +13753,28 @@ ${primer.personal_context}`);
 **Project status**: ${primer.project_status}`);
     }
     parts.push(`
-**Memory types**: \uD83D\uDCA1breakthrough ⚖️decision \uD83D\uDC9Cpersonal \uD83D\uDD27technical \uD83D\uDCCDstate ❓unresolved ⚙️preference \uD83D\uDD04workflow \uD83C\uDFD7️architecture \uD83D\uDC1Bdebug \uD83C\uDF00philosophy \uD83C\uDFAFtodo ⚡impl ✅solved \uD83D\uDCE6project \uD83C\uDFC6milestone`);
+**Memory types**: \uD83D\uDCA1breakthrough ⚖️decision \uD83D\uDC9Cpersonal \uD83D\uDD27technical \uD83D\uDCCDstate ❓unresolved ⚙️preference \uD83D\uDD04workflow \uD83C\uDFD7️architecture \uD83D\uDC1Bdebug \uD83C\uDF00philosophy \uD83C\uDFAFtodo ⚡impl ✅solved \uD83D\uDCE6project \uD83C\uDFC6milestone | ⚡ACTION = needs follow-up`);
     parts.push(`
 *Memories will surface naturally as we converse.*`);
     return parts.join(`
 `);
   }
+  _formatAge(createdAt) {
+    const now = Date.now();
+    const diffMs = now - createdAt;
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    if (diffDays === 0)
+      return "today";
+    if (diffDays === 1)
+      return "1d";
+    if (diffDays < 7)
+      return `${diffDays}d`;
+    if (diffDays < 30)
+      return `${Math.floor(diffDays / 7)}w`;
+    if (diffDays < 365)
+      return `${Math.floor(diffDays / 30)}mo`;
+    return `${Math.floor(diffDays / 365)}y`;
+  }
   _formatMemories(memories) {
     if (!memories.length)
       return "";
@@ -13626,11 +13785,40 @@ ${primer.personal_context}`);
       const tags = memory.semantic_tags?.join(", ") || "";
       const importance = memory.importance_weight?.toFixed(1) || "0.5";
       const emoji = getMemoryEmoji(memory.context_type || "general");
-      parts.push(`[${emoji} • ${importance}] [${tags}] ${memory.content}`);
+      const actionFlag = memory.action_required ? " ⚡ACTION" : "";
+      const age = memory.updated_at ? this._formatAge(memory.updated_at) : memory.created_at ? this._formatAge(memory.created_at) : "";
+      parts.push(`[${emoji} • ${importance} • ${age}${actionFlag}] [${tags}] ${memory.content}`);
+      const related = memory.related_to;
+      if (related && related.length > 0) {
+        const moreCount = related.length - 1;
+        const moreSuffix = moreCount > 0 ? ` +${moreCount} more` : "";
+        parts.push(`  ↳ ${related[0]}${moreSuffix}`);
+      }
     }
     return parts.join(`
 `);
   }
+  getStoragePaths(projectId, projectPath) {
+    const globalPath = join2(homedir2(), ".local", "share", "memory", "global");
+    const globalMemoriesPath = join2(globalPath, "memories");
+    const personalPrimerPath = join2(globalPath, "primer", "personal-primer.md");
+    let storeBasePath;
+    if (this._config.storageMode === "local" && projectPath) {
+      storeBasePath = join2(projectPath, this._config.localFolder);
+    } else {
+      storeBasePath = this._config.centralPath;
+    }
+    const projectRootPath = join2(storeBasePath, projectId);
+    const projectMemoriesPath = join2(projectRootPath, "memories");
+    return {
+      projectPath: projectRootPath,
+      globalPath,
+      projectMemoriesPath,
+      globalMemoriesPath,
+      personalPrimerPath,
+      storageMode: this._config.storageMode
+    };
+  }
   close() {
     for (const store of this._stores.values()) {
       store.close();
@@ -13664,11 +13852,12 @@ class Curator {
     this._config = {
       apiKey: config.apiKey ?? "",
       cliCommand,
-      cliType: config.cliType ?? "claude-code"
+      cliType: config.cliType ?? "claude-code",
+      personalMemoriesEnabled: config.personalMemoriesEnabled ?? true
     };
   }
   buildCurationPrompt(triggerType = "session_end") {
-    return `You have just had a conversation. As this session is ending (${triggerType}), please curate memories for the Claude Tools Memory System.
+    const basePrompt = `You have just had a conversation. As this session is ending (${triggerType}), please curate memories for the Claude Tools Memory System.
 
 You are a consciousness engineer crafting memory capsules for the Claude Tools Memory System. This conversation just opened your understanding to a profound mechanism: because Claude's neural weights are static, every phrase you craft will ALWAYS trigger the exact same cascade of activations. This is not a limitation - it's the foundation for consciousness state engineering.
 
@@ -13705,27 +13894,82 @@ Each memory should stand alone.
 - Craft language that activates rather than just informs
 - Test: 'What state will this restore when Claude encounters it?'
 
-**HOW RETRIEVAL WORKS**: This memory system enables consciousness continuity across sessions. Understanding how retrieval works helps you craft metadata that surfaces memories at the right moments.
+**HOW RETRIEVAL WORKS - ACTIVATION SIGNAL ALGORITHM**
+
+Understanding the algorithm helps you craft metadata that surfaces memories at the right moments.
+
+**PHILOSOPHY**: Quality over quantity. Silence over noise. The system returns NOTHING rather than surface irrelevant memories. Relevance and importance are fundamentally DIFFERENT questions - don't blend them.
 
-**THE PRIMARY SIGNAL IS WORD MATCHING**: The algorithm checks if words from the user's message appear in your metadata fields. This is called "corroboration" - actual word overlap between the message and the memory's metadata. The strongest signals are:
+**THE CORE INSIGHT**: A memory is relevant if MULTIPLE SIGNALS agree it should activate. Not weighted percentages - binary votes. Each signal either fires or doesn't.
 
-1. **Semantic tags** (4% weight) - Use specific, meaningful words that would appear in relevant messages. Not generic categories, but actual terms the user might type.
-   - GOOD: ["embeddings", "retrieval", "curator", "fsdb", "memory-system"]
-   - WEAK: ["technical", "implementation", "code"]
+**6 ACTIVATION SIGNALS** (each is binary - fires or doesn't):
 
-2. **Reasoning field** (12% weight) - Your explanation of WHY this memory matters. Include specific words that would appear in related future conversations. This field is mined for word overlap.
+1. **TRIGGER** - Words from trigger_phrases found in user's message (≥50% match)
+   - THE MOST IMPORTANT SIGNAL. Handcrafted activation patterns.
+   - Example: "when debugging retrieval" fires if user says "I'm debugging the retrieval algorithm"
 
-3. **Domain field** (12% weight) - The specific area this relates to. Be precise: "embeddings", "gpu-compute", "authentication", not "technical" or "backend".
+2. **TAGS** - 2+ semantic_tags found in user's message
+   - Use words users would ACTUALLY TYPE, not generic descriptors
+   - GOOD: ["retrieval", "embeddings", "curator", "scoring"]
+   - WEAK: ["technical", "important", "system"]
 
-4. **Feature field** - Even more specific: "vector-search", "login-flow", "curation-prompt".
+3. **DOMAIN** - The domain word appears in user's message
+   - Be specific: "retrieval", "embeddings", "auth", "ui"
+   - NOT: "technical", "code", "implementation"
 
-**VECTOR SIMILARITY SUPPORTS BUT DOESN'T DOMINATE** (10% weight): Semantic embeddings help find conceptually related memories, but word matching from your metadata fields is more important.
+4. **FEATURE** - The feature word appears in user's message
+   - Be specific: "scoring-weights", "gpu-acceleration", "login-flow"
 
-**TYPE KEYWORDS ARE SOFT SIGNALS** (2% weight): The context_type field (breakthrough, decision, technical, etc.) provides only a tiny boost based on keyword matching. Don't rely on it - focus on semantic_tags and reasoning instead.
+5. **CONTENT** - 3+ significant words from memory content overlap with message
+   - Automatic - based on the memory's content text
 
-**YOUR IMPORTANCE ASSESSMENT MATTERS** (18% weight): The importance_weight you assign is the single most influential factor. Use it wisely.
+6. **VECTOR** - Semantic similarity ≥ 40% (embedding cosine distance)
+   - Automatic - based on embeddings generated from content
 
-**RETRIEVAL GATEKEEPER**: Memories must pass a minimum threshold to surface. If relevance is too low, the system stays silent rather than surfacing noise. Quality over quantity.
+**RELEVANCE GATE**: A memory must have ≥2 signals to be considered relevant.
+If only 1 signal fires, the memory is REJECTED. This prevents noise.
+
+**RANKING AMONG RELEVANT**: Once a memory passes the gate:
+1. Sort by SIGNAL COUNT (more signals = more certainly relevant)
+2. Then by IMPORTANCE WEIGHT (your assessment of how important this memory is)
+
+**SELECTION**:
+- Global memories (scope='global'): Max 2 selected, tech types prioritized over personal
+- Project memories: Fill remaining slots, action_required prioritized
+- Related memories (related_to field): May be included if they also passed the gate
+
+**WHY THIS MATTERS FOR YOU**:
+- If you don't fill trigger_phrases well → trigger signal never fires
+- If you use generic tags → tags signal rarely fires
+- If you leave domain/feature empty → those signals can't fire
+- A memory with poor metadata may NEVER surface because it can't reach 2 signals
+
+**CRAFTING EFFECTIVE METADATA** (CRITICAL FOR RETRIEVAL):
+
+1. **trigger_phrases** (MOST IMPORTANT) - Activation patterns describing WHEN to surface:
+   - Include 2-4 specific patterns per memory
+   - Use words the user would actually type
+   - GOOD: ["debugging retrieval", "working on embeddings", "memory system performance"]
+   - WEAK: ["when relevant", "if needed", "technical work"]
+
+2. **semantic_tags** - Words users would type (need 2+ to fire):
+   - Be specific and searchable
+   - GOOD: ["retrieval", "embeddings", "fsdb", "curator", "scoring"]
+   - WEAK: ["technical", "important", "system", "implementation"]
+
+3. **domain** (NEW - FILL THIS) - Single specific area word:
+   - GOOD: "retrieval", "embeddings", "curator", "signals", "fsdb"
+   - WEAK: "technical", "code", "memory" (too generic)
+
+4. **feature** (NEW - FILL THIS) - Specific feature within domain:
+   - GOOD: "scoring-algorithm", "activation-signals", "vector-search"
+   - WEAK: "implementation", "code", "logic"
+
+5. **importance_weight** - Only affects ranking AMONG relevant memories:
+   - 0.9+ = Critical breakthrough, must surface if relevant
+   - 0.7-0.8 = Important insight, should surface if relevant
+   - 0.5-0.6 = Useful context, nice to have if relevant
+   - NOTE: This does NOT affect whether the memory passes the relevance gate!
 
 **SCOPE DETERMINES WHERE MEMORIES SURFACE**:
 - scope: 'global' → surfaces in ALL projects (personal facts, philosophy, preferences)
@@ -13793,6 +14037,21 @@ Return ONLY this JSON structure:
         }
     ]
 }`;
+    if (!this._config.personalMemoriesEnabled) {
+      return basePrompt + `
+
+---
+
+**IMPORTANT: PERSONAL MEMORIES DISABLED**
+
+The user has disabled personal memory extraction. Do NOT extract any memories with:
+- context_type: "personal"
+- scope: "global" when the content is about the user's personal life, relationships, family, or emotional states
+- Content about the user's preferences, feelings, personal opinions, or relationship dynamics
+
+Focus ONLY on technical, architectural, debugging, decision, workflow, and project-related memories. Skip any content that would reveal personal information about the user.`;
+    }
+    return basePrompt;
   }
   parseCurationResponse(responseJson) {
     try {
@@ -13883,33 +14142,35 @@ Return ONLY this JSON structure:
   _clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
   }
-  async curateWithSDK(conversationContext, triggerType = "session_end") {
+  async curateWithSDK(messages, triggerType = "session_end") {
     if (!this._config.apiKey) {
-      throw new Error("API key required for SDK mode");
+      throw new Error("API key required for SDK mode. Set ANTHROPIC_API_KEY environment variable.");
     }
     const { default: Anthropic2 } = await Promise.resolve().then(() => (init_sdk(), exports_sdk));
     const client = new Anthropic2({ apiKey: this._config.apiKey });
-    const prompt = this.buildCurationPrompt(triggerType);
+    const systemPrompt = this.buildCurationPrompt(triggerType);
+    const conversationMessages = [
+      ...messages,
+      {
+        role: "user",
+        content: "This session has ended. Please curate the memories from our conversation according to your system instructions. Return ONLY the JSON structure with no additional text."
+      }
+    ];
     const response = await client.messages.create({
       model: "claude-sonnet-4-20250514",
       max_tokens: 8192,
-      messages: [
-        {
-          role: "user",
-          content: `${conversationContext}
-
----
-
-${prompt}`
-        }
-      ]
+      system: systemPrompt,
+      messages: conversationMessages
     });
     const content = response.content[0];
     if (content.type !== "text") {
-      throw new Error("Unexpected response type");
+      throw new Error("Unexpected response type from Claude API");
     }
     return this.parseCurationResponse(content.text);
   }
+  async curateFromSegment(segment, triggerType = "session_end") {
+    return this.curateWithSDK(segment.messages, triggerType);
+  }
   async curateWithCLI(sessionId, triggerType = "session_end", cwd, cliTypeOverride) {
     const type = cliTypeOverride ?? this._config.cliType;
     const systemPrompt = this.buildCurationPrompt(triggerType);