pi-memoria 0.1.3 → 0.2.0

package/src/runtime.ts

@@ -9,7 +9,6 @@
  * - Track hits/writes/last-used (`UsageStore`) outside the search path.
  * - Merge several roots with rank normalization so no store is drowned.
  * - Report health: duplicate topics, contradictions, staleness, promotion.
- * - Export and import the store as JSONL.
  */
 
 import { existsSync } from "node:fs";
@@ -20,18 +19,14 @@ import { DEFAULT_CONFIG, INDEX_DIR, LIBRARY_DIR, loadConfig, resolveRoots, resol
 import { MemoryIndex, createIndexSaver, isIgnoredWatchPath } from "./index-engine.ts";
 import {
 	addHotEntry,
-	appendFact,
 	categorySummary,
 	createMemory,
 	deleteMemory,
-	deriveSummary,
 	ensureStore,
-	extendSummary,
 	extractFactUnits,
 	hotTemplate,
 	looksAtomicTopic,
 	moveMemory,
-	normalizePriority,
 	priorityRank,
 	readHot,
 	recoverJournal,
@@ -39,9 +34,9 @@ import {
 	renderLibraryIndexes,
 	resolveMemoryRef,
 	touchLastUsed,
-	trimHot,
 	updateMemory,
 	writeHot,
+	validateHot,
 	type CreateMemoryInput,
 	type CreateMemoryResult,
 	type IndexListingDoc,
@@ -53,7 +48,6 @@ import { SessionStore } from "./sessions.ts";
 import { UsageStore } from "./usage.ts";
 import { compareDocs, detectContradictions, isComparableTerm, suggestMerges, type SimilarityDoc } from "./similarity.ts";
 import { expandSynonymTable, loadSynonymsFile, mergeSynonymTables } from "./synonyms.ts";
-import { decodeJsonl, encodeJsonl, writeImportedNote, type ImportedNote } from "./transfer.ts";
 import { KeyedMutex, atomicWriteFile, debounce, normalizePath, oneLine, readFileOrUndefined } from "./util.ts";
 import type {
 	Contradiction,
@@ -707,57 +701,6 @@ export class MemoriaRuntime {
 		return { result, root };
 	}
 
-	/** Append a fact to an existing note by id (used by session learning). */
-	async appendToNote(
-		id: string,
-		input: { content: string; label?: string; tags?: string[]; summary?: string; priority?: string; confidence?: string; source?: string },
-		scope: Scope = "all",
-	): Promise<{ doc: MemoryDoc; duplicate: boolean } | undefined> {
-		const candidates = scope === "all" ? this.activeRoots("all") : [this.rootForScope(scope)];
-		for (const root of candidates) {
-			const locked = await this.locks.run(root, async () => this.appendToNoteLocked(root, id, input));
-			if (locked) {
-				this.bumpCacheGeneration();
-				return locked;
-			}
-		}
-		return undefined;
-	}
-
-	private async appendToNoteLocked(
-		root: string,
-		id: string,
-		input: { content: string; label?: string; tags?: string[]; summary?: string; priority?: string; confidence?: string; source?: string },
-	): Promise<{ doc: MemoryDoc; duplicate: boolean } | undefined> {
-		const state = await this.storeFor(root);
-		const idx = state.index.idxForId(id);
-		if (idx === undefined) return undefined;
-		const doc = await resolveMemoryRef(root, id, liveLookup(state.index));
-		if (!doc) return undefined;
-		const appended = appendFact(doc.body, input.label, input.content);
-		if (!appended.changed) return { doc, duplicate: true };
-		const tags = input.tags ? [...new Set([...doc.tags, ...input.tags])] : undefined;
-		const priority = input.priority && priorityRank(normalizePriority(input.priority)) > priorityRank(doc.priority) ? input.priority : undefined;
-		const summary = extendSummary(doc.summary, input.summary ?? deriveSummary(input.content));
-		const updated = await updateMemory(root, doc, {
-			content: appended.body,
-			tags,
-			summary,
-			priority,
-			confidence: input.confidence,
-			source: input.source,
-		});
-		state.index.removeDoc(idx);
-		state.index.addDoc(updated);
-		state.index.builtAt = Date.now();
-		state.saver.schedule();
-		if (state.usage) {
-			state.usage.record(updated.id, "write");
-			state.usageSaver();
-		}
-		return { doc: updated, duplicate: false };
-	}
-
 	async updateMemoryById(
 		id: string,
 		input: UpdateMemoryInput & { scope?: Scope },
@@ -922,7 +865,7 @@ export class MemoriaRuntime {
 			const state = await readHot(root, this.config.hotLimit);
 			const content = state.exists ? state.content : hotTemplate();
 			const added = addHotEntry(content, text, topic);
-			if (added.changed) await writeHot(root, added.content);
+			if (added.changed) await writeHot(root, added.content, this.config.hotLimit);
 			return {
 				before: state.chars,
 				after: added.content.length,
@@ -937,7 +880,7 @@ export class MemoriaRuntime {
 		return this.locks.run(root, async () => {
 			const state = await readHot(root, this.config.hotLimit);
 			const [next, removed] = removeHotMatches(state.content, pattern);
-			await writeHot(root, next);
+			await writeHot(root, next, this.config.hotLimit);
 			return { before: state.chars, after: next.length, removed };
 		});
 	}
@@ -945,19 +888,20 @@ export class MemoriaRuntime {
 	async hotReplace(content: string, root = this.roots.primary): Promise<{ before: number; after: number }> {
 		return this.locks.run(root, async () => {
 			const state = await readHot(root, this.config.hotLimit);
-			await writeHot(root, content);
-			return { before: state.chars, after: content.length };
+			await writeHot(root, content, this.config.hotLimit);
+			return { before: state.chars, after: validateHot(content, this.config.hotLimit).length };
 		});
 	}
 
-	/** Trim MEMORY.md to the configured budget, reporting what was cut. */
+	/** Check the briefing without deleting facts to meet the budget. */
 	async hotCompact(root = this.roots.primary): Promise<{ before: number; after: number; removed: string }> {
 		return this.locks.run(root, async () => {
 			const state = await readHot(root, this.config.hotLimit);
-			if (!state.over) return { before: state.chars, after: state.chars, removed: "" };
-			const trimmed = trimHot(state.content, this.config.hotLimit);
-			await writeHot(root, trimmed.content);
-			return { before: state.chars, after: trimmed.content.length, removed: trimmed.removed };
+			if (!state.over) {
+				validateHot(state.content, this.config.hotLimit);
+				return { before: state.chars, after: state.chars, removed: "" };
+			}
+			throw new Error("MEMORY.md is over budget. Read it and use action=replace with a tighter briefing preserving standing facts; compact never drops facts automatically.");
 		});
 	}
 
@@ -1284,159 +1228,6 @@ export class MemoriaRuntime {
 		return { since, created: created.sort(byRecency), updated: updated.sort(byRecency) };
 	}
 
-	/* ---------------------------------------------------------------- */
-	/* Export / import                                                   */
-	/* ---------------------------------------------------------------- */
-
-	/** Serialize the store as JSONL (one record per line, plus MEMORY.md). */
-	async exportJsonl(options: { scope?: Scope; includeHot?: boolean; includeTrash?: boolean } = {}): Promise<{ jsonl: string; notes: number }> {
-		const roots = this.activeRoots(options.scope ?? "all");
-		const lines: string[] = [];
-		let notes = 0;
-		for (const root of roots) {
-			const state = await this.storeFor(root);
-			await this.refreshIndex(state.index);
-			const hot = await readHot(root, this.config.hotLimit);
-			if (options.includeHot !== false && hot.exists && hot.content.trim()) {
-				lines.push(encodeJsonl({ type: "hot", root: this.displayPath(root), content: hot.content }));
-			}
-			for (const { idx, meta } of state.index.liveDocs()) {
-				const body = await state.index.bodyFor(idx);
-				lines.push(
-					encodeJsonl({
-						type: "memory",
-						id: meta.id,
-						relPath: meta.relPath,
-						root: this.displayPath(root),
-						title: meta.title,
-						category: meta.category,
-						tags: meta.tags,
-						aliases: meta.aliases,
-						related: meta.related,
-						supersedes: meta.supersedes,
-						summary: meta.summary,
-						priority: meta.priority,
-						confidence: meta.confidence,
-						created: meta.created,
-						updated: meta.updated,
-						body,
-					}),
-				);
-				notes += 1;
-			}
-		}
-		return { jsonl: `${lines.join("\n")}\n`, notes };
-	}
-
-	/** Import JSONL produced by `exportJsonl` into the primary (or project) store. */
-	async importJsonl(
-		text: string,
-		options: { mode?: "merge" | "replace" | "skip"; scope?: Scope; dryRun?: boolean } = {},
-	): Promise<{ created: string[]; updated: string[]; skipped: number; errors: string[]; hotImported: boolean }> {
-		const mode = options.mode ?? "merge";
-		const root = this.rootForScope(options.scope ?? "primary");
-		await ensureStore(root, this.config.hotLimit, this.config.defaultCategory);
-		const state = await this.storeFor(root);
-		const records = decodeJsonl(text);
-		const result = { created: [] as string[], updated: [] as string[], skipped: 0, errors: records.errors, hotImported: false };
-		return this.locks.run(root, async () => {
-			let changed = false;
-			let completed = false;
-			try {
-				for (const record of records.records) {
-					if (record.type === "hot") {
-						if (options.dryRun) continue;
-						// Already inside the root lock: call the store helpers directly.
-						await writeHot(root, record.content);
-						result.hotImported = true;
-						continue;
-					}
-					if (!options.dryRun) changed = true;
-					const outcome = await this.importNote(root, state, record, mode, options.dryRun === true);
-					if (!options.dryRun && outcome !== "skipped") changed = true;
-					if (outcome === "created") result.created.push(record.id);
-					else if (outcome === "updated") result.updated.push(record.id);
-					else result.skipped += 1;
-				}
-				completed = true;
-				return result;
-			} finally {
-				if (changed) {
-					this.bumpCacheGeneration();
-					if (!completed) state.index.dirty = true;
-					state.index.builtAt = Date.now();
-					state.saver.schedule();
-				}
-			}
-		});
-	}
-
-	private async importNote(
-		root: string,
-		state: StoreState,
-		note: ImportedNote,
-		mode: "merge" | "replace" | "skip",
-		dryRun: boolean,
-	): Promise<"created" | "updated" | "skipped"> {
-		const existingIdx = state.index.idxForId(note.id);
-		const existing = existingIdx !== undefined ? await resolveMemoryRef(root, note.id, liveLookup(state.index)) : undefined;
-		if (existing) {
-			if (mode === "skip") return "skipped";
-			if (dryRun) return "updated";
-			if (mode === "replace") {
-				const updated = await updateMemory(root, existing, {
-					title: note.title,
-					content: note.body,
-					tags: note.tags,
-					aliases: note.aliases,
-					related: note.related,
-					supersedes: note.supersedes,
-					summary: note.summary,
-					priority: note.priority,
-					confidence: note.confidence,
-					category: note.category || existing.category,
-				});
-				state.index.removeDoc(existingIdx!);
-				state.index.addDoc(updated);
-				return "updated";
-			}
-			// merge: fold in the fact units that are not already present.
-			let body = existing.body;
-			let changed = false;
-			for (const unit of extractFactUnits(note.body)) {
-				const appended = appendFact(body, unit.label, unit.text);
-				if (appended.changed) {
-					body = appended.body;
-					changed = true;
-				}
-			}
-			const newTags = note.tags.filter((tag) => !existing.tags.includes(tag));
-			const newAliases = note.aliases.filter((alias) => !existing.aliases.some((current) => current.toLowerCase() === alias.toLowerCase()));
-			const tags = newTags.length > 0 ? [...new Set([...existing.tags, ...newTags])] : undefined;
-			const aliases = newAliases.length > 0 ? [...new Set([...existing.aliases, ...newAliases])] : undefined;
-			if (!changed && !tags && !aliases) return "skipped";
-			const updated = await updateMemory(root, existing, {
-				content: changed ? body : undefined,
-				tags,
-				aliases,
-				summary: changed ? extendSummary(existing.summary, note.summary) : undefined,
-			});
-			state.index.removeDoc(existingIdx!);
-			state.index.addDoc(updated);
-			return "updated";
-		}
-		if (dryRun) return "created";
-		// `writeImportedNote` avoids the path when it is taken by a different note,
-		// so an import can never overwrite an existing memory.
-		const written = await writeImportedNote(root, note);
-		const stale = state.index.idxForRelPath(written.relPath);
-		if (stale >= 0) state.index.removeDoc(stale);
-		const staleId = state.index.idxForId(written.id);
-		if (staleId !== undefined && staleId !== stale) state.index.removeDoc(staleId);
-		state.index.addDoc(written);
-		return "created";
-	}
-
 	/**
 	 * One pass over the store producing both structured findings and the
 	 * human-readable list: `/memoria doctor` renders the structure, the tool and

package/src/store.ts

@@ -1360,9 +1360,36 @@ export async function readHot(root: string, limit: number): Promise<HotState> {
 	return { path, content, chars, limit, over: chars > limit, exists: true };
 }
 
-/** Write MEMORY.md atomically. Callers enforce/validate the budget. */
-export async function writeHot(root: string, content: string): Promise<void> {
-	await atomicWriteFile(join(root, HOT_FILE), content.endsWith("\n") ? content : `${content}\n`);
+/** Validate the complete briefing, without silently cutting or removing facts.
+ * Semantic eligibility and correction checks remain the calling agent's job.
+ * The legacy empty/template title is accepted and removed during migration.
+ */
+export function validateHot(content: string, limit = 5000): string {
+	const prose = content.replace(/^# Memory[ \t]*(?:\r?\n|$)/, "").trim();
+	if (/^\s*(?:#{1,6}\s|[-*+]\s|\d+[.)]\s|>|```|~~~|\|)/m.test(prose) || /<!--|-->/.test(prose)) {
+		throw new Error("MEMORY.md must be plain prose: no headings, lists, tables, code fences or annotations.");
+	}
+	const normalized = prose ? `${prose}\n` : "";
+	if (normalized.length > limit) throw new Error(`MEMORY.md exceeds its ${limit}-character budget. Rewrite more tightly; no content was saved or truncated.`);
+	const seen = new Set<string>();
+	for (const paragraph of normalized.split(/\n\s*\n/)) for (const unit of splitHotUnits(paragraph)) {
+		const key = unit.toLowerCase().replace(/\s+/g, " ").trim();
+		if (key && seen.has(key)) throw new Error("MEMORY.md contains a repeated sentence. Consolidate it before saving.");
+		seen.add(key);
+	}
+	return normalized;
+}
+
+/** All supported briefing writes validate first and preserve the previous version. */
+export async function writeHot(root: string, content: string, limit = 5000): Promise<void> {
+	const next = validateHot(content, limit);
+	const path = join(root, HOT_FILE);
+	const previous = await readFileOrUndefined(path);
+	if (previous === next) return;
+	if (previous !== undefined) {
+		await atomicWriteFile(join(root, ".history", `${newMemoryId()}-MEMORY.md`), previous);
+	}
+	await atomicWriteFile(path, next);
 }
 
 /**
@@ -1466,7 +1493,8 @@ export interface HotAddResult {
  * marker or anchor text is ever written into the file.
  */
 export function addHotEntry(content: string, text: string, topic?: string): HotAddResult {
-	const sentence = oneLine(text, 1200).replace(/^[-*]\s*/, "").trim();
+	validateHot(text, Number.MAX_SAFE_INTEGER);
+	const sentence = oneLine(text).trim();
 	if (!sentence) return { content, changed: false, paragraph: "", created: false };
 	const blocks = splitHotParagraphs(content);
 	const title = blocks.find(isTitleBlock);
@@ -1642,7 +1670,7 @@ export async function ensureStore(root: string, hotLimit: number, defaultCategor
 	await mkdir(join(root, LIBRARY_DIR, defaultCategory), { recursive: true });
 	await mkdir(join(root, INDEX_DIR), { recursive: true });
 	const hot = await readHot(root, hotLimit);
-	if (!hot.exists) await writeHot(root, hotTemplate());
+	if (!hot.exists) await writeHot(root, hotTemplate(), hotLimit);
 }
 
 /** Resolve a user-supplied memory reference (id, alias, relative path, or absolute path). */

package/src/tools.ts

@@ -6,8 +6,6 @@
  * returned when explicitly requested.
  */
 
-import { readFile } from "node:fs/promises";
-import { isAbsolute, resolve } from "node:path";
 import { Type } from "typebox";
 import type { AgentToolResult, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
@@ -15,12 +13,9 @@ import type { MemoriaRuntime } from "./runtime.ts";
 import { readStoreFile } from "./store.ts";
 import { renderSessionFallback, ripgrepNotice } from "./recall.ts";
 import { formatSessionTime } from "./sessions.ts";
-import { atomicWriteFile, oneLine, truncateChars } from "./util.ts";
+import { oneLine, truncateChars } from "./util.ts";
 import type { Priority, Scope, SearchHit, SessionScanStats } from "./types.ts";
 
-/** Inline export/import payload cap; larger dumps must use a file path. */
-const MAX_INLINE_TRANSFER_CHARS = 60_000;
-
 export type RuntimeGetter = (ctx: ExtensionContext) => Promise<MemoriaRuntime>;
 
 const ScopeEnum = Type.Union([Type.Literal("primary"), Type.Literal("all"), Type.Literal("project"), Type.Literal("global")], {
@@ -103,7 +98,7 @@ const WriteParams = Type.Object({
 const HotParams = Type.Object({
 	action: Type.Union([Type.Literal("add"), Type.Literal("remove"), Type.Literal("replace"), Type.Literal("read"), Type.Literal("compact")], {
 		description:
-			"add: append a sentence to a theme paragraph. remove: delete every sentence containing a substring. replace: rewrite the whole file as prose. read: show it. compact: trim to the character budget.",
+			"add: append a sentence to a theme paragraph. remove: delete every sentence containing a substring. replace: rewrite the whole file as prose. read: show it. compact: check the budget without deleting facts; if oversized, use replace with a tighter supported briefing.",
 	}),
 	topic: Type.Optional(
 		Type.String({
@@ -169,29 +164,6 @@ const SessionsParams = Type.Object({
 	window: Type.Optional(Type.Number({ description: "For action=read: messages of context on each side (default 6, max 40)." })),
 });
 
-const ExportParams = Type.Object({
-	path: Type.Optional(
-		Type.String({
-			description: "Write the JSONL dump to this file (absolute, or relative to the working directory). Without it a bounded preview is returned inline.",
-		}),
-	),
-	include_hot: Type.Optional(Type.Boolean({ description: "Include MEMORY.md as a record (default true)." })),
-	scope: Type.Optional(ScopeEnum),
-});
-
-const ImportParams = Type.Object({
-	path: Type.Optional(Type.String({ description: "JSONL file to import (absolute, or relative to the working directory)." })),
-	content: Type.Optional(Type.String({ description: "Inline JSONL content. Prefer `path` for anything larger than a few notes." })),
-	mode: Type.Optional(
-		Type.Union([Type.Literal("merge"), Type.Literal("replace"), Type.Literal("skip")], {
-			description:
-				"merge (default): add facts that are missing from a note with the same id. replace: overwrite notes with the same id. skip: only import notes that do not exist yet.",
-		}),
-	),
-	dry_run: Type.Optional(Type.Boolean({ description: "Report what would happen without writing anything." })),
-	scope: Type.Optional(ScopeEnum),
-});
-
 const ForgetParams = Type.Object({
 	id: Type.String({ description: "Memory id to remove. The file is moved to .trash/ rather than deleted." }),
 	scope: Type.Optional(ScopeEnum),
@@ -238,10 +210,10 @@ export function registerMemoriaTools(pi: ExtensionAPI, getRuntime: RuntimeGetter
 		name: "memoria_recall",
 		label: "Recalling memories",
 		description:
-			"Search long-term memory (the memoria library) for anything the user has said or that was learned in past sessions. Use this before answering questions about people, preferences, projects, decisions, past incidents or anything possibly stored earlier. Returns ranked notes with ids, paths and excerpts; call memoria_read for full text.",
-		promptSnippet: "memoria_recall: search long-term memory before answering anything possibly known from before",
+			"Search long-term memory (the memoria library) for anything the user has said or that was learned in past sessions. Use when evidence already recalled into context is insufficient for a question about prior facts. Returns ranked notes with ids, paths and excerpts; call memoria_read for full text.",
+		promptSnippet: "memoria_recall: search prior facts when recalled context is insufficient",
 		promptGuidelines: [
-			"Call memoria_recall before answering questions about people, preferences, projects, decisions or prior conversations.",
+			"Use relevant recalled context directly; call memoria_recall when it is insufficient.",
 			"Never say you do not remember without calling memoria_recall first.",
 			"Use memoria_recall with several focused queries when a first search returns nothing but the topic is likely stored.",
 		],
@@ -433,7 +405,7 @@ export function registerMemoriaTools(pi: ExtensionAPI, getRuntime: RuntimeGetter
 				lines.push(`NOTE: ${result.topicNote}. Prefer a broad grouping name so related facts stay together.`);
 			}
 			lines.push(
-				`MEMORY.md is at ${hot.chars}/${hot.limit} chars${hot.over ? ' (OVER BUDGET — run memoria_hot { action: "compact" } or move detail into the library)' : ""}.`,
+				`MEMORY.md is at ${hot.chars}/${hot.limit} chars${hot.over ? ' (OVER BUDGET — rewrite with memoria_hot { action: "replace" } or move detail into the library)' : ""}.`,
 			);
 			// Housekeeping hints are best-effort: a failure must not fail the write.
 			try {
@@ -498,6 +470,8 @@ export function registerMemoriaTools(pi: ExtensionAPI, getRuntime: RuntimeGetter
 			"MEMORY.md is loaded on every request, so it is only for facts that pay off that often: identity, timezone/locale, communication style, hard constraints, and the current state of active work.",
 			"Write MEMORY.md as a short, natural introduction to the user plus their standing context. Sentences and paragraphs only — no headings, no bullet lists, no 'Topic — fact' labels.",
 			"Keep occasional details (URLs, versions, file paths, history, rationale) in library notes; recall finds them when needed.",
+			"Before every edit, read the briefing. Consolidate existing statements instead of appending paraphrases. Apply explicit corrections in place; ask about ambiguous conflicts. Preserve unrelated standing facts. Eligibility and factual correctness require your judgment; deterministic validation cannot establish truth.",
+			"Do not repeat skill instructions or dated maintenance history. Every statement must be supported by the user or verified evidence.",
 			"When MEMORY.md grows past a few paragraphs, rewrite it tighter with memoria_hot { action: \"replace\" } and file the dropped detail into the library rather than appending forever.",
 		],
 		parameters: HotParams,
@@ -552,7 +526,7 @@ export function registerMemoriaTools(pi: ExtensionAPI, getRuntime: RuntimeGetter
 					return {
 						content: text(
 							`MEMORY.md compacted: ${result.before} → ${result.after}/${runtime.config.hotLimit} chars.${
-								result.before === result.after ? " Already under budget." : " Least-important trailing paragraphs were dropped. Next time prefer action=replace with a tighter summary."
+								result.before === result.after ? " Already under budget." : " No facts are automatically dropped."
 							}${dropped}`,
 						),
 						details: { kind: "hot", chars: result.after, limit: runtime.config.hotLimit },
@@ -807,105 +781,6 @@ export function registerMemoriaTools(pi: ExtensionAPI, getRuntime: RuntimeGetter
 		},
 	});
 
-	pi.registerTool<typeof ExportParams, { kind: string; notes?: number; bytes?: number; path?: string }, unknown>({
-		name: "memoria_export",
-		label: "Exporting memories",
-		description:
-			"Export the memory store as JSONL (one record per line: notes plus MEMORY.md) for backup or migration. With `path` the full dump is written to that file; without it a bounded preview is returned. Pair with memoria_import to restore.",
-		promptSnippet: "memoria_export: dump the memory store to JSONL for backup or migration",
-		parameters: ExportParams,
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx): Promise<AgentToolResult<any>> {
-			const runtime = await getRuntime(ctx);
-			const { jsonl, notes } = await runtime.exportJsonl({
-				scope: (params.scope as Scope | undefined) ?? "all",
-				includeHot: params.include_hot !== false,
-			});
-			if (params.path) {
-				const target = isAbsolute(params.path) ? params.path : resolve(ctx.cwd, params.path);
-				await atomicWriteFile(target, jsonl);
-				return {
-					content: text(`Exported ${notes} note(s) to ${target} (${jsonl.length} bytes of JSONL).`),
-					details: { kind: "export", notes, bytes: jsonl.length, path: target },
-				};
-			}
-			const preview = truncateChars(jsonl, MAX_INLINE_TRANSFER_CHARS);
-			const truncated = jsonl.length > preview.length;
-			return {
-				content: text(
-					`${notes} note(s) exported (${jsonl.length} bytes).${truncated ? `\n\nInline preview truncated at ${MAX_INLINE_TRANSFER_CHARS} chars; pass \`path\` to write the complete dump.` : ""}\n\n${preview}`,
-				),
-				details: { kind: "export", notes, bytes: jsonl.length },
-			};
-		},
-		renderCall(args, theme) {
-			return new Text(theme.fg("toolTitle", theme.bold("memoria_export ")) + theme.fg("dim", args.path ?? "inline preview"), 0, 0);
-		},
-		renderResult(result, _options, theme) {
-			const details = result.details as { notes?: number; path?: string } | undefined;
-			return new Text(theme.fg("success", `✓ exported ${details?.notes ?? 0} notes`) + theme.fg("dim", details?.path ? ` → ${details.path}` : ""), 0, 0);
-		},
-	});
-
-	pi.registerTool<typeof ImportParams, { kind: string; created?: number; updated?: number; skipped?: number; errors?: number }, unknown>({
-		name: "memoria_import",
-		label: "Importing memories",
-		description:
-			"Import notes from a JSONL file (or inline content) produced by memoria_export. Never overwrites an existing note unless mode=replace: merge adds only the facts that are missing, and a path already taken by another note gets a numbered sibling. Use dry_run first on an unfamiliar file.",
-		promptSnippet: "memoria_import: restore memories from a JSONL export",
-		promptGuidelines: [
-			"Run memoria_import with dry_run: true first when importing a file you did not create.",
-			"Prefer mode=merge (the default) when importing into a store that already has memories.",
-		],
-		parameters: ImportParams,
-		executionMode: "sequential",
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx): Promise<AgentToolResult<any>> {
-			const runtime = await getRuntime(ctx);
-			let payload = params.content ?? "";
-			if (params.path) {
-				const target = isAbsolute(params.path) ? params.path : resolve(ctx.cwd, params.path);
-				const file = await readFile(target, "utf8");
-				if (file.length > 20_000_000) throw new Error(`Refusing to import ${file.length} chars; split the file first.`);
-				payload = payload ? `${file}\n${payload}` : file;
-			}
-			if (!payload.trim()) throw new Error("Nothing to import: pass `path` or `content`.");
-			const result = await runtime.importJsonl(payload, {
-				mode: (params.mode as "merge" | "replace" | "skip" | undefined) ?? "merge",
-				scope: (params.scope as Scope | undefined) ?? "primary",
-				dryRun: params.dry_run === true,
-			});
-			const lines = [
-				`${params.dry_run ? "Dry run: would import" : "Imported"} ${result.created.length} new note(s), updated ${result.updated.length}, skipped ${result.skipped}.`,
-			];
-			if (result.hotImported) lines.push("MEMORY.md was restored from the export.");
-			if (result.errors.length > 0) lines.push(`Skipped ${result.errors.length} malformed record(s):\n${result.errors.slice(0, 10).join("\n")}`);
-			return {
-				content: text(lines.join("\n")),
-				details: {
-					kind: "import",
-					created: result.created.length,
-					updated: result.updated.length,
-					skipped: result.skipped,
-					errors: result.errors.length,
-				},
-			};
-		},
-		renderCall(args, theme) {
-			return new Text(
-				theme.fg("toolTitle", theme.bold("memoria_import ")) + theme.fg("accent", oneLine(args.path ?? "inline", 60)) + theme.fg("dim", args.mode ? ` (${args.mode})` : ""),
-				0,
-				0,
-			);
-		},
-		renderResult(result, _options, theme) {
-			const details = result.details as { created?: number; updated?: number; skipped?: number } | undefined;
-			return new Text(
-				theme.fg("success", `✓ +${details?.created ?? 0} ~${details?.updated ?? 0}`) + theme.fg("dim", ` skipped ${details?.skipped ?? 0}`),
-				0,
-				0,
-			);
-		},
-	});
-
 	pi.registerTool<typeof ForgetParams, { kind: string; id?: string; trash?: string }, unknown>({
 		name: "memoria_forget",
 		label: "Forgetting a memory",

package/src/types.ts

@@ -349,6 +349,8 @@ export interface MemoriaConfig {
 	/** Auto-recall tuning. */
 	autoRecall: boolean;
 	autoRecallLimit: number;
+	/** Minimum fraction of the strongest eligible score for automatic recall. */
+	autoRecallMinRatio: number;
 	autoRecallMinScore: number;
 	autoRecallMaxChars: number;
 	/** Number of previous user turns folded into the recall query. */
@@ -402,16 +404,6 @@ export interface MemoriaConfig {
 	rerankTopK: number;
 	/** Reranker budget in milliseconds; falls back to lexical order on timeout. */
 	rerankTimeoutMs: number;
-	/** Automatic session extraction: off, on-settle (idle) or on-shutdown. */
-	autoLearn: string;
-	/** Minimum user turns before auto-learn considers a session. */
-	autoLearnMinTurns: number;
-	/** Minimum transcript characters before auto-learn considers a session. */
-	autoLearnMinChars: number;
-	/** Minimum time between automatic extractions. */
-	autoLearnCooldownMs: number;
-	/** Characters per extraction chunk when harvesting a session. */
-	learnChunkChars: number;
 	/** Idle delay after a filesystem event before refreshing the index. */
 	watcherSettleMs: number;
 	/** Index persistence format: auto (binary above a threshold), json or binary. */