@rlabs-inc/memory 0.3.5 → 0.3.7

package/dist/index.js

@@ -11995,7 +11995,60 @@ function createDatabase(options = {}) {
 var import_os = require("os");
 var import_path = require("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",
@@ -12012,7 +12065,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",
@@ -12035,17 +12115,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 = import_path.join(import_os.homedir(), ".local", "share", "memory", "global");
+
 class MemoryStore {
   _config;
   _projects = new Map;
+  _global = null;
   constructor(config = {}) {
     this._config = {
       basePath: config.basePath ?? import_path.join(import_os.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}`);
@@ -12090,8 +12364,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,
@@ -12108,7 +12384,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;
   }
@@ -12328,6 +12628,10 @@ class MemoryStore {
       projectDB.db.close();
     }
     this._projects.clear();
+    if (this._global) {
+      this._global.db.close();
+      this._global = null;
+    }
   }
 }
 function createStore(config) {
@@ -12488,17 +12792,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) {
@@ -12513,17 +12855,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();
     });
@@ -12531,125 +12874,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,
@@ -12662,7 +13236,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,
@@ -12673,18 +13247,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;
   }
@@ -12694,14 +13260,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",
@@ -12736,30 +13301,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;
@@ -12798,78 +13369,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;
@@ -12935,7 +13477,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: "" };
     }
@@ -12952,7 +13498,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);
     }
@@ -12985,11 +13531,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: import_path2.join(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),
@@ -13006,6 +13573,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
     };
@@ -13060,6 +13628,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}`);
@@ -13164,24 +13736,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"]
 
-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
+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.
 
-**ACTIVATION PATTERNS**: The 'trigger_phrases' field should contain patterns describing WHEN this memory is relevant, not exact phrases to match. Examples:
+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".
+
+**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.
+
+**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**:
 
@@ -13195,6 +13779,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:
 
 {
@@ -13212,7 +13805,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,
@@ -13220,7 +13813,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
         }
     ]
 }`;
@@ -13270,7 +13870,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) {
@@ -13287,6 +13894,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));
   }