@pencil-agent/nano-mem 0.0.1 → 1.0.2

package/src/engine.ts

@@ -12,10 +12,11 @@ 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 type { PromptSet } from "./i18n.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 { extractTags, pickTop, scoreEntry, scoreEpisode, scoreWorkEntry, tagOverlap, tierEntries } from "./scoring.js";
 import {
 	loadEntries,
 	loadEpisodes,
@@ -115,6 +116,7 @@ export class NanoMemEngine {
 			id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
 			goal: sessionGoal || extracted.goal,
 			summary: filterPII(extracted.summary),
+			detail: extracted.detail ? filterPII(extracted.detail) : undefined,
 			project,
 			tags: extractTags(`${extracted.goal} ${extracted.summary}`),
 			importance: 6,
@@ -173,7 +175,7 @@ export class NanoMemEngine {
 		return newEntries;
 	}
 
-	// ─── Retrieval & Injection ───────────────────────────────────
+	// ─── Retrieval & Injection (Progressive Recall) ────────────
 
 	async getMemoryInjection(project: string, contextTags: string[], scope?: MemoryScope): Promise<string> {
 		const [allKnowledge, allLessons, allPrefs, allFacets, allEpisodes, allWork] = await Promise.all([
@@ -192,79 +194,159 @@ export class NanoMemEngine {
 		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 pr = this.cfg.progressiveRecall;
 		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),
-		);
-
+		// Tier all MemoryEntry categories
+		const tieredKnowledge = tierEntries(knowledge, project, contextTags, hl, sw, pr);
+		const tieredLessons = tierEntries(lessons, project, contextTags, hl, sw, pr);
+		const tieredPrefs = tierEntries(prefs, project, contextTags, hl, sw, pr);
+		const tieredFacets = tierEntries(facets, project, contextTags, hl, sw, pr);
+
+		// Budget calculation
+		const totalChars = this.cfg.tokenBudget * 4;
+		const activeChars = Math.floor(totalChars * pr.budgetActive);
+		const cueChars = Math.floor(totalChars * pr.budgetCue);
+
+		// Entry length helpers
+		const activeLen = (e: MemoryEntry) =>
+			(e.name?.length || 0) + (e.summary?.length || 0) + (e.detail?.length || 0) + 30;
+		const cueLen = (e: MemoryEntry) => (e.name?.length || 0) + (e.summary?.length || 0) + 30;
+		const scoreFn = (e: MemoryEntry) => scoreEntry(e, project, contextTags, hl, sw);
+
+		// Active tier: pick top entries with full detail, split budget across categories
+		const activeBudgetPer = Math.floor(activeChars / 4);
+		const activeKnowledge = pickTop(tieredKnowledge.active, scoreFn, activeLen, activeBudgetPer);
+		const activeLessons = pickTop(tieredLessons.active, scoreFn, activeLen, activeBudgetPer);
+		const activePrefs = pickTop(tieredPrefs.active, scoreFn, activeLen, activeBudgetPer);
+		const activeFacets = pickTop(tieredFacets.active, scoreFn, activeLen, activeBudgetPer);
+
+		// Cue tier: pick top entries with name + summary + id, split budget across categories
+		const cueBudgetPer = Math.floor(cueChars / 6); // 6 = knowledge + lessons + prefs + facets + episodes + work
+		const cueKnowledge = pickTop(tieredKnowledge.cue, scoreFn, cueLen, cueBudgetPer);
+		const cueLessons = pickTop(tieredLessons.cue, scoreFn, cueLen, cueBudgetPer);
+		const cuePrefs = pickTop(tieredPrefs.cue, scoreFn, cueLen, cueBudgetPer);
+		const cueFacets = pickTop(tieredFacets.cue, scoreFn, cueLen, cueBudgetPer);
+
+		// Episodes and Work use their existing scoring for cue layer
 		const topEpisodes = pickTop(
 			episodes,
 			(ep) => scoreEpisode(ep, project, contextTags, hl, sw),
-			(ep) => ep.summary.length,
-			charBudget(b.episodes),
+			(ep) => ep.summary.length + 30,
+			cueBudgetPer,
 		);
-
 		const topWork = pickTop(
 			work,
 			(w) => scoreWorkEntry(w, project, contextTags, hl, sw),
-			(w) => w.goal.length + w.summary.length,
-			charBudget(b.work),
+			(w) => w.goal.length + w.summary.length + 30,
+			cueBudgetPer,
 		);
 
-		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);
+		// Reinforce all recalled entries (Active + Cue) via spaced repetition
+		const allRecalledKnowledge = [...activeKnowledge, ...cueKnowledge];
+		const allRecalledLessons = [...activeLessons, ...cueLessons];
+		const allRecalledPrefs = [...activePrefs, ...cuePrefs];
+		const allRecalledFacets = [...activeFacets, ...cueFacets];
+
+		await this.reinforceEntries(allRecalledKnowledge, allKnowledge, this.knowledgePath);
+		await this.reinforceEntries(allRecalledLessons, allLessons, this.lessonsPath);
+		await this.reinforceEntries(allRecalledPrefs, allPrefs, this.preferencesPath);
+		await this.reinforceEntries(allRecalledFacets, allFacets, this.facetsPath);
 		await this.reinforceWork(topWork, allWork);
 
+		// Optional reconsolidation for low-relevance recalled entries
 		if (this.llmFn) {
-			await this.reconsolidateIfNeeded(topKnowledge, contextTags, allKnowledge);
-			await this.reconsolidateIfNeeded(topLessons, contextTags, allLessons);
+			await this.reconsolidateIfNeeded(allRecalledKnowledge, contextTags, allKnowledge);
+			await this.reconsolidateIfNeeded(allRecalledLessons, contextTags, allLessons);
 		}
 
-		return this.buildInjectionText(
-			topLessons,
-			topKnowledge,
-			topEpisodes,
-			topPrefs,
-			topWork,
-			topFacets,
+		return this.buildProgressiveInjectionText(
+			{
+				knowledge: activeKnowledge,
+				lessons: activeLessons,
+				preferences: activePrefs,
+				facets: activeFacets,
+			},
+			{
+				knowledge: cueKnowledge,
+				lessons: cueLessons,
+				preferences: cuePrefs,
+				facets: cueFacets,
+				episodes: topEpisodes,
+				work: topWork,
+			},
 			allKnowledge,
 			p,
 		);
 	}
 
+	// ─── Progressive Recall Tools ───────────────────────────────
+
+	/** Retrieve a single entry by ID (for recall_memory tool) */
+	async getEntryById(id: string): Promise<MemoryEntry | null> {
+		const paths = [this.knowledgePath, this.lessonsPath, this.preferencesPath, this.facetsPath];
+		for (const path of paths) {
+			const entries = await loadEntries(path);
+			const entry = entries.find((e) => e.id === id);
+			if (entry) return entry;
+		}
+		return null;
+	}
+
+	/** Reinforce a single entry by ID (bump accessCount, lastAccessed, strength) */
+	async reinforceEntryById(id: string): Promise<boolean> {
+		const pathConfigs = [
+			{ path: this.knowledgePath, max: this.cfg.maxEntries.knowledge },
+			{ path: this.lessonsPath, max: this.cfg.maxEntries.lessons },
+			{ path: this.preferencesPath, max: this.cfg.maxEntries.preferences },
+			{ path: this.facetsPath, max: this.cfg.maxEntries.facets },
+		];
+		const hl = this.cfg.halfLife;
+		const ew = this.cfg.evictionWeights;
+
+		for (const { path, max } of pathConfigs) {
+			const entries = await loadEntries(path);
+			const entry = entries.find((e) => e.id === id);
+			if (entry) {
+				entry.accessCount = (entry.accessCount ?? 0) + 1;
+				entry.lastAccessed = new Date().toISOString();
+				entry.strength = (entry.strength || 30) * this.cfg.strengthGrowthFactor;
+				await saveEntries(path, entries, max, (e) => utilityEntry(e, hl, ew));
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/** Full-text search across ALL entries including dormant (for search_all_memories tool) */
+	async searchAllEntries(query: string, limit = 10): Promise<MemoryEntry[]> {
+		const tags = extractTags(query);
+		const queryLower = query.toLowerCase();
+
+		const [knowledge, lessons, prefs, facets] = await Promise.all([
+			loadEntries(this.knowledgePath),
+			loadEntries(this.lessonsPath),
+			loadEntries(this.preferencesPath),
+			loadEntries(this.facetsPath),
+		]);
+
+		const all = [...knowledge, ...lessons, ...prefs, ...facets];
+
+		return all
+			.map((e) => {
+				const nameMatch = (e.name || "").toLowerCase().includes(queryLower) ? 2 : 0;
+				const summaryMatch = (e.summary || "").toLowerCase().includes(queryLower) ? 1 : 0;
+				const tagMatch = tagOverlap(e.tags, tags);
+				return { entry: e, score: nameMatch + summaryMatch + tagMatch };
+			})
+			.filter((x) => x.score > 0)
+			.sort((a, b) => b.score - a.score)
+			.slice(0, limit)
+			.map((x) => x.entry);
+	}
+
 	// ─── Stats ───────────────────────────────────────────────────
 
 	async getStats(): Promise<{
@@ -404,8 +486,8 @@ export class NanoMemEngine {
 			.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,
+				trigger: e.facetData?.kind === "pattern" ? e.facetData.trigger : (e.summary || e.detail || "").slice(0, 50),
+				behavior: e.facetData?.kind === "pattern" ? e.facetData.behavior : (e.summary || e.detail || ""),
 			}))
 			.sort((a, b) => b.weight - a.weight);
 
@@ -416,7 +498,7 @@ export class NanoMemEngine {
 				return {
 					entry: e,
 					weight: calcWeight(e, !isResolved),
-					problem: e.facetData?.kind === "struggle" ? e.facetData.problem : e.content,
+					problem: e.facetData?.kind === "struggle" ? e.facetData.problem : (e.summary || e.detail || ""),
 					attempts: e.facetData?.kind === "struggle" ? e.facetData.attempts : [],
 					solution: e.facetData?.kind === "struggle" ? e.facetData.solution : "",
 					resolved: isResolved,
@@ -462,7 +544,7 @@ export class NanoMemEngine {
 				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),
+					lessons: lessons.slice(0, 5).map((l) => l.summary || l.detail || l.content || ""),
 				});
 				const raw = await this.llmFn(p.insightsRecommendationSystem, input);
 				const cleaned = raw
@@ -609,13 +691,17 @@ export class NanoMemEngine {
 			const overlap = tagOverlap(entry.tags, contextTags);
 			if (overlap >= 0.3) continue;
 			try {
+				const memText = entry.detail || entry.summary || entry.content || "";
 				const updated = await this.llmFn(
 					p.reconsolidationSystem,
-					`Original memory: ${entry.content}\n\nCurrent context tags: ${contextTags.join(", ")}`,
+					`Original memory: ${memText}\n\nCurrent context tags: ${contextTags.join(", ")}`,
 				);
 				if (updated && updated.length > 10) {
-					entry.content = updated.trim();
-					entry.tags = extractTags(entry.content);
+					const trimmed = updated.trim();
+					entry.detail = trimmed;
+					entry.content = trimmed;
+					entry.summary = trimmed.length <= 150 ? trimmed : `${trimmed.slice(0, 147)}...`;
+					entry.tags = extractTags(trimmed);
 				}
 			} catch {
 				/* graceful degradation */
@@ -623,74 +709,88 @@ export class NanoMemEngine {
 		}
 	}
 
-	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;
+	private buildProgressiveInjectionText(
+		active: {
+			knowledge: MemoryEntry[];
+			lessons: MemoryEntry[];
+			preferences: MemoryEntry[];
+			facets: MemoryEntry[];
+		},
+		cue: {
+			knowledge: MemoryEntry[];
+			lessons: MemoryEntry[];
+			preferences: MemoryEntry[];
+			facets: MemoryEntry[];
+			episodes: Episode[];
+			work: WorkEntry[];
 		},
+		allKnowledge: MemoryEntry[],
+		p: PromptSet,
 	): 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")}`);
+		// ── Active tier: full detail ──
+		const activeLines: string[] = [];
+
+		const formatActiveEntry = (e: MemoryEntry): string => {
+			const related = getRelatedSummaries(e, allKnowledge, 2);
+			const suffix = related.length ? ` [→ ${related.join("; ")}]` : "";
+			return `- [ID: ${e.id}] **${e.name || "—"}**: ${e.summary || ""}\n  ${e.detail || ""}${suffix}`;
+		};
+
+		const formatActiveFacet = (e: MemoryEntry): string => {
+			if (e.facetData?.kind === "pattern") {
+				return `- [ID: ${e.id}] **${e.name || "—"}**: When ${e.facetData.trigger} → ${e.facetData.behavior}\n  ${e.detail || ""}`;
+			}
+			if (e.facetData?.kind === "struggle") {
+				return `- [ID: ${e.id}] **${e.name || "—"}**: ${e.facetData.problem}\n  Tried: ${e.facetData.attempts.join(", ")} | Solved: ${e.facetData.solution}\n  ${e.detail || ""}`;
+			}
+			return formatActiveEntry(e);
+		};
+
+		for (const e of active.lessons) activeLines.push(formatActiveEntry(e));
+		for (const e of active.knowledge) activeLines.push(formatActiveEntry(e));
+		for (const e of active.preferences) activeLines.push(formatActiveEntry(e));
+		for (const e of active.facets) activeLines.push(formatActiveFacet(e));
+
+		if (activeLines.length) {
+			sections.push(`### ${p.sectionActiveMemories}\n${activeLines.join("\n")}`);
 		}
-		if (episodes.length) {
-			const lines = episodes.map(
-				(ep) => `- [${ep.date}] ${ep.project}: ${ep.summary}${ep.userGoal ? ` (Goal: ${ep.userGoal})` : ""}`,
+
+		// ── Cue tier: name + summary + id ──
+		const cueLines: string[] = [];
+
+		const formatCueEntry = (e: MemoryEntry): string =>
+			`- [ID: ${e.id}] [${e.type}] **${e.name || "—"}**: ${e.summary || ""}`;
+
+		const formatCueFacet = (e: MemoryEntry): string => {
+			if (e.facetData?.kind === "pattern") {
+				return `- [ID: ${e.id}] [pattern] **${e.name || "—"}**: When ${e.facetData.trigger} → ${e.facetData.behavior}`;
+			}
+			if (e.facetData?.kind === "struggle") {
+				return `- [ID: ${e.id}] [struggle] **${e.name || "—"}**: ${e.facetData.problem}`;
+			}
+			return formatCueEntry(e);
+		};
+
+		for (const e of cue.lessons) cueLines.push(formatCueEntry(e));
+		for (const e of cue.knowledge) cueLines.push(formatCueEntry(e));
+		for (const e of cue.preferences) cueLines.push(formatCueEntry(e));
+		for (const e of cue.facets) cueLines.push(formatCueFacet(e));
+
+		// Episodes in cue layer (no ID-based recall)
+		for (const ep of cue.episodes) {
+			cueLines.push(
+				`- [${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")}`);
+		// Work in cue layer
+		for (const w of cue.work) {
+			cueLines.push(`- [${w.created.slice(0, 10)}] ${w.goal}: ${w.summary}`);
 		}
 
-		// 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 (cueLines.length) {
+			sections.push(`### ${p.sectionMemoryCues}\n*${p.memoryCueHint}*\n${cueLines.join("\n")}`);
 		}
 
 		if (!sections.length) return "";

package/src/extension.ts

@@ -9,6 +9,7 @@
 
 import { writeFileSync } from "node:fs";
 import { basename } from "node:path";
+import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI, ExtensionContext } from "@pencil-agent/nano-pencil";
 import { NanoMemEngine } from "./engine.js";
 import { renderFullInsightsHtml } from "./full-insights-html.js";
@@ -251,7 +252,7 @@ export default function nanomemExtension(pi: ExtensionAPI) {
 				ctx.ui.notify("NanoMem: no matching memories found", "info");
 				return;
 			}
-			for (const e of results.slice(0, 10)) ctx.ui.notify(`[${e.type}] ${e.content.slice(0, 80)}`, "info");
+			for (const e of results.slice(0, 10)) ctx.ui.notify(`[${e.type}] ${(e.summary || e.detail || e.content || "").slice(0, 80)}`, "info");
 		},
 	});
 
@@ -287,4 +288,79 @@ export default function nanomemExtension(pi: ExtensionAPI) {
 			ctx.ui.notify(`NanoMem: Insights report written to ${outputPath}`, "info");
 		},
 	});
+
+	// ─── Progressive Recall Agent Tools ─────────────────────────
+
+	pi.registerTool({
+		name: "recall_memory",
+		label: "Recall Memory",
+		description:
+			"Retrieve full details of a specific memory entry by its ID. " +
+			"Use this when you see a memory cue (name + summary) in context and need the complete information. " +
+			"The ID looks like k_101, l_42, p_7, etc.",
+		parameters: Type.Object({
+			id: Type.String({ description: "The memory entry ID shown in [ID: xxx] cues" }),
+		}),
+		async execute(_toolCallId, params) {
+			const entry = await engine.getEntryById(params.id);
+			if (!entry) {
+				return {
+					content: [{ type: "text" as const, text: `No memory found with ID: ${params.id}` }],
+					details: undefined,
+				};
+			}
+
+			// Reinforce the entry (spaced repetition: bump accessCount, lastAccessed, strength)
+			await engine.reinforceEntryById(params.id);
+
+			const name = entry.name || "Untitled";
+			const summary = entry.summary || "";
+			const detail = entry.detail || entry.content || "";
+			const lines = [`[${entry.type}] ${name}`];
+			if (summary) lines.push("", summary);
+			if (detail && detail !== summary) lines.push("", detail);
+			if (entry.tags?.length) lines.push("", `Tags: ${entry.tags.join(", ")}`);
+
+			return {
+				content: [{ type: "text" as const, text: lines.join("\n") }],
+				details: undefined,
+			};
+		},
+	});
+
+	pi.registerTool({
+		name: "search_all_memories",
+		label: "Search All Memories",
+		description:
+			"Search across ALL stored memories including dormant ones not shown in the current context. " +
+			"Use this to find relevant past knowledge, lessons, preferences, or decisions " +
+			"when the memory cues in context don't cover what you need.",
+		parameters: Type.Object({
+			query: Type.String({ description: "Search keywords or phrase" }),
+			limit: Type.Optional(Type.Number({ description: "Max results (default 10)", default: 10 })),
+		}),
+		async execute(_toolCallId, params) {
+			const limit = params.limit ?? 10;
+			const results = await engine.searchAllEntries(params.query, limit);
+			if (!results.length) {
+				return {
+					content: [{ type: "text" as const, text: `No memories found matching: ${params.query}` }],
+					details: undefined,
+				};
+			}
+
+			const lines = [`Found ${results.length} memories for "${params.query}":\n`];
+			for (const e of results) {
+				const name = e.name || "Untitled";
+				const summary = e.summary || e.content?.slice(0, 100) || "";
+				lines.push(`- [ID: ${e.id}] [${e.type}] **${name}**: ${summary}`);
+			}
+			lines.push("", "Use `recall_memory` with an ID to get full details.");
+
+			return {
+				content: [{ type: "text" as const, text: lines.join("\n") }],
+				details: undefined,
+			};
+		},
+	});
 }

package/src/extraction.ts

@@ -6,6 +6,7 @@
 
 import type { NanomemConfig } from "./config.js";
 import { PROMPTS } from "./i18n.js";
+import { deriveNameFromContent, deriveSummaryFromContent } from "./store.js";
 import type { ExtractedItem, ExtractedWork, LlmFn } from "./types.js";
 
 export async function extractMemories(
@@ -25,7 +26,17 @@ async function extractWithLLM(conversation: string, cfg: NanomemConfig, llmFn: L
 			.replace(/```json?\n?/g, "")
 			.replace(/```/g, "")
 			.trim();
-		return JSON.parse(cleaned) as ExtractedItem[];
+		const items = JSON.parse(cleaned) as ExtractedItem[];
+		// Normalize: ensure name/summary/detail are populated (backward compat with old LLM responses)
+		return items.map((item) => {
+			const detail = item.detail || item.content || "";
+			return {
+				...item,
+				name: item.name || deriveNameFromContent(detail),
+				summary: item.summary || deriveSummaryFromContent(detail),
+				detail,
+			};
+		});
 	} catch {
 		return extractHeuristic(conversation);
 	}
@@ -40,7 +51,12 @@ function extractHeuristic(text: string): ExtractedItem[] {
 		// Skip very short or already seen content
 		if (trimmed.length < 8 || seen.has(trimmed.toLowerCase())) return;
 		seen.add(trimmed.toLowerCase());
-		items.push({ type, content: trimmed });
+		items.push({
+			type,
+			name: deriveNameFromContent(trimmed),
+			summary: deriveSummaryFromContent(trimmed),
+			detail: trimmed,
+		});
 	};
 
 	// Lesson patterns: errors, fixes, bugs, warnings, failures
@@ -148,5 +164,6 @@ function extractWorkHeuristic(text: string): ExtractedWork | null {
 	return {
 		goal: lines[0]?.slice(0, 100) ?? "unknown task",
 		summary: `Session with ${lines.length} exchanges`,
+		detail: lines.slice(0, 20).join("\n"),
 	};
 }

package/src/full-insights.ts

@@ -132,8 +132,8 @@ function buildPatternsAndStruggles(facets: MemoryEntry[]): { patterns: PatternIn
 		.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,
+			trigger: e.facetData?.kind === "pattern" ? e.facetData.trigger : (e.summary || e.detail || e.content || "").slice(0, 50),
+			behavior: e.facetData?.kind === "pattern" ? e.facetData.behavior : (e.summary || e.detail || e.content || ""),
 		}))
 		.sort((a, b) => b.weight - a.weight);
 	const struggles: StruggleInsight[] = struggleEntries
