@pencil-agent/nano-mem 0.0.1

package/src/engine.ts

@@ -0,0 +1,699 @@
+/**
+ * [INPUT]: NanomemConfig, optional LlmFn
+ * [OUTPUT]: NanoMemEngine — unified API for memory CRUD, injection, consolidation
+ * [POS]: Facade layer — composes store, scoring, eviction, update, linking, privacy, extraction, consolidation
+ *
+ * Host products create an engine instance and call its methods.
+ * No dependency on any specific AI framework — LLM is pluggable.
+ */
+
+import { join } from "node:path";
+import { getConfig, type NanomemConfig } from "./config.js";
+import { consolidateEpisodes } from "./consolidation.js";
+import { utilityEntry, utilityWork } from "./eviction.js";
+import { extractMemories, extractWork } from "./extraction.js";
+import { PROMPTS } from "./i18n.js";
+import { getRelatedSummaries, linkNewEntry } from "./linking.js";
+import { evictExpiredEntries, evictExpiredWork, filterByScope, filterPII } from "./privacy.js";
+import { extractTags, pickTop, scoreEntry, scoreEpisode, scoreWorkEntry, tagOverlap } from "./scoring.js";
+import {
+	loadEntries,
+	loadEpisodes,
+	loadMeta,
+	loadWork,
+	saveEpisode as persistEpisode,
+	saveEntries,
+	saveWork,
+	writeJson,
+} from "./store.js";
+import { buildFullInsightsReport } from "./full-insights.js";
+import type {
+	Episode,
+	ExtractedItem,
+	FullInsightsReport,
+	InsightsReport,
+	LlmFn,
+	MemoryEntry,
+	MemoryScope,
+	Meta,
+	PatternInsight,
+	StruggleInsight,
+	WorkEntry,
+} from "./types.js";
+import { applyExtraction } from "./update.js";
+
+export class NanoMemEngine {
+	readonly cfg: NanomemConfig;
+	private llmFn?: LlmFn;
+
+	private knowledgePath: string;
+	private lessonsPath: string;
+	private preferencesPath: string;
+	private facetsPath: string;
+	private workPath: string;
+	private metaPath: string;
+	private episodesDir: string;
+
+	constructor(overrides?: Partial<NanomemConfig>, llmFn?: LlmFn) {
+		this.cfg = getConfig(overrides);
+		this.llmFn = llmFn;
+		this.knowledgePath = join(this.cfg.memoryDir, "knowledge.json");
+		this.lessonsPath = join(this.cfg.memoryDir, "lessons.json");
+		this.preferencesPath = join(this.cfg.memoryDir, "preferences.json");
+		this.facetsPath = join(this.cfg.memoryDir, "facets.json");
+		this.workPath = join(this.cfg.memoryDir, "work.json");
+		this.metaPath = join(this.cfg.memoryDir, "meta.json");
+		this.episodesDir = join(this.cfg.memoryDir, "episodes");
+	}
+
+	setLlmFn(fn: LlmFn): void {
+		this.llmFn = fn;
+	}
+
+	// ─── Extraction ──────────────────────────────────────────────
+
+	async extractAndStore(conversation: string, project: string): Promise<ExtractedItem[]> {
+		const items = await extractMemories(conversation, this.cfg, this.llmFn);
+		if (!items.length) return [];
+
+		const knowledge = await loadEntries(this.knowledgePath);
+		const lessons = await loadEntries(this.lessonsPath);
+		const prefs = await loadEntries(this.preferencesPath);
+		const facets = await loadEntries(this.facetsPath);
+
+		for (const item of items) {
+			const target =
+				item.type === "lesson"
+					? lessons
+					: item.type === "preference"
+						? prefs
+						: item.type === "pattern" || item.type === "struggle"
+							? facets
+							: knowledge;
+			applyExtraction(target, item, project, this.cfg);
+		}
+
+		const hl = this.cfg.halfLife;
+		const ew = this.cfg.evictionWeights;
+		await Promise.all([
+			saveEntries(this.knowledgePath, knowledge, this.cfg.maxEntries.knowledge, (e) => utilityEntry(e, hl, ew)),
+			saveEntries(this.lessonsPath, lessons, this.cfg.maxEntries.lessons, (e) => utilityEntry(e, hl, ew)),
+			saveEntries(this.preferencesPath, prefs, this.cfg.maxEntries.preferences, (e) => utilityEntry(e, hl, ew)),
+			saveEntries(this.facetsPath, facets, this.cfg.maxEntries.facets, (e) => utilityEntry(e, hl, ew)),
+		]);
+
+		return items;
+	}
+
+	async extractAndStoreWork(conversation: string, project: string, sessionGoal?: string): Promise<void> {
+		const extracted = await extractWork(conversation, this.cfg, this.llmFn);
+		if (!extracted || (!extracted.goal && !extracted.summary)) return;
+
+		const entries = await loadWork(this.workPath);
+		const now = new Date().toISOString();
+		const newWork: WorkEntry = {
+			id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+			goal: sessionGoal || extracted.goal,
+			summary: filterPII(extracted.summary),
+			project,
+			tags: extractTags(`${extracted.goal} ${extracted.summary}`),
+			importance: 6,
+			strength: this.cfg.halfLife.work ?? 45,
+			created: now,
+			eventTime: now,
+			accessCount: 0,
+			relatedIds: [],
+			scope: this.cfg.defaultScope,
+		};
+
+		entries.push(newWork);
+		await saveWork(this.workPath, entries, this.cfg.maxEntries.work, (w) =>
+			utilityWork(w, this.cfg.halfLife, this.cfg.evictionWeights),
+		);
+	}
+
+	// ─── Episode Management ──────────────────────────────────────
+
+	async saveEpisode(ep: Episode): Promise<void> {
+		await persistEpisode(this.episodesDir, ep);
+		const meta = await loadMeta(this.metaPath);
+		meta.totalSessions++;
+		await writeJson(this.metaPath, meta);
+	}
+
+	async consolidate(): Promise<MemoryEntry[]> {
+		const episodes = await loadEpisodes(this.episodesDir);
+		const newEntries = await consolidateEpisodes(episodes, this.cfg, this.llmFn);
+		if (!newEntries.length) return [];
+
+		const knowledge = await loadEntries(this.knowledgePath);
+		const lessons = await loadEntries(this.lessonsPath);
+
+		for (const entry of newEntries) {
+			linkNewEntry(entry, [...knowledge, ...lessons]);
+			if (entry.type === "lesson") lessons.push(entry);
+			else knowledge.push(entry);
+		}
+
+		const hl = this.cfg.halfLife;
+		const ew = this.cfg.evictionWeights;
+		await Promise.all([
+			saveEntries(this.knowledgePath, knowledge, this.cfg.maxEntries.knowledge, (e) => utilityEntry(e, hl, ew)),
+			saveEntries(this.lessonsPath, lessons, this.cfg.maxEntries.lessons, (e) => utilityEntry(e, hl, ew)),
+		]);
+
+		for (const ep of episodes) {
+			if (ep.consolidated) await persistEpisode(this.episodesDir, ep);
+		}
+
+		const meta = await loadMeta(this.metaPath);
+		meta.lastConsolidation = new Date().toISOString();
+		await writeJson(this.metaPath, meta);
+
+		return newEntries;
+	}
+
+	// ─── Retrieval & Injection ───────────────────────────────────
+
+	async getMemoryInjection(project: string, contextTags: string[], scope?: MemoryScope): Promise<string> {
+		const [allKnowledge, allLessons, allPrefs, allFacets, allEpisodes, allWork] = await Promise.all([
+			loadEntries(this.knowledgePath),
+			loadEntries(this.lessonsPath),
+			loadEntries(this.preferencesPath),
+			loadEntries(this.facetsPath),
+			loadEpisodes(this.episodesDir),
+			loadWork(this.workPath),
+		]);
+
+		const knowledge = this.filterAndCleanEntries(allKnowledge, scope);
+		const lessons = this.filterAndCleanEntries(allLessons, scope);
+		const prefs = this.filterAndCleanEntries(allPrefs, scope);
+		const facets = this.filterAndCleanEntries(allFacets, scope);
+		const work = this.filterAndCleanWork(allWork, scope);
+		const episodes = filterByScope(allEpisodes, scope);
+
+		const totalBudget = this.cfg.tokenBudget;
+		const b = this.cfg.budget;
+		const hl = this.cfg.halfLife;
+		const sw = this.cfg.scoreWeights;
+		const p = PROMPTS[this.cfg.locale] ?? PROMPTS.en;
+
+		const charBudget = (ratio: number) => Math.floor(totalBudget * 4 * ratio);
+
+		const topLessons = pickTop(
+			lessons,
+			(e) => scoreEntry(e, project, contextTags, hl, sw),
+			(e) => e.content.length,
+			charBudget(b.lessons),
+		);
+
+		const topKnowledge = pickTop(
+			knowledge,
+			(e) => scoreEntry(e, project, contextTags, hl, sw),
+			(e) => e.content.length,
+			charBudget(b.knowledge),
+		);
+
+		const topPrefs = pickTop(
+			prefs,
+			(e) => scoreEntry(e, project, contextTags, hl, sw),
+			(e) => e.content.length,
+			charBudget(b.preferences),
+		);
+
+		const topFacets = pickTop(
+			facets,
+			(e) => scoreEntry(e, project, contextTags, hl, sw),
+			(e) => e.content.length,
+			charBudget(b.facets),
+		);
+
+		const topEpisodes = pickTop(
+			episodes,
+			(ep) => scoreEpisode(ep, project, contextTags, hl, sw),
+			(ep) => ep.summary.length,
+			charBudget(b.episodes),
+		);
+
+		const topWork = pickTop(
+			work,
+			(w) => scoreWorkEntry(w, project, contextTags, hl, sw),
+			(w) => w.goal.length + w.summary.length,
+			charBudget(b.work),
+		);
+
+		await this.reinforceEntries(topLessons, allLessons, this.lessonsPath);
+		await this.reinforceEntries(topKnowledge, allKnowledge, this.knowledgePath);
+		await this.reinforceEntries(topPrefs, allPrefs, this.preferencesPath);
+		await this.reinforceEntries(topFacets, allFacets, this.facetsPath);
+		await this.reinforceWork(topWork, allWork);
+
+		if (this.llmFn) {
+			await this.reconsolidateIfNeeded(topKnowledge, contextTags, allKnowledge);
+			await this.reconsolidateIfNeeded(topLessons, contextTags, allLessons);
+		}
+
+		return this.buildInjectionText(
+			topLessons,
+			topKnowledge,
+			topEpisodes,
+			topPrefs,
+			topWork,
+			topFacets,
+			allKnowledge,
+			p,
+		);
+	}
+
+	// ─── Stats ───────────────────────────────────────────────────
+
+	async getStats(): Promise<{
+		knowledge: number;
+		lessons: number;
+		preferences: number;
+		facets: number;
+		episodes: number;
+		work: number;
+		totalSessions: number;
+	}> {
+		const [knowledge, lessons, prefs, facets, episodes, work, meta] = await Promise.all([
+			loadEntries(this.knowledgePath),
+			loadEntries(this.lessonsPath),
+			loadEntries(this.preferencesPath),
+			loadEntries(this.facetsPath),
+			loadEpisodes(this.episodesDir),
+			loadWork(this.workPath),
+			loadMeta(this.metaPath),
+		]);
+		return {
+			knowledge: knowledge.length,
+			lessons: lessons.length,
+			preferences: prefs.length,
+			facets: facets.length,
+			episodes: episodes.length,
+			work: work.length,
+			totalSessions: meta.totalSessions,
+		};
+	}
+
+	// ─── Direct Access (for CLI, testing) ────────────────────────
+
+	async getAllEntries(): Promise<{
+		knowledge: MemoryEntry[];
+		lessons: MemoryEntry[];
+		preferences: MemoryEntry[];
+		facets: MemoryEntry[];
+	}> {
+		return {
+			knowledge: await loadEntries(this.knowledgePath),
+			lessons: await loadEntries(this.lessonsPath),
+			preferences: await loadEntries(this.preferencesPath),
+			facets: await loadEntries(this.facetsPath),
+		};
+	}
+
+	async getAllWork(): Promise<WorkEntry[]> {
+		return loadWork(this.workPath);
+	}
+
+	async getAllEpisodes(): Promise<Episode[]> {
+		return loadEpisodes(this.episodesDir);
+	}
+
+	async searchEntries(query: string, scope?: MemoryScope): Promise<MemoryEntry[]> {
+		const tags = extractTags(query);
+		const { knowledge, lessons, preferences, facets } = await this.getAllEntries();
+		const all = [...knowledge, ...lessons, ...preferences, ...facets];
+		return filterByScope(all, scope)
+			.map((e) => ({ entry: e, score: tagOverlap(e.tags, tags) }))
+			.filter((x) => x.score > 0)
+			.sort((a, b) => b.score - a.score)
+			.map((x) => x.entry);
+	}
+
+	async forgetEntry(id: string): Promise<boolean> {
+		const paths = [this.knowledgePath, this.lessonsPath, this.preferencesPath, this.facetsPath];
+		for (const path of paths) {
+			const entries = await loadEntries(path);
+			const idx = entries.findIndex((e) => e.id === id);
+			if (idx >= 0) {
+				entries.splice(idx, 1);
+				const hl = this.cfg.halfLife;
+				const ew = this.cfg.evictionWeights;
+				await saveEntries(path, entries, Infinity, (e) => utilityEntry(e, hl, ew));
+				return true;
+			}
+		}
+		return false;
+	}
+
+	async exportAll(): Promise<{
+		knowledge: MemoryEntry[];
+		lessons: MemoryEntry[];
+		preferences: MemoryEntry[];
+		facets: MemoryEntry[];
+		work: WorkEntry[];
+		episodes: Episode[];
+		meta: Meta;
+	}> {
+		const [knowledge, lessons, preferences, facets, work, episodes, meta] = await Promise.all([
+			loadEntries(this.knowledgePath),
+			loadEntries(this.lessonsPath),
+			loadEntries(this.preferencesPath),
+			loadEntries(this.facetsPath),
+			loadWork(this.workPath),
+			loadEpisodes(this.episodesDir),
+			loadMeta(this.metaPath),
+		]);
+		return { knowledge, lessons, preferences, facets, work, episodes, meta };
+	}
+
+	// ─── Full Insights Report ────────────────────────────────────────
+
+	async generateFullInsights(): Promise<FullInsightsReport> {
+		const all = await this.exportAll();
+		return buildFullInsightsReport(all, this.llmFn, this.cfg.locale);
+	}
+
+	// ─── Insights Generation ─────────────────────────────────────
+
+	async generateInsights(): Promise<InsightsReport> {
+		const all = await this.exportAll();
+		const stats = {
+			knowledge: all.knowledge.length,
+			lessons: all.lessons.length,
+			preferences: all.preferences.length,
+			facets: all.facets.length,
+			episodes: all.episodes.length,
+			work: all.work.length,
+			totalSessions: all.meta.totalSessions,
+		};
+
+		// Separate patterns and struggles from facets
+		const patternEntries = all.facets.filter((e) => e.type === "pattern");
+		const struggleEntries = all.facets.filter((e) => e.type === "struggle");
+
+		// Weight calculation: (accessCount + 1) × (importance / 10)
+		const calcWeight = (e: MemoryEntry, unresolvedBonus = false): number => {
+			const base = (e.accessCount + 1) * (e.importance / 10);
+			return unresolvedBonus ? base * 1.5 : base;
+		};
+
+		// Build PatternInsight[]
+		const patterns: PatternInsight[] = patternEntries
+			.map((e) => ({
+				entry: e,
+				weight: calcWeight(e),
+				trigger: e.facetData?.kind === "pattern" ? e.facetData.trigger : e.content.slice(0, 50),
+				behavior: e.facetData?.kind === "pattern" ? e.facetData.behavior : e.content,
+			}))
+			.sort((a, b) => b.weight - a.weight);
+
+		// Build StruggleInsight[]
+		const struggles: StruggleInsight[] = struggleEntries
+			.map((e) => {
+				const isResolved = e.facetData?.kind === "struggle" ? !!e.facetData.solution : false;
+				return {
+					entry: e,
+					weight: calcWeight(e, !isResolved),
+					problem: e.facetData?.kind === "struggle" ? e.facetData.problem : e.content,
+					attempts: e.facetData?.kind === "struggle" ? e.facetData.attempts : [],
+					solution: e.facetData?.kind === "struggle" ? e.facetData.solution : "",
+					resolved: isResolved,
+				};
+			})
+			.sort((a, b) => {
+				// Unresolved first, then by weight
+				if (a.resolved !== b.resolved) return a.resolved ? 1 : -1;
+				return b.weight - a.weight;
+			});
+
+		// Top lessons and knowledge by importance × accessCount
+		const sortByRelevance = (arr: MemoryEntry[]) =>
+			[...arr].sort((a, b) => b.importance * (b.accessCount + 1) - a.importance * (a.accessCount + 1));
+
+		const topLessons = sortByRelevance(all.lessons).slice(0, 10);
+		const topKnowledge = sortByRelevance(all.knowledge).slice(0, 10);
+
+		// Generate recommendations (LLM or rules-based fallback)
+		const recommendations = await this.generateRecommendations(patterns, struggles, topLessons);
+
+		return {
+			patterns,
+			struggles,
+			topLessons,
+			topKnowledge,
+			preferences: all.preferences,
+			stats,
+			recommendations,
+			generatedAt: new Date().toISOString(),
+		};
+	}
+
+	private async generateRecommendations(
+		patterns: PatternInsight[],
+		struggles: StruggleInsight[],
+		lessons: MemoryEntry[],
+	): Promise<string[]> {
+		// Try LLM-based recommendations if available
+		if (this.llmFn) {
+			try {
+				const p = PROMPTS[this.cfg.locale] ?? PROMPTS.en;
+				const input = JSON.stringify({
+					patterns: patterns.slice(0, 5).map((pa) => ({ trigger: pa.trigger, behavior: pa.behavior })),
+					struggles: struggles.slice(0, 5).map((s) => ({ problem: s.problem, resolved: s.resolved })),
+					lessons: lessons.slice(0, 5).map((l) => l.content),
+				});
+				const raw = await this.llmFn(p.insightsRecommendationSystem, input);
+				const cleaned = raw
+					.replace(/```json?\n?/g, "")
+					.replace(/```/g, "")
+					.trim();
+				const result = JSON.parse(cleaned) as string[];
+				if (Array.isArray(result) && result.length > 0) {
+					return result.slice(0, 5);
+				}
+			} catch {
+				// Fall through to rules-based
+			}
+		}
+
+		// Rules-based fallback recommendations
+		return this.generateRulesBasedRecommendations(patterns, struggles, lessons);
+	}
+
+	private generateRulesBasedRecommendations(
+		patterns: PatternInsight[],
+		struggles: StruggleInsight[],
+		lessons: MemoryEntry[],
+	): string[] {
+		const recommendations: string[] = [];
+		const isZh = this.cfg.locale === "zh";
+
+		// High-weight patterns → automation suggestion
+		if (patterns.length > 0) {
+			const top = patterns[0]!;
+			recommendations.push(
+				isZh
+					? `你在「${top.trigger}」时稳定执行「${top.behavior}」，考虑将此行为自动化`
+					: `You consistently ${top.behavior} when ${top.trigger}. Consider automating this behavior.`,
+			);
+		}
+
+		// Unresolved struggles → systematic review suggestion
+		const unresolved = struggles.filter((s) => !s.resolved);
+		if (unresolved.length >= 2) {
+			recommendations.push(
+				isZh
+					? `有 ${unresolved.length} 个未解决的问题，建议系统性地逐个攻克`
+					: `You have ${unresolved.length} unresolved issues. Consider tackling them systematically.`,
+			);
+		}
+
+		// Recurring tag patterns in struggles → domain-specific review
+		const struggleTags = struggles.flatMap((s) => s.entry.tags);
+		const tagCounts = struggleTags.reduce(
+			(acc, tag) => {
+				acc[tag] = (acc[tag] || 0) + 1;
+				return acc;
+			},
+			{} as Record<string, number>,
+		);
+		const topTag = Object.entries(tagCounts).sort((a, b) => b[1] - a[1])[0];
+		if (topTag && topTag[1] >= 3) {
+			recommendations.push(
+				isZh
+					? `「${topTag[0]}」相关的问题反复出现，建议深入学习该领域`
+					: `Issues related to "${topTag[0]}" appear frequently. Consider deeper learning in this area.`,
+			);
+		}
+
+		// Lessons accumulation → expertise recognition
+		if (lessons.length >= 5) {
+			recommendations.push(
+				isZh
+					? `你已积累 ${lessons.length} 条经验教训，这是宝贵的知识财富`
+					: `You've accumulated ${lessons.length} lessons. This is valuable expertise.`,
+			);
+		}
+
+		// No data → encouragement
+		if (patterns.length === 0 && struggles.length === 0 && lessons.length === 0) {
+			recommendations.push(
+				isZh ? `继续使用系统，让它学习你的工作习惯` : `Keep using the system to let it learn your work habits.`,
+			);
+		}
+
+		return recommendations.slice(0, 5);
+	}
+
+	// ─── Private Helpers ─────────────────────────────────────────
+
+	private filterAndCleanEntries(entries: MemoryEntry[], scope?: MemoryScope): MemoryEntry[] {
+		return filterByScope(evictExpiredEntries(entries), scope);
+	}
+
+	private filterAndCleanWork(entries: WorkEntry[], scope?: MemoryScope): WorkEntry[] {
+		return filterByScope(evictExpiredWork(entries), scope);
+	}
+
+	private async reinforceEntries(recalled: MemoryEntry[], all: MemoryEntry[], savePath: string): Promise<void> {
+		const ids = new Set(recalled.map((e) => e.id));
+		const now = new Date().toISOString();
+		for (const entry of all) {
+			if (ids.has(entry.id)) {
+				entry.accessCount = (entry.accessCount ?? 0) + 1;
+				entry.lastAccessed = now;
+				entry.strength = (entry.strength || 30) * this.cfg.strengthGrowthFactor;
+			}
+		}
+		const hl = this.cfg.halfLife;
+		const ew = this.cfg.evictionWeights;
+		await saveEntries(
+			savePath,
+			all,
+			savePath === this.lessonsPath
+				? this.cfg.maxEntries.lessons
+				: savePath === this.preferencesPath
+					? this.cfg.maxEntries.preferences
+					: savePath === this.facetsPath
+						? this.cfg.maxEntries.facets
+						: this.cfg.maxEntries.knowledge,
+			(e) => utilityEntry(e, hl, ew),
+		);
+	}
+
+	private async reinforceWork(recalled: WorkEntry[], all: WorkEntry[]): Promise<void> {
+		const ids = new Set(recalled.map((w) => w.id));
+		const now = new Date().toISOString();
+		for (const w of all) {
+			if (ids.has(w.id)) {
+				w.accessCount = (w.accessCount ?? 0) + 1;
+				w.lastAccessed = now;
+				w.strength = (w.strength || 45) * this.cfg.strengthGrowthFactor;
+			}
+		}
+		await saveWork(this.workPath, all, this.cfg.maxEntries.work, (w) =>
+			utilityWork(w, this.cfg.halfLife, this.cfg.evictionWeights),
+		);
+	}
+
+	private async reconsolidateIfNeeded(
+		recalled: MemoryEntry[],
+		contextTags: string[],
+		_allEntries: MemoryEntry[],
+	): Promise<void> {
+		if (!this.llmFn) return;
+		const p = PROMPTS[this.cfg.locale];
+		for (const entry of recalled) {
+			const overlap = tagOverlap(entry.tags, contextTags);
+			if (overlap >= 0.3) continue;
+			try {
+				const updated = await this.llmFn(
+					p.reconsolidationSystem,
+					`Original memory: ${entry.content}\n\nCurrent context tags: ${contextTags.join(", ")}`,
+				);
+				if (updated && updated.length > 10) {
+					entry.content = updated.trim();
+					entry.tags = extractTags(entry.content);
+				}
+			} catch {
+				/* graceful degradation */
+			}
+		}
+	}
+
+	private buildInjectionText(
+		lessons: MemoryEntry[],
+		knowledge: MemoryEntry[],
+		episodes: Episode[],
+		prefs: MemoryEntry[],
+		work: WorkEntry[],
+		facets: MemoryEntry[],
+		allKnowledge: MemoryEntry[],
+		p: {
+			sectionLessons: string;
+			sectionKnowledge: string;
+			sectionEpisodes: string;
+			sectionPreferences: string;
+			sectionWork: string;
+			sectionPatterns: string;
+			sectionStruggles: string;
+			injectionHeader: string;
+			memoryBehavior: string;
+		},
+	): string {
+		const sections: string[] = [];
+
+		if (lessons.length) {
+			sections.push(`### ${p.sectionLessons}\n${lessons.map((e) => `- ${e.content}`).join("\n")}`);
+		}
+		if (knowledge.length) {
+			const lines = knowledge.map((e) => {
+				const related = getRelatedSummaries(e, allKnowledge, 2);
+				const suffix = related.length ? ` [→ ${related.join("; ")}]` : "";
+				return `- ${e.content}${suffix}`;
+			});
+			sections.push(`### ${p.sectionKnowledge}\n${lines.join("\n")}`);
+		}
+		if (episodes.length) {
+			const lines = episodes.map(
+				(ep) => `- [${ep.date}] ${ep.project}: ${ep.summary}${ep.userGoal ? ` (Goal: ${ep.userGoal})` : ""}`,
+			);
+			sections.push(`### ${p.sectionEpisodes}\n${lines.join("\n")}`);
+		}
+		if (prefs.length) {
+			sections.push(`### ${p.sectionPreferences}\n${prefs.map((e) => `- ${e.content}`).join("\n")}`);
+		}
+		if (work.length) {
+			const lines = work.map((w) => `- [${w.created.slice(0, 10)}] ${w.goal}: ${w.summary}`);
+			sections.push(`### ${p.sectionWork}\n${lines.join("\n")}`);
+		}
+
+		// Facets: patterns and struggles
+		const patterns = facets.filter((e) => e.type === "pattern");
+		const struggles = facets.filter((e) => e.type === "struggle");
+
+		if (patterns.length) {
+			const lines = patterns.map((e) => {
+				if (e.facetData?.kind === "pattern") {
+					return `- When ${e.facetData.trigger} → ${e.facetData.behavior}`;
+				}
+				return `- ${e.content}`;
+			});
+			sections.push(`### ${p.sectionPatterns}\n${lines.join("\n")}`);
+		}
+		if (struggles.length) {
+			const lines = struggles.map((e) => {
+				if (e.facetData?.kind === "struggle") {
+					return `- Problem: ${e.facetData.problem} | Tried: ${e.facetData.attempts.join(", ")} | Solved: ${e.facetData.solution}`;
+				}
+				return `- ${e.content}`;
+			});
+			sections.push(`### ${p.sectionStruggles}\n${lines.join("\n")}`);
+		}
+
+		if (!sections.length) return "";
+		return `## ${p.injectionHeader}\n\n${sections.join("\n\n")}\n\n---\n${p.memoryBehavior}`;
+	}
+}