@elizaos/agent 2.0.0-alpha.441 → 2.0.0-alpha.501

package/packages/typescript/src/features/advanced-capabilities/experience/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/experience/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAGvE,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACtD,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/experience/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAGvE,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACtD,cAAc,YAAY,CAAC"}

package/packages/typescript/src/features/advanced-capabilities/experience/index.js

@@ -2,6 +2,7 @@
  * Experience learning bundled with advanced capabilities.
  */
 export { recordExperienceAction } from "./actions/record-experience.js";
+export { searchExperiencesAction } from "./actions/search-experiences.js";
 export { experienceEvaluator } from "./evaluators/experienceEvaluator.js";
 export { experienceProvider } from "./providers/experienceProvider.js";
 export * from "./types.js";

package/packages/typescript/src/features/advanced-capabilities/experience/providers/experienceProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"experienceProvider.d.ts","sourceRoot":"","sources":["../../../../../../../../../typescript/src/features/advanced-capabilities/experience/providers/experienceProvider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAkB,MAAM,iCAAiC,CAAC;AAahF,eAAO,MAAM,kBAAkB,EAAE,QA6DhC,CAAC"}
+{"version":3,"file":"experienceProvider.d.ts","sourceRoot":"","sources":["../../../../../../../../../typescript/src/features/advanced-capabilities/experience/providers/experienceProvider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAkB,MAAM,iCAAiC,CAAC;AAchF,eAAO,MAAM,kBAAkB,EAAE,QAwEhC,CAAC"}

package/packages/typescript/src/features/advanced-capabilities/experience/providers/experienceProvider.js

@@ -1,5 +1,6 @@
 import { logger } from "../../../../logger.js";
 import { requireProviderSpec } from "../generated/specs/spec-helpers";
+import { formatExperienceForPrompt } from "../utils/experienceFormatter.js";
 /**
  * Simple experience provider that injects relevant experiences into context
  * Similar to the knowledge provider but focused on agent learnings
@@ -19,22 +20,31 @@ export const experienceProvider = {
         if (messageText.length < 10) {
             return { text: "", data: {}, values: {} };
         }
-        // Find relevant experiences using semantic search
-        const relevantExperiences = await experienceService.queryExperiences({
+        const semanticExperiences = await experienceService.queryExperiences({
             query: messageText,
             limit: 5,
             minConfidence: 0.6,
             minImportance: 0.5,
+            includeRelated: true,
         });
+        const topExperiences = await experienceService.listExperiences({
+            limit: 3,
+            minConfidence: 0.7,
+            minImportance: 0.7,
+        });
+        const relevantExperiences = [
+            ...new Map([...semanticExperiences, ...topExperiences].map((experience) => [
+                experience.id,
+                experience,
+            ])).values(),
+        ].slice(0, 7);
         if (relevantExperiences.length === 0) {
             return { text: "", data: {}, values: {} };
         }
         // Format experiences for context injection
         const experienceText = relevantExperiences
-            .map((exp, index) => {
-            return `Experience ${index + 1}: In ${exp.domain} context, when ${exp.context}, I learned: ${exp.learning}`;
-        })
-            .join("\n");
+            .map((experience, index) => formatExperienceForPrompt(experience, index))
+            .join("\n\n");
         const contextText = `[RELEVANT EXPERIENCES]\n${experienceText}\n[/RELEVANT EXPERIENCES]`;
         logger.debug(`[experienceProvider] Injecting ${relevantExperiences.length} relevant experiences`);
         return {

package/packages/typescript/src/features/advanced-capabilities/experience/service.d.ts

@@ -1,7 +1,7 @@
 import type { UUID } from "../../../types/primitives.ts";
 import type { IAgentRuntime } from "../../../types/runtime.ts";
 import { Service, type ServiceTypeName } from "../../../types/service.ts";
-import { type Experience, type ExperienceAnalysis, type ExperienceQuery, ExperienceType } from "./types.ts";
+import { type Experience, type ExperienceAnalysis, type ExperienceConsolidationResult, type ExperienceGraphSnapshot, type ExperienceQuery, ExperienceType } from "./types.ts";
 export declare class ExperienceService extends Service {
     static serviceType: ServiceTypeName;
     capabilityDescription: string;
@@ -10,6 +10,7 @@ export declare class ExperienceService extends Service {
     private experiencesByType;
     private dirtyExperiences;
     private persistTimer;
+    private maintenanceTimer;
     private decayManager;
     private relationshipManager;
     constructor(runtime: IAgentRuntime);
@@ -18,6 +19,10 @@ export declare class ExperienceService extends Service {
     private toOptionalTimestamp;
     private asStringArray;
     private asOptionalUuidArray;
+    private asUuidArray;
+    private dedupeStrings;
+    private normalizeTags;
+    private deriveKeywords;
     private asOptionalEmbedding;
     private clampScore;
     private isExperienceType;
@@ -57,6 +62,21 @@ export declare class ExperienceService extends Service {
     findSimilarExperiences(text: string, limit?: number): Promise<Experience[]>;
     /** Fallback when embeddings are unavailable: sort by decayed confidence * importance. */
     private fallbackSort;
+    getExperienceGraph(query?: ExperienceQuery): Promise<ExperienceGraphSnapshot>;
+    consolidateDuplicateExperiences(options?: {
+        deleteDuplicates?: boolean;
+        limit?: number;
+    }): Promise<ExperienceConsolidationResult>;
+    private buildGraphSnapshot;
+    private buildGraphNode;
+    private buildGraphLinks;
+    private inferGraphLink;
+    private toGraphLinkType;
+    private getSharedKeywords;
+    private getTimeWeight;
+    private selectPrimaryExperience;
+    private areAlreadyConsolidated;
+    private mergeDuplicateExperience;
     analyzeExperiences(domain?: string, type?: ExperienceType): Promise<ExperienceAnalysis>;
     private cosineSimilarity;
     private findCommonPatterns;

package/packages/typescript/src/features/advanced-capabilities/experience/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/experience/service.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAa,IAAI,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,EACN,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,eAAe,EAEpB,cAAc,EAEd,MAAM,YAAY,CAAC;AAIpB,qBAAa,iBAAkB,SAAQ,OAAO;IAC7C,OAAgB,WAAW,EAAE,eAAe,CACS;IAC5C,qBAAqB,SACiE;IAE/F,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,mBAAmB,CAAqC;IAChE,OAAO,CAAC,iBAAiB,CAA6C;IACtE,OAAO,CAAC,gBAAgB,CAAwB;IAChD,OAAO,CAAC,YAAY,CAA+C;IACnE,OAAO,CAAC,YAAY,CAAyB;IAC7C,OAAO,CAAC,mBAAmB,CAAgC;gBAE/C,OAAO,EAAE,aAAa;WAarB,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAMtE,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,mBAAmB;IAK3B,OAAO,CAAC,mBAAmB;IAY3B,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,qBAAqB;YAqHf,iBAAiB;IAiC/B,OAAO,CAAC,qBAAqB;IAuE7B,OAAO,CAAC,gBAAgB;YASV,eAAe;IAmBvB,gBAAgB,CACrB,cAAc,EAAE,OAAO,CAAC,UAAU,CAAC,GACjC,OAAO,CAAC,UAAU,CAAC;YA4ER,sBAAsB;YAOtB,uBAAuB;IAyB/B,aAAa,CAAC,EAAE,EAAE,IAAI,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAKnD,eAAe,CAAC,KAAK,GAAE,eAAoB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAInE,gBAAgB,CACrB,EAAE,EAAE,IAAI,EACR,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,GAC1B,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAsEvB,gBAAgB,CAAC,EAAE,EAAE,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC;IAc5C,gBAAgB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;YAIvD,kBAAkB;IAgEhC,4FAA4F;IAC5F,OAAO,CAAC,YAAY;IAiDpB;;;;;;;;;;;OAWG;IACG,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAoF5E,yFAAyF;IACzF,OAAO,CAAC,YAAY;IAUd,kBAAkB,CACvB,MAAM,CAAC,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,cAAc,GACnB,OAAO,CAAC,kBAAkB,CAAC;IA4C9B,OAAO,CAAC,gBAAgB;IAmBxB,OAAO,CAAC,kBAAkB;IAoB1B,OAAO,CAAC,2BAA2B;IAYnC,OAAO,CAAC,mBAAmB;IAsB3B,OAAO,CAAC,uBAAuB;IAyDzB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CA2B3B"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/experience/service.ts"],"names":[],"mappings":"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"}