@@ -142,7 +142,7 @@ function buildPatternsAndStruggles(facets: MemoryEntry[]): { patterns: PatternIn
 			return {
 				entry: e,
 				weight: calcWeight(e, !isResolved),
-				problem: e.facetData?.kind === "struggle" ? e.facetData.problem : e.content,
+				problem: e.facetData?.kind === "struggle" ? e.facetData.problem : (e.summary || e.detail || e.content || ""),
 				attempts: e.facetData?.kind === "struggle" ? e.facetData.attempts : [],
 				solution: e.facetData?.kind === "struggle" ? e.facetData.solution : "",
 				resolved: isResolved,
@@ -202,7 +202,8 @@ function fallbackWins(struggles: StruggleInsight[], lessons: MemoryEntry[]): Ful
 	}
 	const sortLessons = [...lessons].sort((a, b) => b.importance * (b.accessCount + 1) - a.importance * (a.accessCount + 1));
 	for (const l of sortLessons.slice(0, 3)) {
-		wins.push({ title: l.content.slice(0, 60), description: l.content });
+		const text = l.summary || l.detail || l.content || "";
+		wins.push({ title: text.slice(0, 60), description: text });
 	}
 	return wins.slice(0, 8);
 }
@@ -349,7 +350,7 @@ export async function buildFullInsightsReport(
 		const context = {
 			patterns: patterns.slice(0, 5).map((x) => ({ trigger: x.trigger, behavior: x.behavior })),
 			struggles: struggles.slice(0, 8).map((s) => ({ problem: s.problem, resolved: s.resolved, attempts: s.attempts, solution: s.solution })),
-			lessons: topLessons.slice(0, 5).map((l) => l.content),
+			lessons: topLessons.slice(0, 5).map((l) => l.summary || l.detail || l.content || ""),
 			projectAreas: projectAreas.map((a) => ({ name: a.name, sessionCount: a.sessionCount, firstSummary: a.description })),
 			topTools: toolsChart.rows.slice(0, 5),
 			errorsSummary: errChart.rows.slice(0, 5).map((r) => r.label),