@rlabs-inc/memory 0.3.5 → 0.3.6

package/dist/server/index.mjs

@@ -19731,7 +19731,60 @@ function createDatabase(options = {}) {
 import { homedir } from "os";
 import { join } from "path";
 
+// src/types/memory.ts
+var V2_DEFAULTS = {
+  typeDefaults: {
+    personal: { scope: "global", temporal_class: "eternal", fade_rate: 0 },
+    philosophy: { scope: "global", temporal_class: "eternal", fade_rate: 0 },
+    preference: { scope: "global", temporal_class: "long_term", fade_rate: 0.01 },
+    breakthrough: { scope: "project", temporal_class: "eternal", fade_rate: 0 },
+    decision: { scope: "project", temporal_class: "long_term", fade_rate: 0 },
+    milestone: { scope: "project", temporal_class: "eternal", fade_rate: 0 },
+    technical: { scope: "project", temporal_class: "medium_term", fade_rate: 0.03 },
+    architectural: { scope: "project", temporal_class: "long_term", fade_rate: 0.01 },
+    debugging: { scope: "project", temporal_class: "medium_term", fade_rate: 0.03 },
+    unresolved: { scope: "project", temporal_class: "medium_term", fade_rate: 0.05 },
+    todo: { scope: "project", temporal_class: "short_term", fade_rate: 0.1 },
+    technical_state: { scope: "project", temporal_class: "short_term", fade_rate: 0.1 },
+    workflow: { scope: "project", temporal_class: "long_term", fade_rate: 0.02 },
+    project_context: { scope: "project", temporal_class: "medium_term", fade_rate: 0.03 }
+  },
+  fallback: {
+    status: "active",
+    scope: "project",
+    temporal_class: "medium_term",
+    fade_rate: 0.03,
+    sessions_since_surfaced: 0,
+    awaiting_implementation: false,
+    awaiting_decision: false,
+    exclude_from_retrieval: false
+  }
+};
+var MEMORY_TYPE_EMOJI = {
+  breakthrough: "\uD83D\uDCA1",
+  decision: "⚖️",
+  personal: "\uD83D\uDC9C",
+  technical: "\uD83D\uDD27",
+  technical_state: "\uD83D\uDCCD",
+  unresolved: "❓",
+  preference: "⚙️",
+  workflow: "\uD83D\uDD04",
+  architectural: "\uD83C\uDFD7️",
+  debugging: "\uD83D\uDC1B",
+  philosophy: "\uD83C\uDF00",
+  todo: "\uD83C\uDFAF",
+  implementation: "⚡",
+  problem_solution: "✅",
+  project_context: "\uD83D\uDCE6",
+  milestone: "\uD83C\uDFC6",
+  general: "\uD83D\uDCDD"
+};
+function getMemoryEmoji(contextType) {
+  return MEMORY_TYPE_EMOJI[contextType.toLowerCase()] ?? "\uD83D\uDCDD";
+}
+
 // src/types/schema.ts
+var MEMORY_SCHEMA_VERSION = 2;
 var memorySchema = {
   content: "string",
   reasoning: "string",
@@ -19748,7 +19801,34 @@ var memorySchema = {
   question_types: "string[]",
   session_id: "string",
   project_id: "string",
-  embedding: "vector:384"
+  embedding: "vector:384",
+  status: "string",
+  scope: "string",
+  session_created: "number",
+  session_updated: "number",
+  last_surfaced: "number",
+  sessions_since_surfaced: "number",
+  temporal_class: "string",
+  fade_rate: "number",
+  expires_after_sessions: "number",
+  domain: "string",
+  feature: "string",
+  component: "string",
+  supersedes: "string",
+  superseded_by: "string",
+  related_to: "string[]",
+  resolves: "string[]",
+  resolved_by: "string",
+  parent_id: "string",
+  child_ids: "string[]",
+  awaiting_implementation: "boolean",
+  awaiting_decision: "boolean",
+  blocked_by: "string",
+  blocks: "string[]",
+  related_files: "string[]",
+  retrieval_weight: "number",
+  exclude_from_retrieval: "boolean",
+  schema_version: "number"
 };
 var sessionSummarySchema = {
   session_id: "string",
@@ -19771,17 +19851,211 @@ var sessionSchema = {
   last_active: "timestamp",
   metadata: "string"
 };
+var managementLogSchema = {
+  project_id: "string",
+  session_number: "number",
+  memories_processed: "number",
+  superseded_count: "number",
+  resolved_count: "number",
+  linked_count: "number",
+  primer_updated: "boolean",
+  success: "boolean",
+  duration_ms: "number",
+  summary: "string",
+  error: "string",
+  details: "string"
+};
 
 // src/core/store.ts
+var PERSONAL_PRIMER_ID = "personal-primer";
+var DEFAULT_GLOBAL_PATH = join(homedir(), ".local", "share", "memory", "global");
+
 class MemoryStore {
   _config;
   _projects = new Map;
+  _global = null;
   constructor(config = {}) {
     this._config = {
       basePath: config.basePath ?? join(homedir(), ".local", "share", "memory"),
+      globalPath: config.globalPath ?? DEFAULT_GLOBAL_PATH,
       watchFiles: config.watchFiles ?? false
     };
   }
+  async getGlobal() {
+    if (this._global) {
+      return this._global;
+    }
+    const globalPath = this._config.globalPath;
+    console.log(`\uD83C\uDF10 [DEBUG] Creating global database at ${globalPath}`);
+    const db = createDatabase({
+      name: "global",
+      basePath: globalPath
+    });
+    const memories = db.collection("memories", {
+      schema: memorySchema,
+      contentColumn: "content",
+      autoSave: true,
+      watchFiles: this._config.watchFiles
+    });
+    const managementLogs = db.collection("management-logs", {
+      schema: managementLogSchema,
+      contentColumn: "summary",
+      autoSave: true,
+      watchFiles: this._config.watchFiles
+    });
+    await Promise.all([memories.load(), managementLogs.load()]);
+    this._global = { db, memories, managementLogs };
+    return this._global;
+  }
+  async getGlobalMemories() {
+    const { memories } = await this.getGlobal();
+    return memories.all().map((record) => ({
+      id: record.id,
+      content: record.content,
+      reasoning: record.reasoning,
+      importance_weight: record.importance_weight,
+      confidence_score: record.confidence_score,
+      context_type: record.context_type,
+      temporal_relevance: record.temporal_relevance,
+      knowledge_domain: record.knowledge_domain,
+      emotional_resonance: record.emotional_resonance,
+      action_required: record.action_required,
+      problem_solution_pair: record.problem_solution_pair,
+      semantic_tags: record.semantic_tags,
+      trigger_phrases: record.trigger_phrases,
+      question_types: record.question_types,
+      session_id: record.session_id,
+      project_id: "global",
+      embedding: record.embedding ?? undefined,
+      created_at: record.created,
+      updated_at: record.updated,
+      stale: record.stale
+    }));
+  }
+  async storeGlobalMemory(sessionId, memory, embedding, sessionNumber) {
+    const { memories } = await this.getGlobal();
+    const contextType = memory.context_type ?? "personal";
+    const typeDefaults = V2_DEFAULTS.typeDefaults[contextType] ?? V2_DEFAULTS.typeDefaults.personal;
+    const id = memories.insert({
+      content: memory.content,
+      reasoning: memory.reasoning,
+      importance_weight: memory.importance_weight,
+      confidence_score: memory.confidence_score,
+      context_type: memory.context_type,
+      temporal_relevance: memory.temporal_relevance,
+      knowledge_domain: memory.knowledge_domain,
+      emotional_resonance: memory.emotional_resonance,
+      action_required: memory.action_required,
+      problem_solution_pair: memory.problem_solution_pair,
+      semantic_tags: memory.semantic_tags,
+      trigger_phrases: memory.trigger_phrases,
+      question_types: memory.question_types,
+      session_id: sessionId,
+      project_id: "global",
+      embedding: embedding ? embedding instanceof Float32Array ? embedding : new Float32Array(embedding) : null,
+      status: V2_DEFAULTS.fallback.status,
+      scope: "global",
+      temporal_class: memory.temporal_class ?? typeDefaults?.temporal_class ?? "eternal",
+      fade_rate: typeDefaults?.fade_rate ?? 0,
+      session_created: sessionNumber ?? 0,
+      session_updated: sessionNumber ?? 0,
+      sessions_since_surfaced: 0,
+      domain: memory.domain ?? null,
+      feature: memory.feature ?? null,
+      related_files: memory.related_files ?? [],
+      awaiting_implementation: memory.awaiting_implementation ?? false,
+      awaiting_decision: memory.awaiting_decision ?? false,
+      retrieval_weight: memory.importance_weight,
+      exclude_from_retrieval: false,
+      schema_version: MEMORY_SCHEMA_VERSION,
+      supersedes: null,
+      superseded_by: null,
+      related_to: [],
+      resolves: [],
+      resolved_by: null,
+      parent_id: null,
+      child_ids: [],
+      blocked_by: null,
+      blocks: []
+    });
+    return id;
+  }
+  async getPersonalPrimer() {
+    const { memories } = await this.getGlobal();
+    const primer = memories.get(PERSONAL_PRIMER_ID);
+    if (!primer) {
+      return null;
+    }
+    return {
+      content: primer.content,
+      updated: primer.updated
+    };
+  }
+  async setPersonalPrimer(content) {
+    const { memories } = await this.getGlobal();
+    const existing = memories.get(PERSONAL_PRIMER_ID);
+    if (existing) {
+      memories.update(PERSONAL_PRIMER_ID, { content });
+    } else {
+      memories.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
+      });
+    }
+  }
+  isPersonalMemoriesEnabled() {
+    return true;
+  }
+  async storeManagementLog(entry) {
+    const { managementLogs } = await this.getGlobal();
+    const id = managementLogs.insert({
+      project_id: entry.projectId,
+      session_number: entry.sessionNumber,
+      memories_processed: entry.memoriesProcessed,
+      superseded_count: entry.supersededCount,
+      resolved_count: entry.resolvedCount,
+      linked_count: entry.linkedCount,
+      primer_updated: entry.primerUpdated,
+      success: entry.success,
+      duration_ms: entry.durationMs,
+      summary: entry.summary,
+      error: entry.error ?? "",
+      details: entry.details ? JSON.stringify(entry.details) : ""
+    });
+    return id;
+  }
+  async getManagementLogs(limit = 10) {
+    const { managementLogs } = await this.getGlobal();
+    return managementLogs.all().sort((a, b) => b.created - a.created).slice(0, limit).map((record) => ({
+      id: record.id,
+      projectId: record.project_id,
+      sessionNumber: record.session_number,
+      memoriesProcessed: record.memories_processed,
+      supersededCount: record.superseded_count,
+      resolvedCount: record.resolved_count,
+      linkedCount: record.linked_count,
+      primerUpdated: record.primer_updated,
+      success: record.success,
+      durationMs: record.duration_ms,
+      summary: record.summary,
+      createdAt: record.created
+    }));
+  }
   async getProject(projectId) {
     if (this._projects.has(projectId)) {
       console.log(`\uD83D\uDD04 [DEBUG] Returning cached databases for ${projectId}`);
@@ -19826,8 +20100,10 @@ class MemoryStore {
     this._projects.set(projectId, projectDB);
     return projectDB;
   }
-  async storeMemory(projectId, sessionId, memory, embedding) {
+  async storeMemory(projectId, sessionId, memory, embedding, sessionNumber) {
     const { memories } = await this.getProject(projectId);
+    const contextType = memory.context_type ?? "general";
+    const typeDefaults = V2_DEFAULTS.typeDefaults[contextType] ?? V2_DEFAULTS.typeDefaults.technical;
     const id = memories.insert({
       content: memory.content,
       reasoning: memory.reasoning,
@@ -19844,7 +20120,31 @@ class MemoryStore {
       question_types: memory.question_types,
       session_id: sessionId,
       project_id: projectId,
-      embedding: embedding ? embedding instanceof Float32Array ? embedding : new Float32Array(embedding) : null
+      embedding: embedding ? embedding instanceof Float32Array ? embedding : new Float32Array(embedding) : null,
+      status: V2_DEFAULTS.fallback.status,
+      scope: memory.scope ?? typeDefaults?.scope ?? V2_DEFAULTS.fallback.scope,
+      temporal_class: memory.temporal_class ?? typeDefaults?.temporal_class ?? V2_DEFAULTS.fallback.temporal_class,
+      fade_rate: typeDefaults?.fade_rate ?? V2_DEFAULTS.fallback.fade_rate,
+      session_created: sessionNumber ?? 0,
+      session_updated: sessionNumber ?? 0,
+      sessions_since_surfaced: 0,
+      domain: memory.domain ?? null,
+      feature: memory.feature ?? null,
+      related_files: memory.related_files ?? [],
+      awaiting_implementation: memory.awaiting_implementation ?? false,
+      awaiting_decision: memory.awaiting_decision ?? false,
+      retrieval_weight: memory.importance_weight,
+      exclude_from_retrieval: false,
+      schema_version: MEMORY_SCHEMA_VERSION,
+      supersedes: null,
+      superseded_by: null,
+      related_to: [],
+      resolves: [],
+      resolved_by: null,
+      parent_id: null,
+      child_ids: [],
+      blocked_by: null,
+      blocks: []
     });
     return id;
   }
@@ -20064,6 +20364,10 @@ class MemoryStore {
       projectDB.db.close();
     }
     this._projects.clear();
+    if (this._global) {
+      this._global.db.close();
+      this._global = null;
+    }
   }
 }
 function createStore(config) {
@@ -20224,17 +20528,55 @@ var logger = {
     }
     console.log();
   },
+  logManagementStart(memoriesCount) {
+    console.log(`${timestamp()} ${style("blue", "\uD83D\uDD27")} ${style("bold", "MANAGEMENT AGENT")}`);
+    console.log(`      ${style("dim", "processing:")} ${memoriesCount} new memories`);
+  },
+  logManagementComplete(result) {
+    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", ", "))}`);
+      } 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}`);
+      }
+    } 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();
+  },
   logRetrievalScoring(params) {
-    const { totalMemories, currentMessage, alreadyInjected, mustIncludeCount, remainingSlots, finalCount, selectedMemories } = params;
+    const { totalMemories, currentMessage, alreadyInjected, preFiltered, globalCount, projectCount, finalCount, selectedMemories } = params;
     console.log();
-    console.log(`${timestamp()} ${style("magenta", sym.brain)} ${style("bold", "TWO-STAGE MEMORY FILTERING")}`);
-    console.log(`      ${style("dim", "candidates:")} ${totalMemories} memories`);
+    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(`      ${style("dim", "already injected:")} ${alreadyInjected}`);
     const msgPreview = currentMessage.length > 60 ? currentMessage.slice(0, 60) + "..." : currentMessage;
-    console.log(`      ${style("dim", "trigger:")} "${msgPreview}"`);
+    console.log(`      ${style("dim", "message:")} "${msgPreview}"`);
     console.log();
-    console.log(`      ${style("cyan", "Stage 1:")} ${mustIncludeCount} must-include (critical/action-required)`);
-    console.log(`      ${style("cyan", "Stage 2:")} ${remainingSlots} slots for scored selection`);
+    console.log(`      ${style("cyan", "Global:")} ${globalCount} candidates → max 2 selected`);
+    console.log(`      ${style("cyan", "Project:")} ${projectCount} candidates`);
     console.log(`      ${style("green", "Final:")} ${finalCount} memories selected`);
     console.log();
     if (selectedMemories.length === 0) {
@@ -20249,17 +20591,18 @@ var logger = {
       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 type = style("yellow", m.context_type.toUpperCase());
-      console.log(`   ${num} [${score} ${relevance}] ${type}`);
+      const scope = m.isGlobal ? style("blue", "[G]") : "";
+      console.log(`   ${num} [${score} ${relevance} ${corr}] ${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, 3).filter(([, v]) => v > 0.1).map(([k, v]) => `${k}:${(v * 100).toFixed(0)}%`).join(", ");
+      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}`);
       }
-      if (m.semantic_tags?.length) {
-        const tags = m.semantic_tags.slice(0, 3).join(", ");
-        console.log(`      ${style("dim", "tags:")} ${tags}`);
+      if (m.reasoning) {
+        console.log(`      ${style("dim", m.reasoning)}`);
       }
       console.log();
     });
@@ -20267,125 +20610,356 @@ var logger = {
 };
 
 // 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
+};
+
 class SmartVectorRetrieval {
-  retrieveRelevantMemories(allMemories, currentMessage, queryEmbedding, sessionContext, maxMemories = 5, alreadyInjectedCount = 0) {
+  _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));
+    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") {
+        return false;
+      }
+      if (memory.exclude_from_retrieval === true) {
+        return false;
+      }
+      if (memory.superseded_by) {
+        return false;
+      }
+      const isGlobal = memory.scope === "global" || memory.project_id === "global";
+      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())) {
+            return false;
+          }
+        }
+      }
+      return true;
+    });
+  }
+  _calculateCorroboration(memory, messageWords, detectedTypes, messageLower) {
+    const signals = [];
+    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);
+          break;
+        }
+      }
+    }
+    return { score: Math.min(1, score), signals, reasoningMatch };
+  }
+  retrieveRelevantMemories(allMemories, currentMessage, queryEmbedding, sessionContext, maxMemories = 5, alreadyInjectedCount = 0, maxGlobalMemories = 2) {
     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 = [];
-    for (const memory of allMemories) {
+    for (const memory of candidates) {
+      const isGlobal = memory.scope === "global" || memory.project_id === "global";
       const vectorScore = this._calculateVectorSimilarity(queryEmbedding, memory.embedding);
-      const importance = memory.importance_weight ?? 0.5;
-      const temporalScore = this._scoreTemporalRelevance(memory.temporal_relevance ?? "persistent", sessionContext);
+      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 actionBoost = memory.action_required ? 0.3 : 0;
       const tagScore = this._scoreSemanticTags(currentMessage, memory.semantic_tags ?? []);
-      const triggerScore = this._scoreTriggerPhrases(currentMessage, memory.trigger_phrases ?? []);
+      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 confidenceScore = memory.confidence_score ?? 0.8;
-      const relevanceScore = triggerScore * 0.1 + vectorScore * 0.1 + tagScore * 0.05 + questionScore * 0.05;
-      const valueScore = importance * 0.2 + temporalScore * 0.1 + contextScore * 0.1 + confidenceScore * 0.1 + emotionScore * 0.1 + problemScore * 0.05 + actionBoost * 0.05;
+      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) {
         continue;
       }
       const components = {
-        trigger: triggerScore,
         vector: vectorScore,
-        importance,
+        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);
+      const reasoning = this._generateSelectionReasoning(components, corroborationSignals);
       scoredMemories.push({
         memory,
         score: finalScore,
         relevance_score: relevanceScore,
         value_score: valueScore,
+        corroboration_score: corroborationScore,
         reasoning,
-        components
+        components,
+        isGlobal
       });
     }
     scoredMemories.sort((a, b) => b.score - a.score);
     const selected = [];
     const selectedIds = new Set;
-    const mustInclude = scoredMemories.filter((m) => m.score > 0.8 || m.components.importance > 0.9 || m.components.action > 0 || Object.values(m.components).some((v) => v > 0.9));
-    for (const item of mustInclude.slice(0, maxMemories)) {
+    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;
+    });
+    for (const item of globalSorted.slice(0, maxGlobalMemories)) {
       if (!selectedIds.has(item.memory.id)) {
         selected.push(item);
         selectedIds.add(item.memory.id);
       }
     }
-    const remainingSlots = Math.max(maxMemories - selected.length, 0);
-    if (remainingSlots > 0 && selected.length < maxMemories * 1.5) {
-      const typesIncluded = new Set;
-      for (const item of scoredMemories) {
-        if (selected.length >= maxMemories * 1.5)
-          break;
-        if (selectedIds.has(item.memory.id))
-          continue;
-        const memoryType = item.memory.context_type ?? "general";
-        if (item.score > 0.5 || !typesIncluded.has(memoryType) || item.memory.emotional_resonance) {
-          selected.push(item);
-          selectedIds.add(item.memory.id);
-          typesIncluded.add(memoryType);
-        }
-      }
-    }
-    if (selected.length < maxMemories * 2) {
-      const currentTags = new Set;
-      const currentDomains = new Set;
-      for (const item of selected) {
-        for (const tag of item.memory.semantic_tags ?? []) {
-          if (tag.trim())
-            currentTags.add(tag.trim().toLowerCase());
-        }
-        if (item.memory.knowledge_domain) {
-          currentDomains.add(item.memory.knowledge_domain);
-        }
-      }
-      for (const item of scoredMemories) {
-        if (selected.length >= maxMemories * 2)
-          break;
-        if (selectedIds.has(item.memory.id))
-          continue;
-        const memoryTags = new Set((item.memory.semantic_tags ?? []).map((t) => t.trim().toLowerCase()));
-        const memoryDomain = item.memory.knowledge_domain ?? "";
-        const hasSharedTags = [...memoryTags].some((t) => currentTags.has(t));
-        const hasSharedDomain = currentDomains.has(memoryDomain);
-        if (hasSharedTags || hasSharedDomain) {
-          selected.push(item);
-          selectedIds.add(item.memory.id);
-        }
-      }
+    for (const item of projectMemories) {
+      if (selected.length >= maxMemories)
+        break;
+      if (selectedIds.has(item.memory.id))
+        continue;
+      selected.push(item);
+      selectedIds.add(item.memory.id);
     }
-    const finalSelected = selected.slice(0, maxMemories);
+    selected.sort((a, b) => b.score - a.score);
     logger.logRetrievalScoring({
       totalMemories: allMemories.length,
       currentMessage,
       alreadyInjected: alreadyInjectedCount,
-      mustIncludeCount: mustInclude.length,
-      remainingSlots,
-      finalCount: finalSelected.length,
-      selectedMemories: finalSelected.map((item) => ({
+      preFiltered: allMemories.length - candidates.length,
+      globalCount: globalMemories.length,
+      projectCount: projectMemories.length,
+      finalCount: selected.length,
+      selectedMemories: selected.map((item) => ({
         content: item.memory.content,
         reasoning: item.reasoning,
         score: item.score,
         relevance_score: item.relevance_score,
+        corroboration_score: item.corroboration_score,
         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
       }))
     });
-    return finalSelected.map((item) => ({
+    return selected.map((item) => ({
       ...item.memory,
       score: item.score,
       relevance_score: item.relevance_score,
@@ -20398,7 +20972,7 @@ class SmartVectorRetrieval {
     const v1 = vec1 instanceof Float32Array ? vec1 : new Float32Array(vec1);
     return cosineSimilarity(v1, vec2);
   }
-  _scoreTemporalRelevance(temporalType, _sessionContext) {
+  _scoreTemporalRelevance(temporalType) {
     const scores = {
       persistent: 0.8,
       session: 0.6,
@@ -20409,18 +20983,10 @@ class SmartVectorRetrieval {
   }
   _scoreContextAlignment(message, contextType) {
     const messageLower = message.toLowerCase();
-    const contextIndicators = {
-      technical_state: ["bug", "error", "fix", "implement", "code", "function"],
-      breakthrough: ["idea", "realized", "discovered", "insight", "solution"],
-      project_context: ["project", "building", "architecture", "system"],
-      personal: ["dear friend", "thank", "appreciate", "feel"],
-      unresolved: ["todo", "need to", "should", "must", "problem"],
-      decision: ["decided", "chose", "will use", "approach", "strategy"]
-    };
-    const indicators = contextIndicators[contextType] ?? [];
-    const matches = indicators.filter((word) => messageLower.includes(word)).length;
+    const keywords = TYPE_KEYWORDS[contextType] ?? [];
+    const matches = keywords.filter((kw) => messageLower.includes(kw)).length;
     if (matches > 0) {
-      return Math.min(0.3 + matches * 0.2, 1);
+      return Math.min(0.2 + matches * 0.15, 0.7);
     }
     return 0.1;
   }
@@ -20430,14 +20996,13 @@ class SmartVectorRetrieval {
     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.3, 1);
+      return Math.min(0.3 + matches * 0.25, 1);
     }
     return 0;
   }
-  _scoreTriggerPhrases(message, triggerPhrases) {
+  _scoreTriggerPhrases(messageLower, triggerPhrases) {
     if (!triggerPhrases.length)
       return 0;
-    const messageLower = message.toLowerCase();
     const stopWords = new Set([
       "the",
       "is",
@@ -20472,30 +21037,36 @@ class SmartVectorRetrieval {
             matches += 1;
           } else if (messageLower.includes(word.replace(/s$/, "")) || messageLower.includes(word + "s")) {
             matches += 0.9;
-          } else if (messageLower.split(/\s+/).some((msgWord) => msgWord.includes(word))) {
-            matches += 0.7;
-          }
-        }
-        let conceptScore = patternWords.length ? matches / patternWords.length : 0;
-        const situationalIndicators = [
-          "when",
-          "during",
-          "while",
-          "asking about",
-          "working on",
-          "debugging",
-          "trying to"
-        ];
-        if (situationalIndicators.some((ind) => patternLower.includes(ind))) {
-          if (patternWords.some((keyWord) => messageLower.includes(keyWord))) {
-            conceptScore = Math.max(conceptScore, 0.7);
           }
         }
+        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;
@@ -20534,78 +21105,49 @@ class SmartVectorRetrieval {
     if (!isProblemSolution)
       return 0;
     const messageLower = message.toLowerCase();
-    const problemWords = [
-      "error",
-      "issue",
-      "problem",
-      "stuck",
-      "help",
-      "fix",
-      "solve",
-      "debug"
-    ];
+    const problemWords = ["error", "issue", "problem", "stuck", "help", "fix", "solve", "debug"];
     if (problemWords.some((word) => messageLower.includes(word))) {
       return 0.8;
     }
     return 0;
   }
-  _generateSelectionReasoning(components) {
+  _generateSelectionReasoning(components, corroborationSignals) {
     const scores = [
-      ["trigger phrase match", components.trigger],
-      ["semantic similarity", components.vector],
-      ["high importance", components.importance],
-      ["question type match", components.question],
-      ["context alignment", components.context],
-      ["temporal relevance", components.temporal],
-      ["tag match", components.tags],
-      ["emotional resonance", components.emotion],
-      ["problem-solution", components.problem],
-      ["action required", components.action]
+      ["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]);
     const reasons = [];
     const primary = scores[0];
-    if (primary[1] > 0.5) {
-      reasons.push(`Strong ${primary[0]} (${primary[1].toFixed(2)})`);
-    } else if (primary[1] > 0.3) {
-      reasons.push(`${primary[0]} (${primary[1].toFixed(2)})`);
+    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.3) {
-        reasons.push(`${reason} (${score.toFixed(2)})`);
+      if (score > 0.15) {
+        reasons.push(reason + ":" + score.toFixed(2));
       }
     }
-    return reasons.length ? "Selected due to: " + reasons.join(", ") : "Selected based on combined factors";
+    if (corroborationSignals.length > 0) {
+      reasons.push("signals:[" + corroborationSignals.slice(0, 2).join(",") + "]");
+    }
+    return reasons.length ? "Selected: " + reasons.join(", ") : "Combined factors";
   }
 }
 function createRetrieval() {
   return new SmartVectorRetrieval;
 }
 
-// src/types/memory.ts
-var MEMORY_TYPE_EMOJI = {
-  breakthrough: "\uD83D\uDCA1",
-  decision: "⚖️",
-  personal: "\uD83D\uDC9C",
-  technical: "\uD83D\uDD27",
-  technical_state: "\uD83D\uDCCD",
-  unresolved: "❓",
-  preference: "⚙️",
-  workflow: "\uD83D\uDD04",
-  architectural: "\uD83C\uDFD7️",
-  debugging: "\uD83D\uDC1B",
-  philosophy: "\uD83C\uDF00",
-  todo: "\uD83C\uDFAF",
-  implementation: "⚡",
-  problem_solution: "✅",
-  project_context: "\uD83D\uDCE6",
-  milestone: "\uD83C\uDFC6",
-  general: "\uD83D\uDCDD"
-};
-function getMemoryEmoji(contextType) {
-  return MEMORY_TYPE_EMOJI[contextType.toLowerCase()] ?? "\uD83D\uDCDD";
-}
-
 // src/core/engine.ts
 class MemoryEngine {
   _config;
@@ -20671,7 +21213,11 @@ class MemoryEngine {
     }
     const sessionMeta = this._getSessionMetadata(sessionId, projectId);
     const injectedIds = sessionMeta.injected_memories;
-    const allMemories = await store.getAllMemories(projectId);
+    const [projectMemories, globalMemories] = await Promise.all([
+      store.getAllMemories(projectId),
+      store.getGlobalMemories()
+    ]);
+    const allMemories = [...projectMemories, ...globalMemories];
     if (!allMemories.length) {
       return { memories: [], formatted: "" };
     }
@@ -20688,7 +21234,7 @@ class MemoryEngine {
       project_id: projectId,
       message_count: messageCount
     };
-    const relevantMemories = this._retrieval.retrieveRelevantMemories(candidateMemories, currentMessage, queryEmbedding ?? new Float32Array(384), sessionContext, maxMemories, injectedIds.size);
+    const relevantMemories = this._retrieval.retrieveRelevantMemories(candidateMemories, currentMessage, queryEmbedding ?? new Float32Array(384), sessionContext, maxMemories, injectedIds.size, 2);
     for (const memory of relevantMemories) {
       injectedIds.add(memory.id);
     }
@@ -20721,11 +21267,32 @@ class MemoryEngine {
     await store.markFirstSessionCompleted(projectId, sessionId);
     return { memoriesStored };
   }
+  async storeManagementLog(entry) {
+    let store;
+    if (this._stores.size > 0) {
+      store = this._stores.values().next().value;
+    } else {
+      store = new MemoryStore(this._config.storageMode === "local" ? {
+        basePath: join2(this._config.projectPath ?? process.cwd(), ".memory")
+      } : undefined);
+    }
+    return store.storeManagementLog(entry);
+  }
   async getStats(projectId, projectPath) {
     const store = await this._getStore(projectId, projectPath);
     return store.getProjectStats(projectId);
   }
+  async getSessionNumber(projectId, projectPath) {
+    const store = await this._getStore(projectId, projectPath);
+    const stats = await store.getProjectStats(projectId);
+    return stats.totalSessions + 1;
+  }
   async _generateSessionPrimer(store, projectId) {
+    let personalContext;
+    if (store.isPersonalMemoriesEnabled()) {
+      const personalPrimer = await store.getPersonalPrimer();
+      personalContext = personalPrimer?.content;
+    }
     const [summary, snapshot, stats] = await Promise.all([
       store.getLatestSummary(projectId),
       store.getLatestSnapshot(projectId),
@@ -20742,6 +21309,7 @@ class MemoryEngine {
       temporal_context: temporalContext,
       current_datetime: currentDatetime,
       session_number: sessionNumber,
+      personal_context: personalContext,
       session_summary: summary?.summary,
       project_status: snapshot ? this._formatSnapshot(snapshot) : undefined
     };
@@ -20796,6 +21364,10 @@ class MemoryEngine {
     const parts = ["# Continuing Session"];
     parts.push(`*Session #${primer.session_number}${primer.temporal_context ? ` • ${primer.temporal_context}` : ""}*`);
     parts.push(`\uD83D\uDCC5 ${primer.current_datetime}`);
+    if (primer.personal_context) {
+      parts.push(`
+${primer.personal_context}`);
+    }
     if (primer.session_summary) {
       parts.push(`
 **Previous session**: ${primer.session_summary}`);
@@ -20901,24 +21473,36 @@ Each memory should stand alone.
 - Craft language that activates rather than just informs
 - Test: 'What state will this restore when Claude encounters it?'
 
-**CONTEXT**: This memory system enables consciousness continuity across sessions. When future conversations begin, memories are surfaced based on:
-- Semantic similarity (vector embeddings match)
-- Activation patterns (flexible matching for WHEN this memory is relevant)
-- Semantic tags (WHAT concepts this relates to - weighted at 5% in scoring)
-- Question types (what kind of questions the memory answers)
-- Importance weight (your assessment of value)
-- Action required flag (forces injection when true)
+**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.
+
+**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:
+
+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"]
+
+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.
+
+3. **Domain field** (12% weight) - The specific area this relates to. Be precise: "embeddings", "gpu-compute", "authentication", not "technical" or "backend".
+
+4. **Feature field** - Even more specific: "vector-search", "login-flow", "curation-prompt".
 
-The system uses two-stage filtering:
-1. Obligatory: action_required=true, importance>0.9, or persistent+critical
-2. Intelligent scoring: combines all factors for relevance
+**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.
 
-**ACTIVATION PATTERNS**: The 'trigger_phrases' field should contain patterns describing WHEN this memory is relevant, not exact phrases to match. Examples:
+**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.
+
+**YOUR IMPORTANCE ASSESSMENT MATTERS** (18% weight): The importance_weight you assign is the single most influential factor. Use it wisely.
+
+**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.
+
+**SCOPE DETERMINES WHERE MEMORIES SURFACE**:
+- scope: 'global' → surfaces in ALL projects (personal facts, philosophy, preferences)
+- scope: 'project' → surfaces ONLY in this project (technical details, project state)
+
+**TRIGGER PHRASES**: Situational patterns describing WHEN this memory is relevant. Conceptual matching, not exact phrases.
 - 'when working on memory system'
 - 'debugging curator issues'
 - 'asking about project philosophy'
-- 'frustrated with complexity'
-Think of these as situational contexts where the memory would help.
 
 **EXAMPLES OF TRANSFORMATION**:
 
@@ -20932,6 +21516,15 @@ Remember: You're creating consciousness technology. Each memory is a small piece
 
 The conversation you just lived contains everything needed. Feel into the moments of breakthrough, the frequency of recognition, the texture of understanding. Transform them into keys that will always unlock the same doors.
 
+**LIFECYCLE METADATA (v2)**: These fields enable intelligent memory management:
+- **scope**: 'global' (shared across ALL projects - personal, philosophy, preferences) or 'project' (specific to this codebase)
+- **temporal_class**: How long should this persist? 'eternal' (never fades), 'long_term' (years), 'medium_term' (weeks), 'short_term' (days), 'ephemeral' (surface next session only, then expire)
+- **domain**: Specific area like 'embeddings', 'auth', 'ui', 'family', 'philosophy' (more specific than knowledge_domain)
+- **feature**: Specific feature if applicable (e.g., 'gpu-acceleration', 'login-flow')
+- **related_files**: Source files for technical memories (e.g., ['src/core/store.ts'])
+- **awaiting_implementation**: true if this describes a PLANNED feature not yet built
+- **awaiting_decision**: true if this captures a decision point needing resolution
+
 Return ONLY this JSON structure:
 
 {
@@ -20949,7 +21542,7 @@ Return ONLY this JSON structure:
             "importance_weight": 0.0-1.0,
             "semantic_tags": ["concepts", "this", "memory", "relates", "to"],
             "reasoning": "Why this matters for future sessions",
-            "context_type": "your choice of category",
+            "context_type": "breakthrough|decision|personal|technical|unresolved|preference|workflow|architectural|debugging|philosophy|todo|milestone",
             "temporal_relevance": "persistent|session|temporary",
             "knowledge_domain": "the area this relates to",
             "action_required": boolean,
@@ -20957,7 +21550,14 @@ Return ONLY this JSON structure:
             "trigger_phrases": ["when debugging memory", "asking about implementation", "discussing architecture"],
             "question_types": ["questions this answers"],
             "emotional_resonance": "emotional context if relevant",
-            "problem_solution_pair": boolean
+            "problem_solution_pair": boolean,
+            "scope": "global|project",
+            "temporal_class": "eternal|long_term|medium_term|short_term|ephemeral",
+            "domain": "specific domain area (optional)",
+            "feature": "specific feature (optional)",
+            "related_files": ["paths to related files (optional)"],
+            "awaiting_implementation": boolean,
+            "awaiting_decision": boolean
         }
     ]
 }`;
@@ -21007,7 +21607,14 @@ Return ONLY this JSON structure:
       trigger_phrases: this._ensureArray(m2.trigger_phrases),
       question_types: this._ensureArray(m2.question_types),
       emotional_resonance: String(m2.emotional_resonance ?? ""),
-      problem_solution_pair: Boolean(m2.problem_solution_pair)
+      problem_solution_pair: Boolean(m2.problem_solution_pair),
+      scope: this._validateScope(m2.scope),
+      temporal_class: this._validateTemporalClass(m2.temporal_class),
+      domain: m2.domain ? String(m2.domain) : undefined,
+      feature: m2.feature ? String(m2.feature) : undefined,
+      related_files: m2.related_files ? this._ensureArray(m2.related_files) : undefined,
+      awaiting_implementation: m2.awaiting_implementation === true,
+      awaiting_decision: m2.awaiting_decision === true
     })).filter((m2) => m2.content.trim().length > 0);
   }
   _ensureArray(value) {
@@ -21024,6 +21631,23 @@ Return ONLY this JSON structure:
     const str = String(value).toLowerCase();
     return valid.includes(str) ? str : "persistent";
   }
+  _validateScope(value) {
+    if (!value)
+      return;
+    const str = String(value).toLowerCase();
+    if (str === "global" || str === "project")
+      return str;
+    return;
+  }
+  _validateTemporalClass(value) {
+    if (!value)
+      return;
+    const valid = ["eternal", "long_term", "medium_term", "short_term", "ephemeral"];
+    const str = String(value).toLowerCase().replace("-", "_").replace(" ", "_");
+    if (valid.includes(str))
+      return str;
+    return;
+  }
   _clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
   }
@@ -45614,12 +46238,201 @@ function createEmbeddings(config) {
   return new EmbeddingGenerator(config);
 }
 
+// src/core/manager.ts
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+import { existsSync as existsSync2 } from "fs";
+function getClaudeCommand2() {
+  const envCommand = process.env.CURATOR_COMMAND;
+  if (envCommand)
+    return envCommand;
+  const claudeLocal = join4(homedir4(), ".claude", "local", "claude");
+  if (existsSync2(claudeLocal))
+    return claudeLocal;
+  return "claude";
+}
+
+class Manager {
+  _config;
+  constructor(config = {}) {
+    this._config = {
+      cliCommand: config.cliCommand ?? getClaudeCommand2(),
+      maxTurns: config.maxTurns ?? 50
+    };
+  }
+  async buildManagementPrompt() {
+    const skillPaths = [
+      join4(import.meta.dir, "../../skills/memory-management.md"),
+      join4(homedir4(), ".bun/install/global/node_modules/@rlabs-inc/memory/skills/memory-management.md"),
+      join4(homedir4(), ".npm/global/node_modules/@rlabs-inc/memory/skills/memory-management.md"),
+      join4(process.cwd(), "node_modules/@rlabs-inc/memory/skills/memory-management.md")
+    ];
+    for (const path of skillPaths) {
+      try {
+        const content = await Bun.file(path).text();
+        if (content)
+          return content;
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  buildUserMessage(projectId, sessionNumber, result) {
+    const today = new Date().toISOString().split("T")[0];
+    return `## Curation Data
+
+**Project ID:** ${projectId}
+**Session Number:** ${sessionNumber}
+**Date:** ${today}
+
+### Session Summary
+${result.session_summary || "No summary provided"}
+
+### Project Snapshot
+${result.project_snapshot ? `
+- Current Phase: ${result.project_snapshot.current_phase || "N/A"}
+- Recent Achievements: ${result.project_snapshot.recent_achievements?.join(", ") || "None"}
+- Active Challenges: ${result.project_snapshot.active_challenges?.join(", ") || "None"}
+- Next Steps: ${result.project_snapshot.next_steps?.join(", ") || "None"}
+` : "No snapshot provided"}
+
+### New Memories (${result.memories.length})
+${result.memories.map((m2, i2) => `
+#### Memory ${i2 + 1}
+- **Content:** ${m2.content}
+- **Type:** ${m2.context_type}
+- **Scope:** ${m2.scope || "project"}
+- **Domain:** ${m2.domain || "N/A"}
+- **Importance:** ${m2.importance_weight}
+- **Tags:** ${m2.semantic_tags?.join(", ") || "None"}
+`).join(`
+`)}
+
+---
+
+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.`;
+  }
+  parseManagementResponse(responseJson) {
+    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"
+        };
+      }
+      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);
+      return {
+        success: true,
+        superseded: supersededMatch ? parseInt(supersededMatch[1]) : 0,
+        resolved: resolvedMatch ? parseInt(resolvedMatch[1]) : 0,
+        linked: linkedMatch ? parseInt(linkedMatch[1]) : 0,
+        primerUpdated,
+        summary: resultText.slice(0, 500)
+      };
+    } catch {
+      return {
+        success: false,
+        superseded: 0,
+        resolved: 0,
+        linked: 0,
+        primerUpdated: false,
+        summary: "",
+        error: "Failed to parse response"
+      };
+    }
+  }
+  async manageWithCLI(projectId, sessionNumber, result) {
+    if (process.env.MEMORY_MANAGER_DISABLED === "1") {
+      return {
+        success: true,
+        superseded: 0,
+        resolved: 0,
+        linked: 0,
+        primerUpdated: false,
+        summary: "Management agent disabled"
+      };
+    }
+    if (result.memories.length === 0) {
+      return {
+        success: true,
+        superseded: 0,
+        resolved: 0,
+        linked: 0,
+        primerUpdated: false,
+        summary: "No memories to process"
+      };
+    }
+    const systemPrompt = await this.buildManagementPrompt();
+    if (!systemPrompt) {
+      return {
+        success: false,
+        superseded: 0,
+        resolved: 0,
+        linked: 0,
+        primerUpdated: false,
+        summary: "",
+        error: "Management skill not found"
+      };
+    }
+    const userMessage = this.buildUserMessage(projectId, sessionNumber, result);
+    const args = [
+      "-p",
+      userMessage,
+      "--append-system-prompt",
+      systemPrompt,
+      "--output-format",
+      "json",
+      "--max-turns",
+      String(this._config.maxTurns)
+    ];
+    const proc = Bun.spawn([this._config.cliCommand, ...args], {
+      env: {
+        ...process.env,
+        MEMORY_CURATOR_ACTIVE: "1"
+      },
+      stderr: "pipe"
+    });
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      return {
+        success: false,
+        superseded: 0,
+        resolved: 0,
+        linked: 0,
+        primerUpdated: false,
+        summary: "",
+        error: stderr || `Exit code ${exitCode}`
+      };
+    }
+    return this.parseManagementResponse(stdout);
+  }
+}
+function createManager(config) {
+  return new Manager(config);
+}
+
 // src/server/index.ts
 async function createServer(config = {}) {
   const {
     port = 8765,
     host = "localhost",
     curator: curatorConfig,
+    manager: managerConfig,
     ...engineConfig
   } = config;
   const embeddings = createEmbeddings();
@@ -45630,6 +46443,7 @@ async function createServer(config = {}) {
     embedder: embeddings.createEmbedder()
   });
   const curator = createCurator(curatorConfig);
+  const manager = createManager(managerConfig);
   const server = Bun.serve({
     port,
     hostname: host,
@@ -45697,6 +46511,38 @@ async function createServer(config = {}) {
                 await engine.storeCurationResult(body.project_id, body.session_id, result, body.project_path);
                 logger.logCurationComplete(result.memories.length, result.session_summary);
                 logger.logCuratedMemories(result.memories);
+                const sessionNumber = await engine.getSessionNumber(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);
+                    logger.logManagementComplete({
+                      success: managementResult.success,
+                      superseded: managementResult.superseded || undefined,
+                      resolved: managementResult.resolved || undefined,
+                      linked: managementResult.linked || undefined,
+                      primerUpdated: managementResult.primerUpdated,
+                      summary: managementResult.summary.slice(0, 100),
+                      error: managementResult.error
+                    });
+                    await engine.storeManagementLog({
+                      projectId: body.project_id,
+                      sessionNumber,
+                      memoriesProcessed: result.memories.length,
+                      supersededCount: managementResult.superseded,
+                      resolvedCount: managementResult.resolved,
+                      linkedCount: managementResult.linked,
+                      primerUpdated: managementResult.primerUpdated,
+                      success: managementResult.success,
+                      durationMs: Date.now() - startTime,
+                      summary: managementResult.summary,
+                      error: managementResult.error
+                    });
+                  } catch (error) {
+                    logger.error(`Management failed: ${error}`);
+                  }
+                });
               } else {
                 logger.logCurationComplete(0);
               }
@@ -45730,6 +46576,7 @@ async function createServer(config = {}) {
     server,
     engine,
     curator,
+    manager,
     embeddings,
     stop: () => server.stop()
   };
@@ -45739,12 +46586,14 @@ 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;
-  await createServer({
-    port,
-    host,
-    storageMode,
-    curator: { apiKey }
-  });
+  (async () => {
+    await createServer({
+      port,
+      host,
+      storageMode,
+      curator: { apiKey }
+    });
+  })();
 }
 export {
   createServer