package/packages/typescript/src/features/advanced-capabilities/experience/service.js

@@ -5,6 +5,10 @@ import { Service } from "../../../types/service.js";
 import { ExperienceServiceType, ExperienceType, OutcomeType, } from "./types.js";
 import { ConfidenceDecayManager } from "./utils/confidenceDecay";
 import { ExperienceRelationshipManager } from "./utils/experienceRelationships";
+import { extractExperienceKeywords, isDuplicateLearning, } from "./utils/experienceText.js";
+const GRAPH_MAX_LINKS = 200;
+const GRAPH_KEYWORD_LINK_THRESHOLD = 2;
+const DAILY_EXPERIENCE_MAINTENANCE_MS = 24 * 60 * 60 * 1000;
 export class ExperienceService extends Service {
     static serviceType = ExperienceServiceType.EXPERIENCE;
     capabilityDescription = "Manages agent experiences, learning from successes and failures to improve future decisions";
@@ -13,6 +17,7 @@ export class ExperienceService extends Service {
     experiencesByType = new Map();
     dirtyExperiences = new Set();
     persistTimer = null;
+    maintenanceTimer = null;
     decayManager;
     relationshipManager;
     constructor(runtime) {
@@ -24,6 +29,9 @@ export class ExperienceService extends Service {
         this.persistTimer = setInterval(() => {
             void this.persistDirtyExperiences();
         }, 60_000);
+        this.maintenanceTimer = setInterval(() => {
+            void this.consolidateDuplicateExperiences({ deleteDuplicates: false });
+        }, DAILY_EXPERIENCE_MAINTENANCE_MS);
     }
     static async start(runtime) {
         const service = new ExperienceService(runtime);
@@ -56,6 +64,28 @@ export class ExperienceService extends Service {
         const ids = this.asStringArray(value);
         return ids.length > 0 ? ids : undefined;
     }
+    asUuidArray(value) {
+        return this.asStringArray(value);
+    }
+    dedupeStrings(values) {
+        return Array.from(new Set(values
+            .map((value) => value?.trim())
+            .filter((value) => Boolean(value))));
+    }
+    normalizeTags(tags, domain, type) {
+        const providedTags = this.asStringArray(tags).map((tag) => tag.toLowerCase());
+        return this.dedupeStrings(providedTags.length > 0 ? providedTags : [domain.toLowerCase(), type]);
+    }
+    deriveKeywords(experience) {
+        return extractExperienceKeywords([
+            experience.context,
+            experience.action,
+            experience.result,
+            experience.learning,
+            experience.domain,
+            experience.tags,
+        ]);
+    }
     asOptionalEmbedding(value) {
         if (!Array.isArray(value)) {
             return undefined;
@@ -79,10 +109,19 @@ export class ExperienceService extends Service {
         return {
             ...experience,
             tags: [...experience.tags],
+            keywords: [...experience.keywords],
+            associatedEntityIds: [...experience.associatedEntityIds],
             embedding: experience.embedding ? [...experience.embedding] : undefined,
+            memoryIds: experience.memoryIds ? [...experience.memoryIds] : undefined,
+            sourceMessageIds: experience.sourceMessageIds
+                ? [...experience.sourceMessageIds]
+                : undefined,
             relatedExperiences: experience.relatedExperiences
                 ? [...experience.relatedExperiences]
                 : undefined,
+            mergedExperienceIds: experience.mergedExperienceIds
+                ? [...experience.mergedExperienceIds]
+                : undefined,
         };
     }
     indexExperience(experience) {
@@ -159,6 +198,8 @@ export class ExperienceService extends Service {
                 ? rawData.domain
                 : "general",
             tags: this.asStringArray(rawData?.tags),
+            keywords: this.asStringArray(rawData?.keywords),
+            associatedEntityIds: this.asUuidArray(rawData?.associatedEntityIds),
             confidence: this.clampScore(rawData?.confidence, 0.5),
             importance: this.clampScore(rawData?.importance, 0.5),
             createdAt: this.toTimestamp(rawData?.createdAt, memoryCreatedAt),
@@ -171,6 +212,7 @@ export class ExperienceService extends Service {
             embedding: this.asOptionalEmbedding(memory.embedding) ??
                 this.asOptionalEmbedding(rawData?.embedding),
             relatedExperiences: this.asOptionalUuidArray(rawData?.relatedExperiences),
+            mergedExperienceIds: this.asOptionalUuidArray(rawData?.mergedExperienceIds),
             supersedes: typeof rawData?.supersedes === "string"
                 ? rawData.supersedes
                 : undefined,
@@ -232,6 +274,8 @@ export class ExperienceService extends Service {
             learning: experience.learning,
             domain: experience.domain,
             tags: experience.tags,
+            keywords: experience.keywords,
+            associatedEntityIds: experience.associatedEntityIds,
             confidence: experience.confidence,
             importance: experience.importance,
             createdAt: experience.createdAt,
@@ -244,6 +288,9 @@ export class ExperienceService extends Service {
         if (experience.relatedExperiences !== undefined) {
             data.relatedExperiences = experience.relatedExperiences;
         }
+        if (experience.mergedExperienceIds !== undefined) {
+            data.mergedExperienceIds = experience.mergedExperienceIds;
+        }
         if (experience.supersedes !== undefined) {
             data.supersedes = experience.supersedes;
         }
@@ -306,6 +353,12 @@ export class ExperienceService extends Service {
         for (const memory of memories) {
             const experience = this.parseExperienceMemory(memory);
             if (experience) {
+                if (experience.tags.length === 0) {
+                    experience.tags = this.normalizeTags(experience.tags, experience.domain, experience.type);
+                }
+                if (experience.keywords.length === 0) {
+                    experience.keywords = this.deriveKeywords(experience);
+                }
                 this.setExperience(experience);
             }
         }
@@ -317,6 +370,19 @@ export class ExperienceService extends Service {
         const action = experienceData.action || "";
         const result = experienceData.result || "";
         const learning = experienceData.learning || "";
+        const type = experienceData.type || ExperienceType.LEARNING;
+        const domain = experienceData.domain || "general";
+        const tags = this.normalizeTags(experienceData.tags, domain, type);
+        const keywords = experienceData.keywords && experienceData.keywords.length > 0
+            ? this.dedupeStrings(experienceData.keywords)
+            : this.deriveKeywords({
+                context,
+                action,
+                result,
+                learning,
+                domain,
+                tags,
+            });
         const embedding = await this.generateEmbedding({
             context,
             action,
@@ -326,14 +392,18 @@ export class ExperienceService extends Service {
         const experience = {
             id: uuidv4(),
             agentId: this.runtime.agentId,
-            type: experienceData.type || ExperienceType.LEARNING,
+            type,
             outcome: experienceData.outcome || OutcomeType.NEUTRAL,
             context,
             action,
             result,
             learning,
-            domain: experienceData.domain || "general",
-            tags: experienceData.tags ? [...experienceData.tags] : [],
+            domain,
+            tags,
+            keywords,
+            associatedEntityIds: experienceData.associatedEntityIds
+                ? Array.from(new Set(experienceData.associatedEntityIds))
+                : [],
             confidence: experienceData.confidence ?? 0.5,
             importance: experienceData.importance ?? 0.5,
             createdAt: now,
@@ -344,6 +414,9 @@ export class ExperienceService extends Service {
             relatedExperiences: experienceData.relatedExperiences
                 ? [...experienceData.relatedExperiences]
                 : undefined,
+            mergedExperienceIds: experienceData.mergedExperienceIds
+                ? [...experienceData.mergedExperienceIds]
+                : undefined,
             supersedes: experienceData.supersedes,
             previousBelief: experienceData.previousBelief,
             correctedBelief: experienceData.correctedBelief,
@@ -416,10 +489,31 @@ export class ExperienceService extends Service {
         const nextAction = "action" in updates ? (updates.action ?? "") : existing.action;
         const nextResult = "result" in updates ? (updates.result ?? "") : existing.result;
         const nextLearning = "learning" in updates ? (updates.learning ?? "") : existing.learning;
+        const nextType = "type" in updates ? (updates.type ?? existing.type) : existing.type;
+        const nextDomain = "domain" in updates ? (updates.domain ?? "general") : existing.domain;
+        const nextTags = "tags" in updates
+            ? this.normalizeTags(updates.tags, nextDomain, nextType)
+            : [...existing.tags];
         const shouldRegenerateEmbedding = "context" in updates ||
             "action" in updates ||
             "result" in updates ||
             "learning" in updates;
+        const shouldRegenerateKeywords = shouldRegenerateEmbedding ||
+            "domain" in updates ||
+            "tags" in updates ||
+            "type" in updates;
+        const nextKeywords = "keywords" in updates && updates.keywords && updates.keywords.length > 0
+            ? this.dedupeStrings(updates.keywords)
+            : shouldRegenerateKeywords
+                ? this.deriveKeywords({
+                    context: nextContext,
+                    action: nextAction,
+                    result: nextResult,
+                    learning: nextLearning,
+                    domain: nextDomain,
+                    tags: nextTags,
+                })
+                : [...existing.keywords];
         const embedding = shouldRegenerateEmbedding
             ? await this.generateEmbedding({
                 context: nextContext,
@@ -438,11 +532,13 @@ export class ExperienceService extends Service {
             action: nextAction,
             result: nextResult,
             learning: nextLearning,
-            tags: "tags" in updates
-                ? Array.isArray(updates.tags)
-                    ? [...updates.tags]
-                    : []
-                : [...existing.tags],
+            type: nextType,
+            domain: nextDomain,
+            tags: nextTags,
+            keywords: nextKeywords,
+            associatedEntityIds: "associatedEntityIds" in updates
+                ? Array.from(new Set(updates.associatedEntityIds ?? []))
+                : [...existing.associatedEntityIds],
             relatedExperiences: "relatedExperiences" in updates
                 ? updates.relatedExperiences
                     ? [...updates.relatedExperiences]
@@ -457,6 +553,13 @@ export class ExperienceService extends Service {
                 : existing.sourceMessageIds
                     ? [...existing.sourceMessageIds]
                     : undefined,
+            mergedExperienceIds: "mergedExperienceIds" in updates
+                ? updates.mergedExperienceIds
+                    ? [...updates.mergedExperienceIds]
+                    : undefined
+                : existing.mergedExperienceIds
+                    ? [...existing.mergedExperienceIds]
+                    : undefined,
             embedding,
             updatedAt: Date.now(),
         };
@@ -646,6 +749,282 @@ export class ExperienceService extends Service {
         });
         return all.slice(0, limit);
     }
+    async getExperienceGraph(query = {}) {
+        const experiences = await this.resolveExperiences({ ...query, limit: query.limit ?? 100 }, false);
+        return this.buildGraphSnapshot(experiences);
+    }
+    async consolidateDuplicateExperiences(options = {}) {
+        const candidates = Array.from(this.experiences.values())
+            .sort((left, right) => right.updatedAt - left.updatedAt)
+            .slice(0, options.limit ?? this.experiences.size);
+        const consumedIds = new Set();
+        const groups = [];
+        let deleted = 0;
+        for (const experience of candidates) {
+            if (consumedIds.has(experience.id)) {
+                continue;
+            }
+            const duplicates = candidates.filter((candidate) => candidate.id !== experience.id &&
+                !consumedIds.has(candidate.id) &&
+                !this.areAlreadyConsolidated(experience, candidate) &&
+                isDuplicateLearning(experience.learning, candidate.learning));
+            if (duplicates.length === 0) {
+                consumedIds.add(experience.id);
+                continue;
+            }
+            const group = [experience, ...duplicates];
+            const primary = this.selectPrimaryExperience(group);
+            const duplicateIds = [];
+            for (const duplicate of group) {
+                if (duplicate.id === primary.id) {
+                    continue;
+                }
+                await this.mergeDuplicateExperience(primary.id, duplicate.id, options.deleteDuplicates === true);
+                duplicateIds.push(duplicate.id);
+                consumedIds.add(duplicate.id);
+                if (options.deleteDuplicates === true) {
+                    deleted++;
+                }
+            }
+            const updatedPrimary = this.experiences.get(primary.id) ?? primary;
+            groups.push({
+                primaryId: primary.id,
+                duplicateIds,
+                mergedKeywords: updatedPrimary.keywords,
+                reason: "duplicate learning text",
+            });
+            consumedIds.add(primary.id);
+        }
+        return {
+            inspected: candidates.length,
+            groups,
+            merged: groups.reduce((total, group) => total + group.duplicateIds.length, 0),
+            deleted,
+        };
+    }
+    buildGraphSnapshot(experiences) {
+        const sorted = [...experiences].sort((left, right) => {
+            const scoreLeft = this.decayManager.getDecayedConfidence(left) *
+                left.importance *
+                this.getTimeWeight(left);
+            const scoreRight = this.decayManager.getDecayedConfidence(right) *
+                right.importance *
+                this.getTimeWeight(right);
+            return scoreRight - scoreLeft;
+        });
+        return {
+            generatedAt: Date.now(),
+            totalExperiences: this.experiences.size,
+            nodes: sorted.map((experience, index) => this.buildGraphNode(experience, index, sorted.length)),
+            links: this.buildGraphLinks(sorted),
+        };
+    }
+    buildGraphNode(experience, index, total) {
+        const angle = total > 0 ? (Math.PI * 2 * index) / total : 0;
+        const ring = 0.28 + (index % 4) * 0.1;
+        return {
+            id: experience.id,
+            label: experience.learning,
+            type: experience.type,
+            outcome: experience.outcome,
+            domain: experience.domain,
+            keywords: [...experience.keywords],
+            associatedEntityIds: [...experience.associatedEntityIds],
+            confidence: experience.confidence,
+            importance: experience.importance,
+            timeWeight: this.getTimeWeight(experience),
+            x: 0.5 + Math.cos(angle) * ring,
+            y: 0.5 + Math.sin(angle) * ring,
+        };
+    }
+    buildGraphLinks(experiences) {
+        const links = new Map();
+        const addLink = (link) => {
+            const key = `${link.sourceId}:${link.targetId}:${link.type}`;
+            const existing = links.get(key);
+            if (!existing || existing.strength < link.strength) {
+                links.set(key, link);
+            }
+        };
+        for (const experience of experiences) {
+            for (const relationship of this.relationshipManager.findRelationships(experience.id)) {
+                const type = this.toGraphLinkType(relationship.type);
+                if (!type || !this.experiences.has(relationship.toId)) {
+                    continue;
+                }
+                addLink({
+                    sourceId: relationship.fromId,
+                    targetId: relationship.toId,
+                    type,
+                    strength: relationship.strength,
+                    reason: `stored ${relationship.type} relationship`,
+                    keywords: [],
+                });
+            }
+        }
+        for (let i = 0; i < experiences.length; i++) {
+            const source = experiences[i];
+            if (!source) {
+                continue;
+            }
+            for (let j = i + 1; j < experiences.length; j++) {
+                const target = experiences[j];
+                if (!target) {
+                    continue;
+                }
+                const inferred = this.inferGraphLink(source, target);
+                if (inferred) {
+                    addLink(inferred);
+                }
+            }
+        }
+        return Array.from(links.values())
+            .sort((left, right) => right.strength - left.strength)
+            .slice(0, GRAPH_MAX_LINKS);
+    }
+    inferGraphLink(source, target) {
+        const sharedKeywords = this.getSharedKeywords(source, target);
+        if (source.supersedes === target.id || target.supersedes === source.id) {
+            const superseding = source.supersedes === target.id ? source : target;
+            const superseded = superseding.id === source.id ? target : source;
+            return {
+                sourceId: superseding.id,
+                targetId: superseded.id,
+                type: "supersedes",
+                strength: 0.95,
+                reason: "explicit supersession",
+                keywords: sharedKeywords,
+            };
+        }
+        if (isDuplicateLearning(source.learning, target.learning)) {
+            return {
+                sourceId: source.id,
+                targetId: target.id,
+                type: "similar",
+                strength: 0.9,
+                reason: "duplicate or near-duplicate learning",
+                keywords: sharedKeywords,
+            };
+        }
+        if (source.domain === target.domain &&
+            sharedKeywords.length >= GRAPH_KEYWORD_LINK_THRESHOLD) {
+            return {
+                sourceId: source.id,
+                targetId: target.id,
+                type: "supports",
+                strength: Math.min(0.85, 0.4 + sharedKeywords.length * 0.1),
+                reason: "shared domain keywords",
+                keywords: sharedKeywords,
+            };
+        }
+        const sharesEntities = source.associatedEntityIds.some((entityId) => target.associatedEntityIds.includes(entityId));
+        if (sharesEntities && source.domain === target.domain) {
+            return {
+                sourceId: source.id,
+                targetId: target.id,
+                type: "co_occurs",
+                strength: Math.min(0.8, 0.45 + sharedKeywords.length * 0.08),
+                reason: "same associated entity and domain",
+                keywords: sharedKeywords,
+            };
+        }
+        return null;
+    }
+    toGraphLinkType(type) {
+        switch (type) {
+            case "contradicts":
+            case "supports":
+            case "supersedes":
+                return type;
+            case "related":
+                return "similar";
+            default:
+                return null;
+        }
+    }
+    getSharedKeywords(left, right) {
+        const rightKeywords = new Set(right.keywords);
+        return left.keywords.filter((keyword) => rightKeywords.has(keyword));
+    }
+    getTimeWeight(experience) {
+        const ageDays = Math.max(0, (Date.now() - experience.createdAt) / (24 * 60 * 60 * 1000));
+        return 1 / (1 + ageDays / 30);
+    }
+    selectPrimaryExperience(experiences) {
+        return [...experiences].sort((left, right) => {
+            const scoreLeft = left.importance * 0.4 +
+                left.confidence * 0.4 +
+                this.getTimeWeight(left) * 0.1 +
+                Math.min(1, left.accessCount / 10) * 0.1;
+            const scoreRight = right.importance * 0.4 +
+                right.confidence * 0.4 +
+                this.getTimeWeight(right) * 0.1 +
+                Math.min(1, right.accessCount / 10) * 0.1;
+            return scoreRight - scoreLeft;
+        })[0];
+    }
+    areAlreadyConsolidated(left, right) {
+        return (left.supersedes === right.id ||
+            right.supersedes === left.id ||
+            (left.mergedExperienceIds?.includes(right.id) ?? false) ||
+            (right.mergedExperienceIds?.includes(left.id) ?? false));
+    }
+    async mergeDuplicateExperience(primaryId, duplicateId, deleteDuplicate) {
+        const primary = this.experiences.get(primaryId);
+        const duplicate = this.experiences.get(duplicateId);
+        if (!primary || !duplicate) {
+            return;
+        }
+        const merged = {
+            ...primary,
+            confidence: Math.max(primary.confidence, duplicate.confidence),
+            importance: Math.max(primary.importance, duplicate.importance),
+            accessCount: primary.accessCount + duplicate.accessCount,
+            lastAccessedAt: Math.max(primary.lastAccessedAt ?? primary.updatedAt, duplicate.lastAccessedAt ?? duplicate.updatedAt),
+            updatedAt: Date.now(),
+            tags: this.dedupeStrings([...primary.tags, ...duplicate.tags]),
+            keywords: this.dedupeStrings([
+                ...primary.keywords,
+                ...duplicate.keywords,
+            ]),
+            associatedEntityIds: this.asUuidArray([
+                ...primary.associatedEntityIds,
+                ...duplicate.associatedEntityIds,
+            ]),
+            sourceMessageIds: this.asOptionalUuidArray([
+                ...(primary.sourceMessageIds ?? []),
+                ...(duplicate.sourceMessageIds ?? []),
+            ]),
+            relatedExperiences: this.asOptionalUuidArray([
+                ...(primary.relatedExperiences ?? []),
+                ...(duplicate.relatedExperiences ?? []),
+                duplicate.id,
+            ].filter((id) => id !== primary.id)),
+            mergedExperienceIds: this.asOptionalUuidArray([
+                ...(primary.mergedExperienceIds ?? []),
+                duplicate.id,
+                ...(duplicate.mergedExperienceIds ?? []),
+            ]),
+        };
+        this.setExperience(merged);
+        await this.saveExperienceToMemory(merged);
+        if (deleteDuplicate) {
+            await this.deleteExperience(duplicate.id);
+            return;
+        }
+        const superseded = {
+            ...duplicate,
+            confidence: Math.min(duplicate.confidence, 0.4),
+            updatedAt: Date.now(),
+            supersedes: primary.id,
+            relatedExperiences: this.asOptionalUuidArray([
+                ...(duplicate.relatedExperiences ?? []),
+                primary.id,
+            ]),
+        };
+        this.setExperience(superseded);
+        await this.saveExperienceToMemory(superseded);
+    }
     async analyzeExperiences(domain, type) {
         const experiences = await this.queryExperiences({
             domain: domain ? [domain] : undefined,
@@ -793,6 +1172,10 @@ export class ExperienceService extends Service {
             clearInterval(this.persistTimer);
             this.persistTimer = null;
         }
+        if (this.maintenanceTimer) {
+            clearInterval(this.maintenanceTimer);
+            this.maintenanceTimer = null;
+        }
         // Final persist of all dirty experiences + full save
         const experiencesToSave = Array.from(this.experiences.values());
         let savedCount = 0;