@gavin-hu/my-pi-agent 0.12.0 → 0.13.0

package/extensions/memory/doctor.ts

@@ -0,0 +1,137 @@
+/**
+ * Memory health: what the two stores hold, and whether recall is already
+ * dropping notes (pure).
+ *
+ * The report answers the questions a user cannot see from the notes alone: how
+ * many notes and bytes each store carries, how much of the `maxInjectBytes`
+ * budget the injection uses and which scope overflowed it, and which notes the
+ * conservative `duplicateKey` already considers the same fact. It never changes
+ * anything — consolidation is the picker's `m` merge, and the doctor only names
+ * the pair to merge.
+ *
+ * Byte counts are the store file's size on disk (what a user can reason about
+ * and compare with the cap), plus the injected body's size; both are exact UTF-8
+ * bytes, not a rounded display.
+ */
+
+import { clip } from "../../lib/tui/columns.ts";
+import type { MemoryConfig } from "./config.ts";
+import { injectionPlan, type MemoryEntries } from "./format.ts";
+import { duplicateKey } from "./store.ts";
+import { MEMORY_SCOPES, type MemoryScope } from "./types.ts";
+
+/** Longest note text a duplicate line shows. */
+const PAIR_NOTE_WIDTH = 60;
+/** Label column for the report's rows. */
+const LABEL_WIDTH = 11;
+
+/** One store's counts. */
+export interface ScopeHealth {
+	notes: number;
+	/** File size in bytes; `undefined` when the store was not read. */
+	bytes?: number;
+}
+
+/** Two notes the comparison key treats as one fact, in stored order. */
+export interface DuplicatePair {
+	scope: MemoryScope;
+	/** The note `add` would have kept. */
+	kept: string;
+	/** The note `add` would have refused as a near-duplicate. */
+	duplicate: string;
+}
+
+export interface MemoryHealth {
+	trusted: boolean;
+	inject: boolean;
+	/** The `maxInjectBytes` cap in effect. */
+	cap: number;
+	project: ScopeHealth;
+	global: ScopeHealth;
+	/** Present while injection is on: the body's bytes and what did not fit. */
+	injection?: { bytes: number; omitted: Record<MemoryScope, number> };
+	duplicates: DuplicatePair[];
+}
+
+export interface HealthInput {
+	entries: MemoryEntries;
+	sizes: Record<MemoryScope, number | undefined>;
+	trusted: boolean;
+	config: MemoryConfig;
+}
+
+/** Every near-duplicate pair, computed with the store's own comparison key. */
+export function duplicatePairs(entries: MemoryEntries): DuplicatePair[] {
+	const pairs: DuplicatePair[] = [];
+	for (const scope of MEMORY_SCOPES) {
+		const kept = new Map<string, string>();
+		for (const note of entries[scope]) {
+			const key = duplicateKey(note);
+			const first = kept.get(key);
+			if (first === undefined) kept.set(key, note);
+			else pairs.push({ scope, kept: first, duplicate: note });
+		}
+	}
+	return pairs;
+}
+
+/** Derive the report from the current stores and config. */
+export function memoryHealth({ entries, sizes, trusted, config }: HealthInput): MemoryHealth {
+	const scope = (name: MemoryScope): ScopeHealth => {
+		const size = sizes[name];
+		return size === undefined ? { notes: entries[name].length } : { notes: entries[name].length, bytes: size };
+	};
+	const plan = config.inject ? injectionPlan(entries, config.maxInjectBytes) : undefined;
+	return {
+		trusted,
+		inject: config.inject,
+		cap: config.maxInjectBytes,
+		project: scope("project"),
+		global: scope("global"),
+		...(plan ? { injection: { bytes: Buffer.byteLength(plan.lines.join("\n"), "utf-8"), omitted: plan.omitted } } : {}),
+		duplicates: duplicatePairs(entries),
+	};
+}
+
+function row(label: string, text: string): string {
+	return `  ${label.padEnd(LABEL_WIDTH)}${text}`;
+}
+
+/** `3 notes · 412 B`, or the reason a store was not read. */
+function scopeText(health: MemoryHealth, name: MemoryScope): string {
+	const scope = health[name];
+	if (name === "project" && !health.trusted) return "unavailable (untrusted project)";
+	const notes = `${scope.notes} note${scope.notes === 1 ? "" : "s"}`;
+	if (scope.bytes === undefined) return scope.notes === 0 ? notes : `${notes} · size unknown`;
+	return `${notes} · ${scope.bytes} B`;
+}
+
+function injectionText(health: MemoryHealth): string {
+	if (!health.inject) return "off (memory.inject is false)";
+	if (!health.injection) return "nothing to inject";
+	const { bytes, omitted } = health.injection;
+	const missing = omitted.project + omitted.global;
+	if (missing === 0) return `${bytes} B of ${health.cap} B · all notes fit`;
+	const scopes = MEMORY_SCOPES.filter((name) => omitted[name] > 0).map((name) => `${name} ${omitted[name]}`);
+	return `${bytes} B of ${health.cap} B · ${missing} omitted (${scopes.join(", ")})`;
+}
+
+function pairLine(pair: DuplicatePair): string {
+	const kept = clip(pair.kept, PAIR_NOTE_WIDTH);
+	const duplicate = clip(pair.duplicate, PAIR_NOTE_WIDTH);
+	return `    ${pair.scope}  "${kept}" ≈ "${duplicate}"`;
+}
+
+/** The `/memory doctor` notice: plain text, one row per fact. */
+export function formatHealth(health: MemoryHealth): string {
+	const count = health.duplicates.length;
+	const duplicates = count === 0 ? "none" : `${count} pair${count === 1 ? "" : "s"} (merge with m in /memory)`;
+	return [
+		"Memory health",
+		row("project", scopeText(health, "project")),
+		row("global", scopeText(health, "global")),
+		row("injection", injectionText(health)),
+		row("duplicates", duplicates),
+		...health.duplicates.map(pairLine),
+	].join("\n");
+}

