feat: contextual support — 6-decision dedup with per-context preference tracking

Extends OpenViking's smart memory architecture with context-aware support:

- smart-metadata.ts: add SupportInfoV2/ContextualSupport types, normalizeContext,
  parseSupportInfo (V1→V2 migration), updateSupportStats; fix LegacyStoreCategory
  missing 'reflection'
- memory-categories.ts: extend DedupDecision with support/contextualize/contradict,
  add contextLabel to DedupResult, supported count to ExtractionStats
- extraction-prompts.ts: extend dedup prompt with 3 new decisions + context_label
- smart-extractor.ts: add handleSupport/handleContextualize/handleContradict handlers
  in processCandidate pipeline, extract contextLabel in llmDedupDecision
- test: add smart-metadata-v2.mjs (6 tests, all passing)

Author: LvPengfei1

src/extraction-prompts.ts

@@ -149,20 +149,26 @@ Please decide:
 - SKIP: Candidate memory duplicates existing memories, no need to save. Also SKIP if the candidate contains LESS information than an existing memory on the same topic (information degradation — e.g., candidate says "programming language preference" but existing memory already says "programming language preference: Python, TypeScript")
 - CREATE: This is completely new information not covered by any existing memory, should be created
 - MERGE: Candidate memory adds genuinely NEW details to an existing memory and should be merged
+- SUPPORT: Candidate reinforces/confirms an existing memory in a specific context (e.g. "still prefers tea in the evening")
+- CONTEXTUALIZE: Candidate adds a situational nuance to an existing memory (e.g. existing: "likes coffee", candidate: "prefers tea at night" — different context, same topic)
+- CONTRADICT: Candidate directly contradicts an existing memory in a specific context (e.g. existing: "runs on weekends", candidate: "stopped running on weekends")
 
 IMPORTANT:
-- "events" and "cases" categories are independent records — they do NOT support MERGE. For these categories, only use SKIP or CREATE.
+- "events" and "cases" categories are independent records — they do NOT support MERGE/SUPPORT/CONTEXTUALIZE/CONTRADICT. For these categories, only use SKIP or CREATE.
 - If the candidate appears to be derived from a recall question (e.g., "Do you remember X?" / "你记得X吗？") and an existing memory already covers topic X with equal or more detail, you MUST choose SKIP.
 - A candidate with less information than an existing memory on the same topic should NEVER be CREATED or MERGED — always SKIP.
+- For SUPPORT/CONTEXTUALIZE/CONTRADICT, you MUST provide a context_label from this vocabulary: general, morning, evening, night, weekday, weekend, work, leisure, summer, winter, travel.
 
 Return JSON format:
 {
-  "decision": "skip|create|merge",
+  "decision": "skip|create|merge|support|contextualize|contradict",
   "match_index": 1,
-  "reason": "Decision reason"
+  "reason": "Decision reason",
+  "context_label": "evening"
 }
 
