@yandy0725/pi-memory 0.3.1 → 1.0.0

package/src/inject.ts

@@ -1,6 +1,8 @@
-import { readFile } from "node:fs/promises";
+import { readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
+import { getSubagentsService } from "@yandy0725/pi-subagents";
 import { truncateForInjection } from "./index-file";
+import { parseFrontmatter } from "./topic-file";
 
 export async function loadIndexSnapshot(memoryDir: string, maxLines: number, maxBytes: number): Promise<string> {
 	try {
@@ -16,3 +18,233 @@ export function buildInjection(systemPrompt: string, snapshot: string): string {
 	if (!snapshot) return systemPrompt;
 	return `${systemPrompt}\n\n${snapshot}`;
 }
+
+export interface TopicManifest {
+	filename: string;
+	name: string;
+	description: string;
+	type: string;
+	mtimeMs: number;
+}
+
+export async function scanTopics(memoryDir: string): Promise<TopicManifest[]> {
+	const files = (await readdir(memoryDir).catch(() => [])).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
+
+	const manifests: TopicManifest[] = [];
+	for (const f of files.slice(0, 200)) {
+		try {
+			const raw = await readFile(join(memoryDir, f), "utf8");
+			const meta = parseFrontmatter(raw);
+			if (!meta) continue;
+			let mtimeMs = 0;
+			try {
+				const s = await stat(join(memoryDir, f));
+				mtimeMs = s.mtimeMs;
+			} catch {
+				/* ignore */
+			}
+			manifests.push({
+				filename: f,
+				name: meta.name,
+				description: meta.description,
+				type: meta.type,
+				mtimeMs,
+			});
+		} catch {
+			/* skip unreadable files */
+		}
+	}
+	return manifests.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+
+export function buildSurfacingPrompt(
+	manifest: TopicManifest[],
+	userPrompt: string,
+	injectedTopics: Set<string>,
+): string {
+	const lines = manifest.map((t) => {
+		const marker = injectedTopics.has(t.filename) ? " [already injected]" : "";
+		return `[${t.type}] ${t.filename} — ${t.description.slice(0, 80)}${marker}`;
+	});
+	const alreadyInjected =
+		injectedTopics.size > 0
+			? `\n\nNote: ${injectedTopics.size} topic file(s) have already been injected in this session and are marked [already injected]. Prefer selecting uninjected topics.`
+			: "";
+
+	return [
+		"You are a memory relevance selector. Below is a list of memory topic files and a user message.",
+		"Select up to N topic files that are relevant to the user's current query.",
+		"Response format: JSON with a 'selected_files' array of filenames.",
+		alreadyInjected,
+		"",
+		"=== Topic Files ===",
+		...lines,
+		"",
+		"=== User Message ===",
+		userPrompt,
+		"",
+		'Return: {"selected_files": ["a.md", "b.md"]}',
+	].join("\n");
+}
+
+export async function injectSurfacedContent(
+	memoryDir: string,
+	selectedFiles: string[],
+	maxTopicBytes: number,
+	maxInjectionBytes: number,
+): Promise<string> {
+	const blocks: string[] = [];
+	let totalBytes = 0;
+
+	for (const f of selectedFiles) {
+		try {
+			const raw = await readFile(join(memoryDir, f), "utf8");
+			const { content } = truncateForInjection(raw, 999999, maxTopicBytes);
+			const block = `## ${f}\n${content}`;
+			const blockBytes = Buffer.byteLength(block, "utf8");
+			if (totalBytes + blockBytes > maxInjectionBytes) break;
+			blocks.push(block);
+			totalBytes += blockBytes;
+		} catch {
+			/* skip unreadable files */
+		}
+	}
+
+	if (blocks.length === 0) return "";
+	return `<relevant_memories>\n${blocks.join("\n\n")}\n</relevant_memories>`;
+}
+
+/** Run a lightweight LLM side-query to select relevant topic files.
+ *  Uses pi-subagents spawn + Promise pattern (same as dream.ts).
+ *  Falls back to keyword matching if subagent service is unavailable. */
+export async function runSideQuery(
+	prompt: string,
+	manifest: TopicManifest[],
+	maxFiles: number,
+	// biome-ignore lint/suspicious/noExplicitAny: pi events API handler
+	events?: { on(channel: string, handler: (data: any) => void): () => void },
+): Promise<string[]> {
+	// Filter to uninjected candidates only
+	const candidates = manifest.filter((t) => {
+		// already-injected topics are marked in the prompt, but we also
+		// filter here as a safety net
+		return !prompt.includes(`[already injected] ${t.filename}`);
+	});
+	if (candidates.length === 0) return [];
+
+	// Build a minimal selection prompt — only current user message + topic manifest.
+	// With prompt_mode=replace, this IS the entire system prompt (no inheritance).
+	const task = [
+		"Respond with ONLY a JSON object.",
+		"",
+		"Below is a list of memory topic files and a user query.",
+		`Select up to ${maxFiles} topic files MOST relevant to the user's current query.`,
+		'If nothing is relevant, return {"selected_files": []}.',
+		"",
+		prompt,
+		"",
+		'Respond with EXACTLY: {"selected_files": [...]}',
+	].join("\n");
+
+	const service = getSubagentsService();
+	if (!service) {
+		// Fallback: keyword matching when subagent service unavailable
+		return keywordMatch(candidates, prompt, maxFiles);
+	}
+
+	const provider = {
+		// biome-ignore lint/suspicious/noExplicitAny: WorkspaceProvider prepare ctx
+		async prepare(_ctx: any) {
+			return { cwd: process.cwd(), dispose: () => undefined };
+		},
+	};
+	const unregister = service.registerWorkspaceProvider(provider);
+
+	try {
+		// Subscribe to events BEFORE spawn to prevent race: if the subagent
+		// completes between spawn and subscribe, the event is lost and
+		// the Promise never resolves except by timeout.
+		const result = await new Promise<string[]>((resolve) => {
+			const timeout = setTimeout(() => {
+				cleanup();
+				resolve(keywordMatch(candidates, prompt, maxFiles));
+			}, 30_000);
+
+			let settled = false;
+			const cleanup = () => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timeout);
+				unsubCompleted();
+				unsubFailed();
+				unregister();
+			};
+
+			const onCompleted = (data: { id: string }) => {
+				if (data.id !== agentId) return;
+				cleanup();
+				const record = service.getRecord(agentId);
+				const result = record?.result ?? "";
+				try {
+					const jsonMatch = result.match(/\{[^}]*"selected_files"[^}]*\}/s);
+					if (jsonMatch) {
+						const parsed = JSON.parse(jsonMatch[0]);
+						const files: string[] = parsed.selected_files ?? [];
+						const valid = files.filter((f: string) => candidates.some((c) => c.filename === f)).slice(0, maxFiles);
+						resolve(valid);
+					} else {
+						resolve([]);
+					}
+				} catch {
+					resolve([]);
+				}
+			};
+
+			const onFailed = (data: { id: string }) => {
+				if (data.id !== agentId) return;
+				cleanup();
+				resolve(keywordMatch(candidates, prompt, maxFiles));
+			};
+
+			const unsubCompleted = events?.on("subagents:completed", onCompleted) ?? (() => {});
+			const unsubFailed = events?.on("subagents:failed", onFailed) ?? (() => {});
+
+			if (!events) {
+				cleanup();
+				resolve(keywordMatch(candidates, prompt, maxFiles));
+				return;
+			}
+
+			// Spawn AFTER subscriptions are active
+			const agentId = service.spawn("memory-agent", task, {
+				maxTurns: 1,
+				inheritContext: false,
+				thinkingLevel: "off",
+				foreground: true,
+				bypassQueue: true,
+			});
+		});
+
+		return result;
+	} catch {
+		unregister();
+		return keywordMatch(candidates, prompt, maxFiles);
+	}
+}
+
+/** Keyword-matching fallback for topic selection (no LLM required). */
+function keywordMatch(manifest: TopicManifest[], userPrompt: string, maxFiles: number): string[] {
+	const words = userPrompt
+		.toLowerCase()
+		.split(/\W+/)
+		.filter((w) => w.length > 2);
+	const scored = manifest
+		.map((t) => {
+			const desc = `${t.description} ${t.name}`.toLowerCase();
+			const score = words.filter((w) => desc.includes(w)).length;
+			return { filename: t.filename, score };
+		})
+		.filter((t) => t.score > 0)
+		.sort((a, b) => b.score - a.score);
+	return scored.slice(0, maxFiles).map((t) => t.filename);
+}

