@rlabs-inc/memory 0.3.7 → 0.3.8

package/dist/server/index.js

@@ -19885,6 +19885,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";
@@ -19906,7 +19911,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
@@ -19923,8 +19928,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() {
@@ -20001,40 +20012,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
       });
     }
   }
@@ -20054,6 +20056,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) : ""
     });
@@ -20417,7 +20420,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}`);
   },
@@ -20489,7 +20499,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`)}`);
@@ -20501,11 +20518,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();
@@ -20553,44 +20571,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}"`);
@@ -20609,347 +20707,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.reasoning) {
-        console.log(`      ${style("dim", m.reasoning)}`);
+      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 (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))
@@ -20957,7 +21179,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,
@@ -20966,202 +21208,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() {
@@ -21180,7 +21322,8 @@ class MemoryEngine {
       centralPath: config.centralPath ?? import_path2.join(import_os2.homedir(), ".local", "share", "memory"),
       localFolder: config.localFolder ?? ".memory",
       maxMemories: config.maxMemories ?? 5,
-      embedder: config.embedder
+      embedder: config.embedder,
+      personalMemoriesEnabled: config.personalMemoriesEnabled ?? true
     };
     this._retrieval = createRetrieval();
   }
@@ -21309,7 +21452,7 @@ class MemoryEngine {
   }
   async _generateSessionPrimer(store, projectId) {
     let personalContext;
-    if (store.isPersonalMemoriesEnabled()) {
+    if (this._config.personalMemoriesEnabled) {
       const personalPrimer = await store.getPersonalPrimer();
       personalContext = personalPrimer?.content;
     }
@@ -21397,12 +21540,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 "";
@@ -21413,11 +21572,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 = import_path2.join(import_os2.homedir(), ".local", "share", "memory", "global");
+    const globalMemoriesPath = import_path2.join(globalPath, "memories");
+    const personalPrimerPath = import_path2.join(globalPath, "primer", "personal-primer.md");
+    let storeBasePath;
+    if (this._config.storageMode === "local" && projectPath) {
+      storeBasePath = import_path2.join(projectPath, this._config.localFolder);
+    } else {
+      storeBasePath = this._config.centralPath;
+    }
+    const projectRootPath = import_path2.join(storeBasePath, projectId);
+    const projectMemoriesPath = import_path2.join(projectRootPath, "memories");
+    return {
+      projectPath: projectRootPath,
+      globalPath,
+      projectMemoriesPath,
+      globalMemoriesPath,
+      personalPrimerPath,
+      storageMode: this._config.storageMode
+    };
+  }
   close() {
     for (const store of this._stores.values()) {
       store.close();
@@ -21452,11 +21640,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.
 
@@ -21493,27 +21682,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 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.
+
+**6 ACTIVATION SIGNALS** (each is binary - fires or doesn't):
+
+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"
+
+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"]
+
+3. **DOMAIN** - The domain word appears in user's message
+   - Be specific: "retrieval", "embeddings", "auth", "ui"
+   - NOT: "technical", "code", "implementation"
+
+4. **FEATURE** - The feature word appears in user's message
+   - Be specific: "scoring-weights", "gpu-acceleration", "login-flow"
+
+5. **CONTENT** - 3+ significant words from memory content overlap with message
+   - Automatic - based on the memory's content text
+
+6. **VECTOR** - Semantic similarity ≥ 40% (embedding cosine distance)
+   - Automatic - based on embeddings generated from content
+
+**RELEVANCE GATE**: A memory must have ≥2 signals to be considered relevant.
+If only 1 signal fires, the memory is REJECTED. This prevents noise.
 
-**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:
+**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)
 
-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"]
+**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
 
-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.
+**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
 
-3. **Domain field** (12% weight) - The specific area this relates to. Be precise: "embeddings", "gpu-compute", "authentication", not "technical" or "backend".
+**CRAFTING EFFECTIVE METADATA** (CRITICAL FOR RETRIEVAL):
 
-4. **Feature field** - Even more specific: "vector-search", "login-flow", "curation-prompt".
+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"]
 
-**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.
+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"]
 
-**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.
+3. **domain** (NEW - FILL THIS) - Single specific area word:
+   - GOOD: "retrieval", "embeddings", "curator", "signals", "fsdb"
+   - WEAK: "technical", "code", "memory" (too generic)
 
-**YOUR IMPORTANCE ASSESSMENT MATTERS** (18% weight): The importance_weight you assign is the single most influential factor. Use it wisely.
+4. **feature** (NEW - FILL THIS) - Specific feature within domain:
+   - GOOD: "scoring-algorithm", "activation-signals", "vector-search"
+   - WEAK: "implementation", "code", "logic"
 
-**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.
+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)
@@ -21581,6 +21825,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 {
@@ -21671,33 +21930,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);
@@ -46276,8 +46537,9 @@ class Manager {
   _config;
   constructor(config = {}) {
     this._config = {
+      enabled: config.enabled ?? true,
       cliCommand: config.cliCommand ?? getClaudeCommand2(),
-      maxTurns: config.maxTurns ?? 50
+      maxTurns: config.maxTurns
     };
   }
   async buildManagementPrompt() {
@@ -46298,14 +46560,31 @@ class Manager {
     }
     return null;
   }
-  buildUserMessage(projectId, sessionNumber, result) {
+  buildUserMessage(projectId, sessionNumber, result, storagePaths) {
     const today = new Date().toISOString().split("T")[0];
+    const pathsSection = storagePaths ? `
+## Storage Paths (ACTUAL - use these exact paths)
+
+**Storage Mode:** ${storagePaths.storageMode}
+
+### Project Storage
+- **Project Root:** ${storagePaths.projectPath}
+- **Project Memories:** ${storagePaths.projectMemoriesPath}
+
+### Global Storage (shared across all projects)
+- **Global Root:** ${storagePaths.globalPath}
+- **Global Memories:** ${storagePaths.globalMemoriesPath}
+- **Personal Primer:** ${storagePaths.personalPrimerPath}
+
+> ⚠️ These paths are resolved from the running server configuration. Use them exactly as provided.
+> Memories are stored as individual markdown files in the memories directories.
+` : "";
     return `## Curation Data
 
 **Project ID:** ${projectId}
 **Session Number:** ${sessionNumber}
 **Date:** ${today}
-
+${pathsSection}
 ### Session Summary
 ${result.session_summary || "No summary provided"}
 
@@ -46331,56 +46610,105 @@ ${result.memories.map((m2, i2) => `
 
 ---
 
-Please process these memories according to your management procedure. Update, supersede, or link existing memories as needed. Update the personal primer if any personal memories warrant it.`;
+Please process these memories according to your management procedure. Use the exact storage paths provided above to read and write memory files. Update, supersede, or link existing memories as needed. Update the personal primer if any personal memories warrant it.`;
   }
   parseManagementResponse(responseJson) {
+    const emptyResult = (error) => ({
+      success: !error,
+      superseded: 0,
+      resolved: 0,
+      linked: 0,
+      filesRead: 0,
+      filesWritten: 0,
+      primerUpdated: false,
+      actions: [],
+      summary: error ? "" : "No actions taken",
+      fullReport: error ? `Error: ${error}` : "",
+      error
+    });
     try {
       const cliOutput = JSON.parse(responseJson);
       if (cliOutput.type === "error" || cliOutput.is_error === true) {
-        return {
-          success: false,
-          superseded: 0,
-          resolved: 0,
-          linked: 0,
-          primerUpdated: false,
-          summary: "",
-          error: cliOutput.error || "Unknown error"
-        };
+        return emptyResult(cliOutput.error || "Unknown error");
       }
       const resultText = typeof cliOutput.result === "string" ? cliOutput.result : "";
-      const supersededMatch = resultText.match(/superseded[:\s]+(\d+)/i);
-      const resolvedMatch = resultText.match(/resolved[:\s]+(\d+)/i);
-      const linkedMatch = resultText.match(/linked[:\s]+(\d+)/i);
-      const primerUpdated = /primer.*updated|updated.*primer/i.test(resultText);
+      const reportMatch = resultText.match(/(=== MANAGEMENT ACTIONS ===[\s\S]*)/);
+      const fullReport = reportMatch ? reportMatch[1].trim() : resultText;
+      const actionsMatch = resultText.match(/=== MANAGEMENT ACTIONS ===([\s\S]*?)(?:=== SUMMARY ===|$)/);
+      const actions = [];
+      if (actionsMatch) {
+        const actionsText = actionsMatch[1];
+        const actionLines = actionsText.split(`
+`).map((line) => line.trim()).filter((line) => /^(READ|WRITE|RECEIVED|CREATED|UPDATED|SUPERSEDED|RESOLVED|LINKED|PRIMER|SKIPPED|NO_ACTION)/.test(line));
+        actions.push(...actionLines);
+      }
+      const supersededMatch = resultText.match(/memories_superseded[:\s]+(\d+)/i) || resultText.match(/superseded[:\s]+(\d+)/i);
+      const resolvedMatch = resultText.match(/memories_resolved[:\s]+(\d+)/i) || resultText.match(/resolved[:\s]+(\d+)/i);
+      const linkedMatch = resultText.match(/memories_linked[:\s]+(\d+)/i) || resultText.match(/linked[:\s]+(\d+)/i);
+      const filesReadMatch = resultText.match(/files_read[:\s]+(\d+)/i);
+      const filesWrittenMatch = resultText.match(/files_written[:\s]+(\d+)/i);
+      const primerUpdated = /primer_updated[:\s]+true/i.test(resultText) || /PRIMER\s+OK/i.test(resultText);
+      const readActions = actions.filter((a2) => a2.startsWith("READ OK")).length;
+      const writeActions = actions.filter((a2) => a2.startsWith("WRITE OK")).length;
       return {
         success: true,
         superseded: supersededMatch ? parseInt(supersededMatch[1]) : 0,
         resolved: resolvedMatch ? parseInt(resolvedMatch[1]) : 0,
         linked: linkedMatch ? parseInt(linkedMatch[1]) : 0,
+        filesRead: filesReadMatch ? parseInt(filesReadMatch[1]) : readActions,
+        filesWritten: filesWrittenMatch ? parseInt(filesWrittenMatch[1]) : writeActions,
         primerUpdated,
-        summary: resultText.slice(0, 500)
+        actions,
+        summary: resultText.slice(0, 500),
+        fullReport
       };
     } catch {
-      return {
-        success: false,
-        superseded: 0,
-        resolved: 0,
-        linked: 0,
-        primerUpdated: false,
-        summary: "",
-        error: "Failed to parse response"
-      };
-    }
+      return emptyResult("Failed to parse response");
+    }
+  }
+  async _buildSettingsFile(storagePaths) {
+    const allowRules = [];
+    const globalPath = storagePaths?.globalPath ?? import_path5.join(import_os4.homedir(), ".local", "share", "memory", "global");
+    const projectPath = storagePaths?.projectPath ?? import_path5.join(import_os4.homedir(), ".local", "share", "memory");
+    allowRules.push("Glob");
+    allowRules.push("Grep");
+    const formatPath = (p2) => p2.startsWith("/") ? "/" + p2 : "//" + p2;
+    allowRules.push(`Read(${formatPath(globalPath)}/**)`);
+    allowRules.push(`Write(${formatPath(globalPath)}/**)`);
+    allowRules.push(`Edit(${formatPath(globalPath)}/**)`);
+    allowRules.push(`Read(${formatPath(projectPath)}/**)`);
+    allowRules.push(`Write(${formatPath(projectPath)}/**)`);
+    allowRules.push(`Edit(${formatPath(projectPath)}/**)`);
+    const settings = {
+      permissions: {
+        allow: allowRules,
+        deny: [
+          "Read(/etc/**)",
+          "Read(~/.ssh/**)",
+          "Read(~/.aws/**)",
+          "Read(~/.gnupg/**)",
+          "Read(.env)",
+          "Read(.env.*)"
+        ]
+      }
+    };
+    const tempPath = import_path5.join(import_os4.homedir(), ".local", "share", "memory", ".manager-settings.json");
+    await Bun.write(tempPath, JSON.stringify(settings, null, 2));
+    return tempPath;
   }
-  async manageWithCLI(projectId, sessionNumber, result) {
-    if (process.env.MEMORY_MANAGER_DISABLED === "1") {
+  async manageWithCLI(projectId, sessionNumber, result, storagePaths) {
+    if (!this._config.enabled || process.env.MEMORY_MANAGER_DISABLED === "1") {
       return {
         success: true,
         superseded: 0,
         resolved: 0,
         linked: 0,
+        filesRead: 0,
+        filesWritten: 0,
         primerUpdated: false,
-        summary: "Management agent disabled"
+        actions: [],
+        summary: "Management agent disabled",
+        fullReport: "Management agent disabled via configuration"
       };
     }
     if (result.memories.length === 0) {
@@ -46389,8 +46717,12 @@ Please process these memories according to your management procedure. Update, su
         superseded: 0,
         resolved: 0,
         linked: 0,
+        filesRead: 0,
+        filesWritten: 0,
         primerUpdated: false,
-        summary: "No memories to process"
+        actions: [],
+        summary: "No memories to process",
+        fullReport: "No memories to process - skipped"
       };
     }
     const systemPrompt = await this.buildManagementPrompt();
@@ -46400,12 +46732,17 @@ Please process these memories according to your management procedure. Update, su
         superseded: 0,
         resolved: 0,
         linked: 0,
+        filesRead: 0,
+        filesWritten: 0,
         primerUpdated: false,
+        actions: [],
         summary: "",
+        fullReport: "Error: Management skill file not found",
         error: "Management skill not found"
       };
     }
-    const userMessage = this.buildUserMessage(projectId, sessionNumber, result);
+    const userMessage = this.buildUserMessage(projectId, sessionNumber, result, storagePaths);
+    const settingsPath = await this._buildSettingsFile(storagePaths);
     const args = [
       "-p",
       userMessage,
@@ -46413,9 +46750,12 @@ Please process these memories according to your management procedure. Update, su
       systemPrompt,
       "--output-format",
       "json",
-      "--max-turns",
-      String(this._config.maxTurns)
+      "--settings",
+      settingsPath
     ];
+    if (this._config.maxTurns !== undefined) {
+      args.push("--max-turns", String(this._config.maxTurns));
+    }
     const proc = Bun.spawn([this._config.cliCommand, ...args], {
       env: {
         ...process.env,
@@ -46429,14 +46769,20 @@ Please process these memories according to your management procedure. Update, su
     ]);
     const exitCode = await proc.exited;
     if (exitCode !== 0) {
+      const errorMsg = stderr || `Exit code ${exitCode}`;
       return {
         success: false,
         superseded: 0,
         resolved: 0,
         linked: 0,
+        filesRead: 0,
+        filesWritten: 0,
         primerUpdated: false,
+        actions: [],
         summary: "",
-        error: stderr || `Exit code ${exitCode}`
+        fullReport: `Error: CLI failed with exit code ${exitCode}
+${stderr}`,
+        error: errorMsg
       };
     }
     return this.parseManagementResponse(stdout);
@@ -46453,17 +46799,28 @@ async function createServer(config = {}) {
     host = "localhost",
     curator: curatorConfig,
     manager: managerConfig,
+    managerEnabled,
+    personalMemoriesEnabled,
     ...engineConfig
   } = config;
   const embeddings = createEmbeddings();
   logger.info("Initializing embedding model (this may take a moment on first run)...");
   await embeddings.initialize();
+  const finalCuratorConfig = {
+    ...curatorConfig,
+    personalMemoriesEnabled: personalMemoriesEnabled ?? curatorConfig?.personalMemoriesEnabled
+  };
+  const finalManagerConfig = {
+    ...managerConfig,
+    enabled: managerEnabled ?? managerConfig?.enabled
+  };
   const engine = createEngine({
     ...engineConfig,
-    embedder: embeddings.createEmbedder()
+    embedder: embeddings.createEmbedder(),
+    personalMemoriesEnabled: finalCuratorConfig.personalMemoriesEnabled
   });
-  const curator = createCurator(curatorConfig);
-  const manager = createManager(managerConfig);
+  const curator = createCurator(finalCuratorConfig);
+  const manager = createManager(finalManagerConfig);
   const server = Bun.serve({
     port,
     hostname: host,
@@ -46532,18 +46889,22 @@ async function createServer(config = {}) {
                 logger.logCurationComplete(result.memories.length, result.session_summary);
                 logger.logCuratedMemories(result.memories);
                 const sessionNumber = await engine.getSessionNumber(body.project_id, body.project_path);
+                const storagePaths = engine.getStoragePaths(body.project_id, body.project_path);
                 setImmediate(async () => {
                   try {
                     logger.logManagementStart(result.memories.length);
                     const startTime = Date.now();
-                    const managementResult = await manager.manageWithCLI(body.project_id, sessionNumber, result);
+                    const managementResult = await manager.manageWithCLI(body.project_id, sessionNumber, result, storagePaths);
                     logger.logManagementComplete({
                       success: managementResult.success,
                       superseded: managementResult.superseded || undefined,
                       resolved: managementResult.resolved || undefined,
                       linked: managementResult.linked || undefined,
+                      filesRead: managementResult.filesRead || undefined,
+                      filesWritten: managementResult.filesWritten || undefined,
                       primerUpdated: managementResult.primerUpdated,
-                      summary: managementResult.summary.slice(0, 100),
+                      actions: managementResult.actions,
+                      fullReport: managementResult.fullReport,
                       error: managementResult.error
                     });
                     await engine.storeManagementLog({
@@ -46557,7 +46918,13 @@ async function createServer(config = {}) {
                       success: managementResult.success,
                       durationMs: Date.now() - startTime,
                       summary: managementResult.summary,
-                      error: managementResult.error
+                      fullReport: managementResult.fullReport,
+                      error: managementResult.error,
+                      details: {
+                        actions: managementResult.actions,
+                        filesRead: managementResult.filesRead,
+                        filesWritten: managementResult.filesWritten
+                      }
                     });
                   } catch (error) {
                     logger.error(`Management failed: ${error}`);
@@ -46606,11 +46973,15 @@ if (require.main == require.module) {
   const host = process.env.MEMORY_HOST ?? "localhost";
   const storageMode = process.env.MEMORY_STORAGE_MODE ?? "central";
   const apiKey = process.env.ANTHROPIC_API_KEY;
+  const managerEnabled = !["0", "false"].includes(process.env.MEMORY_MANAGER_ENABLED?.toLowerCase() ?? "");
+  const personalMemoriesEnabled = !["0", "false"].includes(process.env.MEMORY_PERSONAL_ENABLED?.toLowerCase() ?? "");
   (async () => {
     await createServer({
       port,
       host,
       storageMode,
+      managerEnabled,
+      personalMemoriesEnabled,
       curator: { apiKey }
     });
   })();