package/extensions/memory/format.ts

@@ -104,13 +104,21 @@ export function formatNotice(entries: MemoryEntries): string {
 }
 
 /**
- * The hidden `[MEMORY]` context body, or `undefined` when nothing is stored.
+ * The hidden `[MEMORY]` context body split into its lines, plus what did not fit.
  *
  * Sections are emitted project-then-global. When the notes do not fit under
  * `maxBytes`, the remainder is replaced by one `(+N more)` tail so the model
- * knows to call the tool for the rest.
+ * knows to call the tool for the rest. `omitted` says which store overflowed, for
+ * the health report; `buildInjection` only needs the lines.
  */
-export function buildInjection(entries: MemoryEntries, maxBytes: number): string | undefined {
+export interface InjectionPlan {
+	lines: string[];
+	/** Notes that did not fit, per scope. */
+	omitted: Record<MemoryScope, number>;
+}
+
+/** Plan the injected body, or `undefined` when nothing is stored. */
+export function injectionPlan(entries: MemoryEntries, maxBytes: number): InjectionPlan | undefined {
 	const sections: Array<[MemoryScope, string[]]> = [];
 	if (entries.project.length > 0) sections.push(["project", entries.project]);
 	if (entries.global.length > 0) sections.push(["global", entries.global]);
@@ -119,7 +127,7 @@ export function buildInjection(entries: MemoryEntries, maxBytes: number): string
 	const lines = [MEMORY_CONTEXT_MARKER, INTRO];
 	let used = lines.reduce((total, line) => total + bytes(line) + 1, 0);
 	const limit = Math.max(0, maxBytes - TAIL_RESERVE);
-	let omitted = 0;
+	const omitted: Record<MemoryScope, number> = { project: 0, global: 0 };
 
 	for (const [scope, list] of sections) {
 		const header = `${scope}:`;
@@ -127,7 +135,7 @@ export function buildInjection(entries: MemoryEntries, maxBytes: number): string
 		for (const entry of list) {
 			const line = `- ${entry}`;
 			if (used + bytes(header) + 1 + bytes(line) + 1 > limit) {
-				omitted += 1;
+				omitted[scope] += 1;
 				continue;
 			}
 			rendered.push(line);
@@ -138,6 +146,15 @@ export function buildInjection(entries: MemoryEntries, maxBytes: number): string
 			used += bytes(header) + 1;
 		}
 	}
-	if (omitted > 0) lines.push(`- (+${omitted} more; use the memory tool)`);
-	return lines.join("\n");
+	const missing = omitted.project + omitted.global;
+	if (missing > 0) lines.push(`- (+${missing} more; use the memory tool)`);
+	return { lines, omitted };
+}
+
+/**
+ * The hidden `[MEMORY]` context body, or `undefined` when nothing is stored.
+ * Bounded by `maxBytes`, with one tail naming what did not fit.
+ */
+export function buildInjection(entries: MemoryEntries, maxBytes: number): string | undefined {
+	return injectionPlan(entries, maxBytes)?.lines.join("\n");
 }

package/extensions/memory/runtime.ts

@@ -15,6 +15,7 @@ import {
 	applyAdd,
 	applyClear,
 	applyForget,
+	applyMerge,
 	applyUpdate,
 	memoryFileStamp,
 	mutateMemoryFile,
@@ -40,6 +41,13 @@ interface AddResult {
 	existing?: string;
 }
 
+/** Outcome of a scope move: whether the source lost the note, and a target match. */
+export interface MoveResult {
+	moved: boolean;
+	/** The note the target store already had, when it matched as a near-duplicate. */
+	existing?: string;
+}
+
 export interface MemoryRuntime {
 	/** Resolve paths and load notes for a session; returns a warning message, if any. */
 	load(cwd: string, trusted: boolean): Promise<string | undefined>;
@@ -61,6 +69,16 @@ export interface MemoryRuntime {
 	update(scope: MemoryScope, from: string, to: string): Promise<boolean>;
 	forget(scope: MemoryScope, entry: string): Promise<boolean>;
 	clear(scope: MemoryScope): Promise<boolean>;
+	/** File size of each store in bytes; `undefined` when it was not read. */
+	sizes(): Record<MemoryScope, number | undefined>;
+	/** Merge two notes in `scope` into one, in a single write. */
+	merge(scope: MemoryScope, first: string, second: string, merged: string): Promise<boolean>;
+	/**
+	 * Move a note from one scope to the other: written to the target first, then
+	 * removed from the source, so a failure between the two leaves a duplicate
+	 * rather than losing the note.
+	 */
+	move(from: MemoryScope, to: MemoryScope, entry: string): Promise<MoveResult>;
 	/** Drop cached state on shutdown. */
 	reset(): void;
 }
@@ -150,6 +168,14 @@ export function createMemoryRuntime(pi: Pick<ExtensionAPI, "exec">): MemoryRunti
 		},
 		config: () => config,
 		paths: () => paths,
+		sizes: () => {
+			// A store we may not read reports no size, the same way `refresh` refuses
+			// to cache a stamp for it.
+			return {
+				project: trusted ? stampOf("project")?.size : undefined,
+				global: stampOf("global")?.size,
+			};
+		},
 		trusted: () => trusted,
 		entries: () => {
 			refresh();
@@ -188,6 +214,29 @@ export function createMemoryRuntime(pi: Pick<ExtensionAPI, "exec">): MemoryRunti
 			commit(scope, result.entries);
 			return result.changed;
 		},
+		async merge(scope, first, second, merged) {
+			requireTrusted(scope);
+			const result = await mutateMemoryFile(pathFor(scope), (content) => applyMerge(content, first, second, merged));
+			commit(scope, result.entries);
+			return result.changed;
+		},
+		async move(from, to, entry) {
+			if (from === to) throw new Error(`The note is already in ${scopeLabel(from)} memory.`);
+			// Refuse before any write: an untrusted target, or a note that is not in the
+			// source, must leave both stores exactly as they were.
+			requireTrusted(to);
+			// `entries()` refreshes both stores from disk first, so the check is against
+			// what is on disk now, not the cache a previous call left behind.
+			if (!this.entries()[from].includes(entry)) {
+				throw new Error(`No ${scopeLabel(from)} memory note matches "${entry}".`);
+			}
+			// Target first: the one failure possible across two files then leaves the note
+			// in both scopes, where `/memory doctor` reports it and `m` merges it, instead
+			// of deleting the only copy.
+			const added = await this.add(to, entry);
+			const moved = await this.forget(from, entry);
+			return added.existing === undefined ? { moved } : { moved, existing: added.existing };
+		},
 		reset: () => {
 			paths = undefined;
 			config = DEFAULT_MEMORY_CONFIG;

package/extensions/memory/store.ts

@@ -180,6 +180,37 @@ export function applyUpdate(content: string, from: string, to: string): FileChan
 	return changed ? { content: lines.join("\n"), changed: true } : { content, changed: false };
 }
 
+/**
+ * Merge two notes into one: replace `first` in place with `merged` and drop
+ * `second`, so the pair becomes a single bullet where the first one stood. One
+ * transform, so the caller's write is atomic; a missing note or two identical
+ * names changes nothing.
+ */
+export function applyMerge(content: string, first: string, second: string, merged: string): FileChange {
+	if (first === second) return { content, changed: false };
+	const lines = content.split(/\r?\n/);
+	const notes = lines.map((line) => {
+		const match = BULLET_PARTS.exec(line);
+		return match ? sanitizeLine(match[2]) : undefined;
+	});
+	if (!notes.includes(first) || !notes.includes(second)) return { content, changed: false };
+
+	let changed = false;
+	const out: string[] = [];
+	for (const line of lines) {
+		const match = BULLET_PARTS.exec(line);
+		if (match && sanitizeLine(match[2]) === first) {
+			out.push(`${match[1]}${merged}${match[3]}`);
+			changed = true;
+			continue;
+		}
+		if (match && sanitizeLine(match[2]) === second) continue;
+		out.push(line);
+	}
+
+	return changed ? { content: endWithNewline(out.join("\n")), changed: true } : { content, changed: false };
+}
+
 /** Remove every note, keeping the header and any prose. */
 export function applyClear(content: string): FileChange {
 	let changed = false;

package/extensions/memory/tui.ts

@@ -7,6 +7,12 @@
  * without the component owning any authoritative state. Navigation and scroll
  * math come from `lib/tui/cursor.ts` and the screen chrome from `lib/tui/chrome.ts`;
  * the inline note editor is the shared `Editor` from `@earendil-works/pi-tui`.
+ *
+ * `m` marks one note as a merge source and `m` on a second note in the same
+ * scope opens the editor, pre-filled with both notes so the user writes the
+ * merged wording. The merge is one write: the store replaces the first note and
+ * drops the second. `p` moves the focused note to the other scope, which is two
+ * writes ordered target-first so a failure leaves a duplicate, never a loss.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
@@ -53,6 +59,10 @@ export interface MemoryPickerCallbacks {
 	add(scope: MemoryScope, text: string): Promise<{ changed: boolean; existing?: string }>;
 	update(scope: MemoryScope, from: string, to: string): Promise<boolean>;
 	forget(scope: MemoryScope, entry: string): Promise<boolean>;
+	/** Merge two notes in `scope` into one, in a single write. */
+	merge(scope: MemoryScope, first: string, second: string, merged: string): Promise<boolean>;
+	/** Move a note to the other scope: written there first, then removed here. */
+	move(from: MemoryScope, to: MemoryScope, entry: string): Promise<{ moved: boolean; existing?: string }>;
 }
 
 /** One note in the flat, filtered list. */
@@ -72,11 +82,15 @@ export class MemoryPickerComponent implements Component {
 	private readonly editor: Editor;
 
 	private filter: MemoryFilter = "all";
-	private mode: "list" | "edit" | "add" = "list";
+	private mode: "list" | "edit" | "add" | "merge" = "list";
 	/** Scope the inline editor writes to. */
 	private editorScope: MemoryScope = "project";
 	/** Note being edited, or undefined while adding. */
 	private editing: Note | undefined;
+	/** The two notes a merge editor will combine. */
+	private mergePair: { first: Note; second: Note } | undefined;
+	/** The note marked with `m`, awaiting a second `m` to merge into it. */
+	private mergeSource: Note | undefined;
 	/** Note awaiting a y/N forget confirmation. */
 	private confirm: Note | undefined;
 	/** Transient feedback shown in place of the hint. */
@@ -161,15 +175,55 @@ export class MemoryPickerComponent implements Component {
 		}
 		this.mode = "edit";
 		this.editing = note;
+		this.mergePair = undefined;
 		this.editorScope = note.scope;
 		this.editor.setText(note.text);
 		this.syncEditorFocus();
 		this.requestRender();
 	}
 
+	/**
+	 * `m`: mark the focused note, unmark it, or open the merge editor for a marked
+	 * pair. The mark survives navigation so the second note can be found.
+	 */
+	private toggleMerge(note: Note | undefined): void {
+		if (!note) return;
+		const source = this.mergeSource;
+		if (source && noteKey(source) === noteKey(note)) {
+			this.mergeSource = undefined;
+			this.requestRender();
+			return;
+		}
+		if (source) {
+			this.startMerge(source, note);
+			return;
+		}
+		this.mergeSource = note;
+		this.notice = undefined;
+		this.requestRender();
+	}
+
+	/** Open the editor for a marked pair, pre-filled with both notes to rewrite. */
+	private startMerge(first: Note, second: Note): void {
+		if (first.scope !== second.scope) {
+			this.notice = "A merge combines two notes in the same scope.";
+			this.requestRender();
+			return;
+		}
+		this.mode = "merge";
+		this.editing = undefined;
+		this.mergePair = { first, second };
+		this.editorScope = first.scope;
+		// The user writes the merged wording; the seed only saves retyping both notes.
+		this.editor.setText(`${first.text}; ${second.text}`.slice(0, MAX_NOTE_CHARS));
+		this.syncEditorFocus();
+		this.requestRender();
+	}
+
 	private startAdd(): void {
 		this.mode = "add";
 		this.editing = undefined;
+		this.mergePair = undefined;
 		this.editorScope = this.activeScope();
 		this.editor.setText("");
 		this.syncEditorFocus();
@@ -179,6 +233,8 @@ export class MemoryPickerComponent implements Component {
 	private cancelEditor(): void {
 		this.mode = "list";
 		this.editing = undefined;
+		this.mergePair = undefined;
+		this.mergeSource = undefined;
 		this.syncEditorFocus();
 		this.notice = undefined;
 		this.requestRender();
@@ -188,8 +244,11 @@ export class MemoryPickerComponent implements Component {
 		const text = sanitizeLine(value).trim();
 		const editing = this.editing;
 		const scope = this.editorScope;
+		const pair = this.mergePair;
 		this.mode = "list";
 		this.editing = undefined;
+		this.mergePair = undefined;
+		this.mergeSource = undefined;
 		this.syncEditorFocus();
 
 		if (text.length === 0) {
@@ -204,6 +263,12 @@ export class MemoryPickerComponent implements Component {
 		}
 
 		this.run(async () => {
+			if (pair) {
+				await this.callbacks.merge(pair.first.scope, pair.first.text, pair.second.text, text);
+				this.notice = `Merged 2 ${scopeLabel(pair.first.scope)} notes.`;
+				this.selectedKey = noteKey({ scope: pair.first.scope, text });
+				return;
+			}
 			if (editing) {
 				if (text === editing.text) {
 					this.notice = "Unchanged.";
@@ -236,6 +301,30 @@ export class MemoryPickerComponent implements Component {
 		});
 	}
 
+	/** `p`: move the focused note to the other scope, target first. */
+	private moveNote(note: Note | undefined): void {
+		if (!note) return;
+		const to: MemoryScope = note.scope === "project" ? "global" : "project";
+		if (to === "project" && !this.callbacks.trusted()) {
+			this.notice = "Project memory is unavailable for an untrusted project.";
+			this.requestRender();
+			return;
+		}
+		const from = note.scope;
+		const text = note.text;
+		this.run(async () => {
+			const result = await this.callbacks.move(from, to, text);
+			if (!result.moved) {
+				this.notice = `Added to ${scopeLabel(to)}; the ${scopeLabel(from)} note was already gone.`;
+			} else if (result.existing !== undefined) {
+				this.notice = `Moved to ${scopeLabel(to)} (it was already there).`;
+			} else {
+				this.notice = `Moved to ${scopeLabel(to)}.`;
+			}
+			this.selectedKey = noteKey({ scope: to, text });
+		});
+	}
+
 	private reload(): void {
 		this.notice = this.callbacks.refresh() ? "Reloaded memory." : "Memory is already up to date.";
 		this.requestRender();
@@ -248,11 +337,21 @@ export class MemoryPickerComponent implements Component {
 			.catch((error: unknown) => {
 				this.notice = `Memory not saved: ${messageOf(error)}`;
 			})
-			.then(() => this.requestRender());
+			.then(() => {
+				this.dropStaleMergeSource();
+				this.requestRender();
+			});
+	}
+
+	/** A merge source that a mutation removed is no longer a valid target. */
+	private dropStaleMergeSource(): void {
+		const source = this.mergeSource;
+		if (!source) return;
+		if (!this.notes().some((note) => noteKey(note) === noteKey(source))) this.mergeSource = undefined;
 	}
 
 	private syncEditorFocus(): void {
-		this.editor.focused = this.componentFocused && (this.mode === "edit" || this.mode === "add");
+		this.editor.focused = this.componentFocused && this.mode !== "list";
 	}
 
 	private handleConfirm(data: string): void {
@@ -270,7 +369,7 @@ export class MemoryPickerComponent implements Component {
 	}
 
 	handleInput(data: string): void {
-		if (this.mode === "edit" || this.mode === "add") {
+		if (this.mode !== "list") {
 			if (isCloseKey(data) || matchesKey(data, Key.escape)) {
 				this.cancelEditor();
 				return;
@@ -284,6 +383,12 @@ export class MemoryPickerComponent implements Component {
 			return;
 		}
 		if (isCloseKey(data) || data === "q") {
+			// With a mark set, the first Esc cancels the merge instead of closing the screen.
+			if (this.mergeSource) {
+				this.mergeSource = undefined;
+				this.requestRender();
+				return;
+			}
 			this.onClose();
 			return;
 		}
@@ -308,6 +413,8 @@ export class MemoryPickerComponent implements Component {
 		if (matchesKey(data, Key.tab) || data === "s") this.cycleFilter();
 		else if (matchesKey(data, Key.enter) || data === "e") this.startEdit(focused);
 		else if (data === "a") this.startAdd();
+		else if (data === "m") this.toggleMerge(focused);
+		else if (data === "p") this.moveNote(focused);
 		else if (data === "d") {
 			if (!focused) return;
 			this.confirm = focused;
@@ -355,9 +462,11 @@ export class MemoryPickerComponent implements Component {
 	/** One note row: selection marker, scope tag, and the sanitized note text. */
 	private noteRow(note: Note, selected: boolean, width: number): string {
 		const tag = `${paint(this.theme, "meta", scopeLabel(note.scope))} ${paint(this.theme, "faint", "·")}`;
+		const source = this.mergeSource;
+		const marked = source !== undefined && noteKey(source) === noteKey(note);
 		return listRow(this.theme, width, {
 			selected,
-			leading: tag,
+			leading: marked ? `${tag} ${paint(this.theme, "warn", "merge")}` : tag,
 			label: sanitizeLine(note.text),
 			labelRole: selected ? "accent" : "label",
 		});
@@ -372,17 +481,20 @@ export class MemoryPickerComponent implements Component {
 	}
 
 	private renderEditor(width: number): string[] {
-		const verb = this.mode === "edit" ? "Edit" : "Add";
+		const verb = this.mode === "edit" ? "Edit" : this.mode === "merge" ? "Merge" : "Add";
 		const scope = scopeLabel(this.editorScope);
 		const pad = width > 1 ? " " : "";
+		const summary =
+			this.mode === "edit"
+				? "Editing the focused note"
+				: this.mode === "merge"
+					? `Merging 2 ${scope} notes into one`
+					: `New ${scope} note`;
 		const body: string[] = [];
 		for (const line of this.editor.render(Math.max(1, width - 2))) body.push(`${pad}${line}`);
 		return dockListFrame({
 			header: titleRule(this.theme, width, `Memory · ${verb} ${scope}`),
-			summary: clip(
-				`  ${paint(this.theme, "meta", this.mode === "edit" ? "Editing the focused note" : `New ${scope} note`)}`,
-				width,
-			),
+			summary: clip(`  ${paint(this.theme, "meta", summary)}`, width),
 			body,
 			hint: screenHint(this.theme, width, ["Enter save", "Esc cancel"]),
 		});
@@ -391,7 +503,7 @@ export class MemoryPickerComponent implements Component {
 	render(width: number): string[] {
 		const w = Math.max(1, width);
 		this.syncEditorFocus();
-		if (this.mode === "edit" || this.mode === "add") return this.renderEditor(w);
+		if (this.mode !== "list") return this.renderEditor(w);
 
 		const notes = this.notes();
 		this.cursor.visible = fitRows(this.viewportRowsSource, notes.length, CHROME, SCREEN_DEFAULT_ROWS);
@@ -411,7 +523,19 @@ export class MemoryPickerComponent implements Component {
 			? clip(`  ${paint(this.theme, "warn", this.confirmPrompt())}`, w)
 			: this.notice !== undefined
 				? clip(`  ${paint(this.theme, "meta", this.notice)}`, w)
-				: screenHint(this.theme, w, ["Esc close", "Enter/e edit", "a add", "d forget", "s/Tab scope", "↑/↓", "g/G"]);
+				: this.mergeSource
+					? screenHint(this.theme, w, ["m merge into the focused note", "Esc cancel merge", "↑/↓"])
+					: screenHint(this.theme, w, [
+							"Esc close",
+							"Enter/e edit",
+							"a add",
+							"d forget",
+							"m merge",
+							"p move",
+							"s/Tab scope",
+							"↑/↓",
+							"g/G",
+						]);
 
 		return dockListFrame({
 			header: titleRule(this.theme, w, "Memory"),