package/src/memory-tool.ts

@@ -1,18 +1,54 @@
-import { readFile, writeFile, mkdir, readdir, unlink } from "node:fs/promises";
-import { join, dirname } from "node:path";
-import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
+import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { StringEnum } from "@earendil-works/pi-ai";
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
-import { parseIndex, serializeIndex, addEntry, removeEntryByTitle, matchEntryByTitle, checkCapacity, type IndexEntry } from "./index-file";
-import { buildFrontmatter, appendContent, updateFrontmatterDate, removeEntrySection, hasEntries, parseEntries } from "./topic-file";
+import { Type } from "typebox";
+import {
+	checkCapacity,
+	findEntryByTopic,
+	type IndexEntry,
+	parseIndex,
+	removeEntryByTopic,
+	serializeIndex,
+	updateHook,
+	upsertEntryByTopic,
+} from "./index-file";
 import { safeTopicPath } from "./paths";
+import {
+	appendContent,
+	buildFrontmatter,
+	hasEntries,
+	parseEntries,
+	removeEntrySection,
+	updateFrontmatterDate,
+} from "./topic-file";
 
-export interface AddParams { content: string; topic: string; title: string; maxLines: number; maxBytes: number; }
-export interface RemoveParams { entry: string; }
-export interface ReadParams { topic?: string; entry?: string; }
-export interface ReadResult { ok: boolean; error?: string; content?: string; }
-export interface ActionResult { ok: boolean; error?: string; entries?: IndexEntry[]; }
+export interface AddParams {
+	content: string;
+	topic: string;
+	title: string;
+	type?: string;
+	maxLines: number;
+	maxBytes: number;
+}
+export interface RemoveParams {
+	entry: string;
+}
+export interface ReadParams {
+	topic?: string;
+	entry?: string;
+}
+export interface ReadResult {
+	ok: boolean;
+	error?: string;
+	content?: string;
+}
+export interface ActionResult {
+	ok: boolean;
+	error?: string;
+	entries?: IndexEntry[];
+}
 
 const MEMORY_MD = "MEMORY.md";
 