-If decision is "merge", set "match_index" to the number of the existing memory to merge with (1-based).`;
+- If decision is "merge"/"support"/"contextualize"/"contradict", set "match_index" to the number of the existing memory (1-based).
+- Only include "context_label" for support/contextualize/contradict decisions.`;
 }
 
 export function buildMergePrompt(
@@ -176,32 +182,32 @@ export function buildMergePrompt(
 ): string {
   return `Merge the following memory into a single coherent record with all three levels.
 
-**Category**: ${category}
+** Category **: ${category}
 
-**Existing Memory:**
-Abstract: ${existingAbstract}
-Overview:
+** Existing Memory:**
+    Abstract: ${existingAbstract}
+  Overview:
 ${existingOverview}
-Content:
+  Content:
 ${existingContent}
 
-**New Information:**
-Abstract: ${newAbstract}
-Overview:
+** New Information:**
+    Abstract: ${newAbstract}
+  Overview:
 ${newOverview}
-Content:
+  Content:
 ${newContent}
 
-Requirements:
-- Remove duplicate information
-- Keep the most up-to-date details
-- Maintain a coherent narrative
-- Keep code identifiers / URIs / model names unchanged when they are proper nouns
+  Requirements:
+  - Remove duplicate information
+    - Keep the most up - to - date details
+      - Maintain a coherent narrative
+        - Keep code identifiers / URIs / model names unchanged when they are proper nouns
 
 Return JSON:
-{
-  "abstract": "Merged one-line abstract",
-  "overview": "Merged structured Markdown overview",
-  "content": "Merged full content"
-}`;
+  {
+    "abstract": "Merged one-line abstract",
+      "overview": "Merged structured Markdown overview",
+        "content": "Merged full content"
+  } `;
 }

src/memory-categories.ts

@@ -44,18 +44,20 @@ export type CandidateMemory = {
 };
 
 /** Dedup decision from LLM. */
-export type DedupDecision = "create" | "merge" | "skip";
+export type DedupDecision = "create" | "merge" | "skip" | "support" | "contextualize" | "contradict";
 
 export type DedupResult = {
   decision: DedupDecision;
   reason: string;
   matchId?: string; // ID of existing memory to merge with
+  contextLabel?: string; // Optional context label for support/contextualize/contradict
 };
 
 export type ExtractionStats = {
   created: number;
   merged: number;
   skipped: number;
+  supported?: number; // context-aware support count
 };
 
 /** Validate and normalize a category string. */

src/smart-extractor.ts

@@ -27,7 +27,7 @@ import {
 } from "./memory-categories.js";
 import { isNoise } from "./noise-filter.js";
 import type { NoisePrototypeBank } from "./noise-prototypes.js";
-import { buildSmartMetadata, parseSmartMetadata, stringifySmartMetadata } from "./smart-metadata.js";
+import { buildSmartMetadata, parseSmartMetadata, stringifySmartMetadata, parseSupportInfo, updateSupportStats } from "./smart-metadata.js";
 
 // ============================================================================
 // Constants
@@ -36,7 +36,7 @@ import { buildSmartMetadata, parseSmartMetadata, stringifySmartMetadata } from "
 const SIMILARITY_THRESHOLD = 0.7;
 const MAX_SIMILAR_FOR_PROMPT = 3;
 const MAX_MEMORIES_PER_EXTRACTION = 5;
-const VALID_DECISIONS = new Set<string>(["create", "merge", "skip"]);
+const VALID_DECISIONS = new Set<string>(["create", "merge", "skip", "support", "contextualize", "contradict"]);
 
 // ============================================================================
 // Smart Extractor
@@ -356,6 +356,36 @@ export class SmartExtractor {
         );
         stats.skipped++;
         break;
+
+      case "support":
+        if (dedupResult.matchId) {
+          await this.handleSupport(dedupResult.matchId, scopeFilter, { session: sessionKey, timestamp: Date.now() }, dedupResult.reason, dedupResult.contextLabel);
+          stats.supported = (stats.supported ?? 0) + 1;
+        } else {
+          await this.storeCandidate(candidate, vector, sessionKey, targetScope);
+          stats.created++;
+        }
+        break;
+
+      case "contextualize":
+        if (dedupResult.matchId) {
+          await this.handleContextualize(candidate, vector, dedupResult.matchId, sessionKey, targetScope, scopeFilter, dedupResult.contextLabel);
+          stats.created++;
+        } else {
+          await this.storeCandidate(candidate, vector, sessionKey, targetScope);
+          stats.created++;
+        }
+        break;
+
+      case "contradict":
+        if (dedupResult.matchId) {
+          await this.handleContradict(candidate, vector, dedupResult.matchId, sessionKey, targetScope, scopeFilter, dedupResult.contextLabel);
+          stats.created++;
+        } else {
+          await this.storeCandidate(candidate, vector, sessionKey, targetScope);
+          stats.created++;
+        }
+        break;
     }
   }
 
@@ -445,7 +475,8 @@ export class SmartExtractor {
       return {
         decision,
         reason: data.reason ?? "",
-        matchId: decision === "merge" ? matchEntry?.entry.id : undefined,
+        matchId: ["merge", "support", "contextualize", "contradict"].includes(decision) ? matchEntry?.entry.id : undefined,
+        contextLabel: typeof (data as any).context_label === "string" ? (data as any).context_label : undefined,
       };
     } catch (err) {
       this.log(
@@ -593,6 +624,138 @@ export class SmartExtractor {
     );
   }
 
+  // --------------------------------------------------------------------------
+  // Context-Aware Handlers (support / contextualize / contradict)
+  // --------------------------------------------------------------------------
+
+  /**
+   * Handle SUPPORT: update support stats on existing memory for a specific context.
+   */
+  private async handleSupport(
+    matchId: string,
+    scopeFilter: string[],
+    source: { session: string; timestamp: number },
+    reason: string,
+    contextLabel?: string,
+  ): Promise<void> {
+    const existing = await this.store.getById(matchId, scopeFilter);
+    if (!existing) return;
+
+    const meta = parseSmartMetadata(existing.metadata, existing);
+    const supportInfo = parseSupportInfo(meta.support_info);
+    const updated = updateSupportStats(supportInfo, contextLabel, "support");
+    meta.support_info = updated;
+
+    await this.store.update(
+      matchId,
+      { metadata: stringifySmartMetadata(meta) },
+      scopeFilter,
+    );
+
+    this.log(
+      `memory-pro: smart-extractor: support [${contextLabel || "general"}] on ${matchId.slice(0, 8)} — ${reason}`,
+    );
+  }
+
+  /**
+   * Handle CONTEXTUALIZE: create a new entry that adds situational nuance,
+   * linked to the original via a relation in metadata.
+   */
+  private async handleContextualize(
+    candidate: CandidateMemory,
+    vector: number[],
+    matchId: string,
+    sessionKey: string,
+    targetScope: string,
+    scopeFilter: string[],
+    contextLabel?: string,
+  ): Promise<void> {
+    const storeCategory = this.mapToStoreCategory(candidate.category);
+    const metadata = stringifySmartMetadata({
+      l0_abstract: candidate.abstract,
+      l1_overview: candidate.overview,
+      l2_content: candidate.content,
+      memory_category: candidate.category,
+      tier: "working" as const,
+      access_count: 0,
+      confidence: 0.7,
+      last_accessed_at: Date.now(),
+      source_session: sessionKey,
+      contexts: contextLabel ? [contextLabel] : [],
+      relations: [{ type: "contextualizes", targetId: matchId }],
+    });
+
+    await this.store.store({
+      text: candidate.abstract,
+      vector,
+      category: storeCategory,
+      scope: targetScope,
+      importance: this.getDefaultImportance(candidate.category),
+      metadata,
+    });
+
+    this.log(
+      `memory-pro: smart-extractor: contextualize [${contextLabel || "general"}] new entry linked to ${matchId.slice(0, 8)}`,
+    );
+  }
+
+  /**
+   * Handle CONTRADICT: create contradicting entry + record contradiction evidence
+   * on the original memory's support stats.
+   */
+  private async handleContradict(
+    candidate: CandidateMemory,
+    vector: number[],
+    matchId: string,
+    sessionKey: string,
+    targetScope: string,
+    scopeFilter: string[],
+    contextLabel?: string,
+  ): Promise<void> {
+    // 1. Record contradiction on the existing memory
+    const existing = await this.store.getById(matchId, scopeFilter);
+    if (existing) {
+      const meta = parseSmartMetadata(existing.metadata, existing);
+      const supportInfo = parseSupportInfo(meta.support_info);
+      const updated = updateSupportStats(supportInfo, contextLabel, "contradict");
+      meta.support_info = updated;
+      await this.store.update(
+        matchId,
+        { metadata: stringifySmartMetadata(meta) },
+        scopeFilter,
+      );
+    }
+
+    // 2. Store the contradicting entry as a new memory
+    const storeCategory = this.mapToStoreCategory(candidate.category);
+    const metadata = stringifySmartMetadata({
+      l0_abstract: candidate.abstract,
+      l1_overview: candidate.overview,
+      l2_content: candidate.content,
+      memory_category: candidate.category,
+      tier: "working" as const,
+      access_count: 0,
+      confidence: 0.7,
+      last_accessed_at: Date.now(),
+      source_session: sessionKey,
+      contexts: contextLabel ? [contextLabel] : [],
+      relations: [{ type: "contradicts", targetId: matchId }],
+    });
+
+    await this.store.store({
+      text: candidate.abstract,
+      vector,
+      category: storeCategory,
+      scope: targetScope,
+      importance: this.getDefaultImportance(candidate.category),
+      metadata,
+    });
+
+    this.log(
+      `memory-pro: smart-extractor: contradict [${contextLabel || "general"}] on ${matchId.slice(0, 8)}, new entry created`,
+    );
+  }
+
   // --------------------------------------------------------------------------
   // Store Helper
   // --------------------------------------------------------------------------