@@ -31,35 +67,61 @@ function today(): string {
 
 export async function doAdd(memoryDir: string, p: AddParams): Promise<ActionResult> {
 	if (!p.title) return { ok: false, error: "title is required" };
+	const memType = p.type ?? "feedback";
+	if (!["user", "feedback", "project", "reference"].includes(memType)) {
+		return { ok: false, error: `Invalid type "${memType}". Must be one of: user, feedback, project, reference` };
+	}
+	// Normalize topic: always .md extension (LLM may pass "debugging" or "debugging.md")
+	const topic = p.topic.endsWith(".md") ? p.topic : `${p.topic}.md`;
 	let topicPath: string;
 	try {
-		topicPath = safeTopicPath(memoryDir, p.topic);
+		topicPath = safeTopicPath(memoryDir, topic);
+		// biome-ignore lint/suspicious/noExplicitAny: error catch
 	} catch (e: any) {
 		return { ok: false, error: e.message };
 	}
 	return withFileMutationQueue(join(memoryDir, MEMORY_MD), async () => {
 		await mkdir(dirname(topicPath), { recursive: true });
 		const entries = await readIndex(memoryDir);
-		const next = addEntry(entries, { title: p.title, topic: p.topic, raw: "" });
-		if (!checkCapacity(next, p.maxLines, p.maxBytes)) {
-			return {
-				ok: false,
-				error: `MEMORY.md capacity exceeded (max ${p.maxLines} lines / ${p.maxBytes} bytes). Current entries: ${serializeIndex(entries)}`,
-			};
-		}
-		// write topic file
-		let existing: string | null = null;
-		try { existing = await readFile(topicPath, "utf8"); } catch { existing = null; }
+		const existing = findEntryByTopic(entries, topic);
+
+		let next: IndexEntry[];
 		if (!existing) {
-			const out = `${buildFrontmatter({ updated: today() })}${appendContent(null, p.title, p.content)}`;
-			await writeFile(topicPath, out, "utf8");
+			// New topic: create index entry with topic name as display name, entry title as hook
+			const name = topic.replace(/\.md$/, "");
+			const entry: IndexEntry = { name, topic, hook: p.title, raw: "" };
+			next = upsertEntryByTopic(entries, entry);
+			if (!checkCapacity(next, p.maxLines, p.maxBytes)) {
+				return {
+					ok: false,
+					error: `MEMORY.md capacity exceeded (max ${p.maxLines} lines / ${p.maxBytes} bytes). Current entries: ${serializeIndex(entries)}`,
+				};
+			}
+			// Create topic file with full frontmatter
+			const fm = buildFrontmatter({ name, description: p.title, type: memType, updated: today() });
+			const topicContent = appendContent(fm, p.title, p.content);
+			await writeFile(topicPath, topicContent, "utf8");
 		} else {
-			const updated = updateFrontmatterDate(existing, today());
-			const out = appendContent(updated, p.title, p.content);
-			await writeFile(topicPath, out, "utf8");
+			// Existing topic: append entry, then regenerate hook from ALL entry titles
+			const raw = await readFile(topicPath, "utf8");
+			const refreshed = updateFrontmatterDate(raw, today());
+			const topicContent = appendContent(refreshed, p.title, p.content);
+			await writeFile(topicPath, topicContent, "utf8");
+
+			// Build hook from all entries (comma-separated titles, trimmed to ~150 chars)
+			const allEntries = parseEntries(topicContent);
+			const hook = allEntries.map((e) => e.title).join("; ").slice(0, 150);
+			next = updateHook(entries, topic, hook);
+			if (!checkCapacity(next, p.maxLines, p.maxBytes)) {
+				return {
+					ok: false,
+					error: `MEMORY.md capacity exceeded (max ${p.maxLines} lines / ${p.maxBytes} bytes). Current entries: ${serializeIndex(entries)}`,
+				};
+			}
 		}
+
 		// write index
-		await writeFile(join(memoryDir, MEMORY_MD), serializeIndex(next) + "\n", "utf8");
+		await writeFile(join(memoryDir, MEMORY_MD), `${serializeIndex(next)}\n`, "utf8");
 		return { ok: true, entries: next };
 	});
 }
@@ -67,38 +129,56 @@ export async function doAdd(memoryDir: string, p: AddParams): Promise<ActionResu
 export async function doRemove(memoryDir: string, p: RemoveParams): Promise<ActionResult> {
 	return withFileMutationQueue(join(memoryDir, MEMORY_MD), async () => {
 		const entries = await readIndex(memoryDir);
-		const match = matchEntryByTitle(entries, p.entry);
-		if (!match.entry) {
-			return { ok: false, error: `Entry "${p.entry}" not found in index` };
+
+		// Search across all topic files to find which one contains this entry
+		const files = await readdir(memoryDir).catch(() => []);
+		let foundTopic: string | null = null;
+		const foundTopics: string[] = [];
+
+		for (const f of files) {
+			if (!f.endsWith(".md") || f === MEMORY_MD) continue;
+			const raw = await readFile(join(memoryDir, f), "utf8").catch(() => "");
+			const parsed = parseEntries(raw);
+			if (parsed.some((e) => e.title === p.entry)) {
+				foundTopics.push(f);
+				foundTopic = f;
+			}
+		}
+
+		if (foundTopics.length === 0) {
+			return { ok: false, error: `Entry "${p.entry}" not found in any topic` };
 		}
-		if (!match.unique) {
-			const matchingTopics = entries
-				.filter((e) => e.title === p.entry)
-				.map((e) => e.topic)
-				.join(", ");
-			return { ok: false, error: `Multiple matches for entry "${p.entry}" in topics: ${matchingTopics}` };
+		if (foundTopics.length > 1) {
+			return { ok: false, error: `Multiple matches for entry "${p.entry}" in topics: ${foundTopics.join(", ")}` };
 		}
 
-		const topicFile = match.entry.topic;
+		// biome-ignore lint/style/noNonNullAssertion: foundTopic assigned in guard above
+		const topicFile = foundTopic!;
 		const topicPath = safeTopicPath(memoryDir, topicFile);
 
-		// remove index line
-		const updated = removeEntryByTitle(entries, p.entry);
-		await writeFile(join(memoryDir, MEMORY_MD), serializeIndex(updated) + "\n", "utf8");
-
-		// remove ## block from topic file
+		// Remove ## block from topic file
 		try {
 			const raw = await readFile(topicPath, "utf8");
 			const afterRemoval = removeEntrySection(raw, p.entry);
+
 			if (hasEntries(afterRemoval)) {
+				// Still has entries: update hook to remaining first entry, refresh date
+				const remaining = parseEntries(afterRemoval);
+				const newHook = remaining.length > 0 ? remaining[0].title : "";
+				const nextEntries = updateHook(entries, topicFile, newHook);
 				const refreshed = updateFrontmatterDate(afterRemoval, today());
 				await writeFile(topicPath, refreshed, "utf8");
+				await writeFile(join(memoryDir, MEMORY_MD), `${serializeIndex(nextEntries)}\n`, "utf8");
 			} else {
+				// Last entry removed: delete topic file and remove from index
+				const nextEntries = removeEntryByTopic(entries, topicFile);
 				await unlink(topicPath).catch(() => {});
+				await writeFile(join(memoryDir, MEMORY_MD), `${serializeIndex(nextEntries)}\n`, "utf8");
 			}
+			// biome-ignore lint/suspicious/noExplicitAny: error catch
 		} catch (e: any) {
-			// topic file missing — still ok, index already removed
 			if ((e as NodeJS.ErrnoException).code !== "ENOENT") throw e;
+			return { ok: false, error: `Topic file "${topicFile}" not found` };
 		}
 
 		return { ok: true };
@@ -111,6 +191,7 @@ export async function doRead(memoryDir: string, p: ReadParams): Promise<ReadResu
 		let topicPath: string;
 		try {
 			topicPath = safeTopicPath(memoryDir, topicName);
+			// biome-ignore lint/suspicious/noExplicitAny: error catch
 		} catch (e: any) {
 			return { ok: false, error: e.message };
 		}
@@ -122,9 +203,7 @@ export async function doRead(memoryDir: string, p: ReadParams): Promise<ReadResu
 		}
 	}
 	if (p.entry) {
-		const files = (await readdir(memoryDir).catch(() => [])).filter(
-			(f) => f.endsWith(".md") && f !== MEMORY_MD,
-		);
+		const files = (await readdir(memoryDir).catch(() => [])).filter((f) => f.endsWith(".md") && f !== MEMORY_MD);
 		for (const f of files) {
 			const raw = await readFile(join(memoryDir, f), "utf8").catch(() => "");
 			const entries = parseEntries(raw);
@@ -156,7 +235,11 @@ export async function searchMemory(memoryDir: string, query: string): Promise<st
 
 export interface MemoryToolDeps {
 	getMemoryDir: () => string | null;
-	getConfig: () => { memIndexMaxLines: number; memIndexMaxBytes: number; sessionSearch: { maxSessions: number; maxMatches: number } };
+	getConfig: () => {
+		memIndexMaxLines: number;
+		memIndexMaxBytes: number;
+		sessionSearch: { maxSessions: number; maxMatches: number };
+	};
 	getEnabled: () => boolean;
 	searchSessions: (cwd: string, query: string, cfg: { maxSessions: number; maxMatches: number }) => Promise<string>;
 	cwd: () => string;
@@ -167,51 +250,74 @@ export function createMemoryTool(deps: MemoryToolDeps) {
 		name: "memory",
 		label: "Memory",
 		description:
-			"Read/write project memory across sessions. action 'add' appends content under a topic (auto-created) as an entry; 'remove' deletes an entry by title; 'read' loads a topic or entry; 'search' queries memory files or history sessions. IMPORTANT: only MEMORY.md index lines are injected into system prompts — entry titles must be self-contained and descriptive (topic file content is NOT injected).",
-		promptSnippet: "Read/write project memory across sessions (add/remove/search/read). Only index titles are injected — make titles self-descriptive.",
+			"Read/write project memory across sessions. action 'add' appends content under a topic (auto-created) as an entry; 'remove' deletes an entry by title; 'read' loads a topic or entry; 'search' queries memory files or history sessions. IMPORTANT: only MEMORY.md index lines are injected into system prompts — entry titles must be self-contained and descriptive (topic file content is NOT injected automatically — it is auto-surfaced for relevant queries).",
+		promptSnippet:
+			"Read/write project memory across sessions (add/remove/search/read). Only index titles are injected — make titles self-descriptive.",
 		promptGuidelines: [
 			"Use memory to persist project facts, user preferences, and lessons learned across sessions.",
 			"Use memory action 'add' with an explicit topic filename and a descriptive, self-contained entry title — only the index line (title + topic) is injected into future prompts, NOT the topic file content. The title alone must convey what was learned.",
 			"Use memory action 'search' with scope='sessions' to find past work in history sessions.",
 			"Use memory action 'read' with topic or entry to load stored knowledge.",
+			"Auto-surfacing: relevant topic files are automatically selected and their content injected into the conversation context. Use 'read' to load additional topics when needed — you don't need to read what's already been surfaced.",
 		],
 		parameters: Type.Object({
 			action: StringEnum(["add", "remove", "search", "read"] as const),
 			// add
 			content: Type.Optional(Type.String({ description: "Knowledge text to store (add)." })),
-			topic: Type.Optional(Type.String({ description: "Target topic filename, e.g. 'debugging.md'. Auto-created if new (add/read)." })),
-			title: Type.Optional(Type.String({ description: "Descriptive, self-contained title for the MEMORY.md index line. Only index lines are injected into future prompts (NOT topic file content), so the title must convey enough context on its own. Required for add." })),
+			topic: Type.Optional(
+				Type.String({ description: "Target topic filename, e.g. 'debugging.md'. Auto-created if new (add/read)." }),
+			),
+			title: Type.Optional(
+				Type.String({
+					description:
+						"Descriptive, self-contained title for the MEMORY.md index line. Only index lines are injected into future prompts (NOT topic file content), so the title must convey enough context on its own. Required for add.",
+				}),
+			),
+			type: Type.Optional(StringEnum(["user", "feedback", "project", "reference"] as const)),
 			// remove
-			entry: Type.Optional(Type.String({ description: "Entry title to remove. Exact match on MEMORY.md index line (remove/read)." })),
+			entry: Type.Optional(
+				Type.String({ description: "Entry title to remove. Exact match on MEMORY.md index line (remove/read)." }),
+			),
 			// search
 			query: Type.Optional(Type.String()),
 			scope: Type.Optional(StringEnum(["memory", "sessions"] as const)),
 		}),
+		// biome-ignore lint/suspicious/noExplicitAny: renderCall args
 		renderCall(args: any, theme: any) {
 			let t = theme.fg("toolTitle", theme.bold("memory ")) + theme.fg("muted", args.action);
 			if (args.topic) t += ` ${theme.fg("accent", args.topic)}`;
 			if (args.query) t += ` ${theme.fg("dim", `"${args.query}"`)}`;
 			return new Text(t, 0, 0);
 		},
-		renderResult(result: any, { expanded }: any, theme: any) {
+		// biome-ignore lint/suspicious/noExplicitAny: renderResult expanded param
+		renderResult(result: any, { expanded: _expanded }: any, theme: any) {
 			const txt = result.content?.[0];
 			const text = txt?.type === "text" ? txt.text : "";
 			if (result.details?.error) return new Text(theme.fg("error", `Error: ${result.details.error}`), 0, 0);
 			return new Text(theme.fg("success", "✓ ") + theme.fg("muted", text.split("\n")[0]), 0, 0);
 		},
+		// biome-ignore lint/suspicious/noExplicitAny: renderResult result param
 		async execute(_id: string, params: any, _signal: AbortSignal | undefined, _onUpdate: any, _ctx: any) {
 			if (!deps.getEnabled()) throw new Error("Memory is disabled (run /memory on)");
 			const dir = deps.getMemoryDir();
 			const cfg = deps.getConfig();
 			if (!dir) throw new Error("Memory not initialized (no session_start yet)");
 			let text: string;
+			// biome-ignore lint/suspicious/noExplicitAny: execute params
 			let details: any = {};
 			switch (params.action) {
 				case "add": {
 					if (!params.content) throw new Error("content is required for add");
 					if (!params.topic) throw new Error("topic is required for add");
 					if (!params.title) throw new Error("title is required for add");
-					const r = await doAdd(dir, { content: params.content, topic: params.topic, title: params.title, maxLines: cfg.memIndexMaxLines, maxBytes: cfg.memIndexMaxBytes });
+					const r = await doAdd(dir, {
+						content: params.content,
+						topic: params.topic,
+						title: params.title,
+						type: params.type,
+						maxLines: cfg.memIndexMaxLines,
+						maxBytes: cfg.memIndexMaxBytes,
+					});
 					if (!r.ok) throw new Error(r.error);
 					text = `Added "${params.title}" to ${params.topic}. Index now has ${r.entries?.length ?? 0} entries.`;
 					details = { entries: r.entries?.length };
@@ -237,6 +343,7 @@ export function createMemoryTool(deps: MemoryToolDeps) {
 					if (!params.topic && !params.entry) throw new Error("topic or entry is required for read");
 					const r = await doRead(dir, { topic: params.topic, entry: params.entry });
 					if (!r.ok) throw new Error(r.error);
+					// biome-ignore lint/style/noNonNullAssertion: content assertion
 					text = r.content!;
 					break;
 				}

package/src/nudge.ts

@@ -1,9 +1,12 @@
 import { readFile, writeFile } from "node:fs/promises";
-import { SessionManager } from "@earendil-works/pi-coding-agent";
 import { join } from "node:path";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
 import type { MemoryConfig } from "./config";
 
-export interface DreamMeta { lastDreamAt: string; sessionCountAtDream: number; }
+export interface DreamMeta {
+	lastDreamAt: string;
+	sessionCountAtDream: number;
+}
 
 const META_FILE = ".dream-meta.json";
 
@@ -29,17 +32,17 @@ export async function shouldNudge(
 	memoryDir: string,
 	config: MemoryConfig,
 	cwd: string,
-): Promise<{ nudge: boolean; message: string }> {
+): Promise<{ nudge: boolean; message: string; sessions: number; newEntries: number }> {
 	const sessions = (await SessionManager.list(cwd)).length;
 	const meta = await readDreamMeta(memoryDir);
 	const newEntries = meta ? Math.max(0, sessions - meta.sessionCountAtDream) : sessions;
 	if (meta) {
 		const hoursSince = (Date.now() - new Date(meta.lastDreamAt).getTime()) / 3600_000;
 		if (hoursSince >= config.dream.nudgeAfterHours && newEntries >= config.dream.nudgeAfterSessions) {
-			return { nudge: true, message: formatNudge(sessions, newEntries) };
+			return { nudge: true, message: formatNudge(sessions, newEntries), sessions, newEntries };
 		}
 	} else if (sessions >= config.dream.nudgeAfterSessions) {
-		return { nudge: true, message: formatNudge(sessions, newEntries) };
+		return { nudge: true, message: formatNudge(sessions, newEntries), sessions, newEntries };
 	}
-	return { nudge: false, message: "" };
+	return { nudge: false, message: "", sessions: 0, newEntries: 0 };
 }

package/src/paths.ts

@@ -1,6 +1,6 @@
-import { createHash } from "node:crypto";
 import { execFile } from "node:child_process";
-import { join, resolve, normalize, sep } from "node:path";
+import { createHash } from "node:crypto";
+import { join, normalize, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 
 const execFileP = promisify(execFile);
@@ -19,10 +19,7 @@ export async function projectHash(cwd: string): Promise<string> {
 	return createHash("sha256").update(key).digest("hex").slice(0, 12);
 }
 
-export async function resolveMemoryDir(
-	config: { memoryDir: string },
-	cwd: string,
-): Promise<string> {
+export async function resolveMemoryDir(config: { memoryDir: string }, cwd: string): Promise<string> {
 	const hash = await projectHash(cwd);
 	return join(config.memoryDir, hash);
 }