@@ -173,6 +173,10 @@ const PORTABLE_TOOLS_TOKENS_EST = Math.round(JSON.stringify(PORTABLE_TOOLS).leng
 // wires ctx.recallSessions (memory + the recall setting on), so it costs nothing otherwise. Read-only and
 // instant like use_skill — it searches the project's OWN past-session outcomes, never the file system.
 const RECALL_TOOL = { name: 'recall_sessions', description: 'Search THIS project\'s past sessions for relevant earlier work — their recorded outcomes (what was built/fixed/decided), the files they touched, and the conversations themselves. Use when the user refers to earlier work ("what did we do about refunds?", "did we already fix the webhook?") or when prior context would clearly help before you start. Returns cited past-session outcomes (with a matching transcript snippet when the match is deep in the conversation) and dates; treat them as memory — informative but possibly stale, so verify against the current code.', input_schema: { type: 'object', properties: { query: { type: 'string', description: 'keywords or a short question, e.g. "refund retries" or "MCP timeline rail"' } }, required: ['query'] } };
+// Memory the person asks for (docs/levelcode-sessions-memory.md §12). The host decides whether a note can be
+// credited to the person (sessionMemory.groundNote); the agent only proposes it, with their words.
+const REMEMBER_TOOL = { name: 'remember', description: 'Save something the user told you, so future sessions in THIS project start knowing it. Use it when the user asks you to remember something; when they correct how you work ("no, use pnpm", "don\'t mock the database") or confirm an approach that was not obvious ("yes, keep doing that"); when they state a decision or constraint (write dates as absolute dates); or when they say where something lives (a dashboard, a ticket tracker, a doc). Do NOT save what the code or git history already shows, or details of the current task. `said` MUST be the user\'s own words, copied exactly from their message — the note is credited to them only when those words are found in what they typed and the note says no more than they did; otherwise it is kept unconfirmed until they confirm it. Keep `text` short and close to their words.', input_schema: { type: 'object', properties: { kind: { type: 'string', enum: ['preference', 'project', 'reference'], description: 'preference = how the user wants you to work (corrections and confirmed approaches); project = a decision, constraint or deadline; reference = where to find something outside the code' }, text: { type: 'string', description: 'the note, one sentence, in the user\'s terms, e.g. "Use pnpm, never npm, in this repo"' }, said: { type: 'string', description: 'the user\'s exact words this note rests on, copied from their message' } }, required: ['kind', 'text', 'said'] } };
+const FORGET_TOOL = { name: 'forget', description: 'Remove a note or fact from this project\'s memory when the user asks you to forget it or says it is no longer true. `said` MUST be the user\'s own words asking for it, copied exactly. Removes the best match for `query` and tells you what it removed.', input_schema: { type: 'object', properties: { query: { type: 'string', description: 'words that identify the memory, e.g. "pnpm"' }, said: { type: 'string', description: 'the user\'s exact words asking you to forget it' } }, required: ['query', 'said'] } };
 
 // How much of a background command's accumulated output the sniffers re-read on each chunk. Generous
 // next to any single log line, so a url split across chunk boundaries is still found, yet small enough
@@ -736,6 +740,11 @@ async function runTool(tu, ctx) {
 				return '- ' + (a.header ? a.header + ' — ' : '') + (a.question || '') + ' → ' + sel;
 			});
 			if (res.notes) { lines.push('- Additional notes from the user: ' + res.notes); }
+			// What the person chose and wrote here is theirs: `remember` may quote it (see heard, below).
+			if (Array.isArray(ctx.heardThisRun)) {
+				for (const a of res.answers) { for (const sel of (a.selected || [])) { ctx.heardThisRun.push(String(sel)); } }
+				if (res.notes) { ctx.heardThisRun.push(String(res.notes)); }
+			}
 			return 'The user answered your questions (these are their recorded decisions — honor them and do NOT ask again):\n' + lines.join('\n') + '\n\nProceed with the work using these answers.';
 		}
 		if (tu.name === 'use_skill') {
@@ -749,6 +758,27 @@ async function runTool(tu, ctx) {
 			ctx.post({ type: 'agentTool', icon: 'sparkle', text: '🧩 using skill: ' + name });   // quiet chip — only on success (🧩 is the marker; 'sparkle' falls back cleanly)
 			return body;                                                                       // SKILL.md body → tool_result, steers the next turns
 		}
+		if (tu.name === 'remember' || tu.name === 'forget') {
+			if (!ctx.memoryNotes) { return 'ERROR: project memory is off in this session.'; }
+			// What the person typed this run: their goal and their answers to ask_user. The host checks `said` against it.
+			const heard = [String(ctx.goalText || '')].concat(Array.isArray(ctx.heardThisRun) ? ctx.heardThisRun : []).filter(Boolean);
+			const said = String(input.said || '').trim();
+			if (!said) { return 'ERROR: pass `said` — the user\'s exact words, copied from their message.'; }
+			try {
+				if (tu.name === 'remember') {
+					const text = String(input.text || '').replace(/\s+/g, ' ').trim();
+					if (!text) { return 'ERROR: pass `text` — the note, one sentence.'; }
+					const r = ctx.memoryNotes.remember({ kind: String(input.kind || 'preference'), text, said, personWords: heard }) || {};
+					ctx.post({ type: 'agentTool', icon: 'history', text: '🧠 remembered: ' + host.displaySafe(text) + (r.verified ? '' : ' (unconfirmed)') });
+					return String(r.message || 'Saved.');
+				}
+				const query = String(input.query || '').trim();
+				if (!query) { return 'ERROR: pass `query` — words that identify the memory.'; }
+				const r = ctx.memoryNotes.forget({ query, said, personWords: heard }) || {};
+				if (r.removed) { ctx.post({ type: 'agentTool', icon: 'history', text: '🧠 forgot: ' + host.displaySafe(r.removed) }); }
+				return String(r.message || 'Nothing was removed.');
+			} catch (e) { return 'ERROR: memory could not be updated.'; }
+		}
 		if (tu.name === 'recall_sessions') {
 			if (typeof ctx.recallSessions !== 'function') { return 'ERROR: session recall is not available in this session.'; }
 			const query = String(input.query || '').trim();
@@ -1004,6 +1034,8 @@ function saysDone(text) {
 }
 
 async function runAgent(ctx) {
+	// The person's own words this run beyond the goal (their ask_user answers) — what `remember` may quote.
+	if (!Array.isArray(ctx.heardThisRun)) { ctx.heardThisRun = []; }
 	// No workspace is no longer a refusal. It used to fail the whole run here, which meant a question
 	// that never needed a folder — "what does this error mean?", anything through an MCP server, a
 	// follow-up about the conversation itself — died on a guard written for the file tools. The root
@@ -1102,6 +1134,7 @@ async function runAgent(ctx) {
 	// then there is nothing to fetch, and a tool that is never needed is a standing cost for nothing.
 	const extras = [];
 	if (ctx.recallSessions) { extras.push(RECALL_TOOL); }
+	if (ctx.memoryNotes) { extras.push(REMEMBER_TOOL, FORGET_TOOL); }
 	if (rich) { extras.push(diagramTool.RENDER_DIAGRAM); if (ctx.diagramsStubbed) { extras.push(diagramTool.GET_DIAGRAM); } }
 	if (extras.length) { tools = tools.concat(extras); }
 	// Withhold what this host cannot do: no shell, no run_command, no read_command_output — and for a shell that
 
@@ -1429,7 +1429,8 @@ function enrichMemoryAsync(id) {
 	const factsOn = aiConfig().get('sessions.memory.facts', true);
 	// The active facts this session might make obsolete — passed to the same call for the §4 conflict pass.
 	let existing = [];
-	if (factsOn) { try { existing = (m.digest().facts || []).filter((f) => f.active !== false); } catch (e) { existing = []; } }
+	// A note the person asked to keep is not the summarizer's to replace: only they change it (remember, forget, the panel).
+	if (factsOn) { try { existing = sessionMemory.supersedableFacts(m.digest().facts); } catch (e) { existing = []; } }
 	Promise.resolve(summarizeSessionOutcome(messages, existing)).then((res) => {
 		const r = res || {};
 		let changed = false;
@@ -1448,6 +1449,9 @@ function enrichMemoryAsync(id) {
 // truth, which is the opposite of what decay is for.
 const FACT_STATE_NOTE = {
 	confirmed: '',                                             // the user said yes; it needs no hedge
+	yours: ' [the user asked you to keep this]',
+	// A note the agent saved that could not be credited to the user's words: kept, listed, not in effect.
+	'unconfirmed-note': ' [a note the user has not confirmed — do not act on it]',
 	observed: ' [inferred from repeated sessions — unconfirmed]',
 	inferred: ' [seen once, unconfirmed — weak evidence]',
 	superseded: ' [SUPERSEDED — later work replaced this]',
@@ -1471,7 +1475,8 @@ function formatRecall(hits, query, facts) {
 				const when = f.at ? String(f.at).slice(0, 10) : 'undated';
 				const note = FACT_STATE_NOTE[f.state] != null ? FACT_STATE_NOTE[f.state] : '';
 				const by = f.state === 'superseded' && f.supersededBy ? '\n    ↳ replaced by: ' + f.supersededBy : '';
-				return '- ' + f.text + note + ' (' + when + ')' + by;
+				const said = f.state === 'yours' && f.said ? '\n    ↳ they said: "' + f.said + '"' : '';
+				return '- ' + f.text + note + ' (' + when + ')' + by + said;
 			}).join('\n');
 	}
 	if (arr.length) {
@@ -1487,6 +1492,53 @@ function formatRecall(hits, query, facts) {
 	}
 	return out;
 }
+// The remember tool's host half. The agent proposes a note with the person's words; THIS decides whether it
+// is theirs (sessionMemory.groundNote — deterministic, no model), keeps it either way, and says which.
+function rememberNoteTool(note) {
+	const m = sessionsManager();
+	if (!m) { return { verified: false, message: 'No project memory is available in this workspace (open a folder).' }; }
+	const n = note || {};
+	const kind = sessionMemory.NOTE_KINDS.includes(n.kind) ? n.kind : 'preference';
+	const g = sessionMemory.groundNote({ text: n.text, said: n.said, personWords: n.personWords });
+	// The note's provenance is this conversation's session; a first run has none on disk yet, so make it now
+	// (recordTurn reuses it when the turn ends).
+	let sourceId = null;
+	try { const live = m.ensure(); sourceId = live ? live.id : null; } catch (e) { sourceId = null; }
+	const ok = m.rememberNote(sourceId, { kind, text: n.text, said: n.said, verified: g.verified });
+	dbg('sessions.memory.remember', { kind, verified: g.verified, reason: g.reason, grounded: Math.round(g.grounded * 100) / 100, ok });
+	if (!ok) { return { verified: false, message: 'ERROR: the note could not be saved.' }; }
+	refreshMemoryViews();
+	if (g.verified) {
+		return { verified: true, message: 'Remembered as the user\'s ' + kind + ' note. It is in this project\'s memory now and in every future session. No need to repeat it back at length.' };
+	}
+	const why = g.reason === 'not-said' ? 'the quoted words were not found in what the user typed this run'
+		: g.reason === 'adds-to-what-was-said' ? 'the note says more than the quoted words do'
+			: 'the quoted words are too short to credit';
+	return { verified: false, message: 'Saved as UNCONFIRMED (' + why + '). It is listed in the Memory tab and has no effect until the user confirms it there. If the user did ask for this, quote their exact words in `said` and keep the note to what they said.' };
+}
+// The forget tool's host half: removes the best-matching note or fact, when the person's own words ask for it.
+function forgetNoteTool(req) {
+	const m = sessionsManager();
+	if (!m) { return { removed: '', message: 'No project memory is available in this workspace.' }; }
+	const r = req || {};
+	const asked = sessionMemory.groundNote({ text: r.said, said: r.said, personWords: r.personWords });
+	if (!asked.verified) {
+		return { removed: '', message: 'Not removed: the quoted words were not found in what the user typed this run. Tell the user they can remove it from the Memory tab.' };
+	}
+	const hit = (m.recallFacts(String(r.query || ''), { limit: 1 }) || [])[0];
+	if (!hit) { return { removed: '', message: 'Nothing in this project\'s memory matches "' + String(r.query || '') + '".' }; }
+	m.factAction(hit.key, 'remove');
+	dbg('sessions.memory.forget', { key: hit.key, state: hit.state });
+	refreshMemoryViews();
+	return { removed: hit.text, message: 'Removed from memory: "' + hit.text + '". Tell the user what you removed, in case it was the wrong one (saying it again with remember brings it back).' };
+}
+// After memory changes from the chat: the Memory tab's list and the welcome-back strip.
+function refreshMemoryViews() {
+	const m = sessionsManager();
+	if (m && sessionsWebview) { try { sessionsWebview.postMessage({ type: 'memoryList', items: m.memoryItems(), facts: m.factsList() }); } catch (e) { /* view closed */ } }
+	postMemoryDigest();
+}
+
 // The recall_sessions tool callback handed to the agent — only when memory + the recall setting are on.
 function recallSessionsTool(query) {
 	const m = sessionsManager();
@@ -1538,6 +1590,47 @@ async function handleFactAction(action, key, webview) {
 // (§4.9): Done archives (reversible, never deletes), Delete soft-trashes, Rename retitles, Pin toggles.
 // Done/Delete offer an Undo (restore) so an accidental click is recoverable. Best-effort — a History action
 // must never throw into the UI.
+/**
+ * Search Sessions… — every session not in the trash, by its title and what was said in it, newest first,
+ * each with the line it matched. A quick pick rather than a field in History: History stays the short list
+ * of recent work it was made to be (77d4f13), and this reaches the sessions that list no longer shows.
+ */
+function searchSessionsQuickPick() {
+	const m = sessionsManager();
+	if (!m) { vscode.window.showInformationMessage('Open a folder to search its sessions.'); return; }
+	const qp = vscode.window.createQuickPick();
+	qp.placeholder = 'Search this project\'s sessions — titles and what was said';
+	qp.matchOnDescription = false; qp.matchOnDetail = false;
+	let timer = null;
+	const when = (iso) => { const t = Date.parse(iso || ''); return Number.isFinite(t) ? new Date(t).toLocaleDateString(undefined, { month: 'short', day: 'numeric' }) : ''; };
+	const run = (q) => {
+		let results = [];
+		try { results = m.search(q, { limit: 40 }); } catch (e) { results = []; }
+		dbg('sessions.search', { chars: q.length, results: results.length });
+		// alwaysShow: these items are already the matches; the quick pick's own label filter would drop the
+		// ones that matched inside the conversation rather than in the title.
+		qp.items = results.length
+			? results.map((r) => ({ label: r.title || 'Untitled', description: [when(r.updatedAt), r.lifecycle === 'archived' ? 'done' : '', r.pinned ? 'pinned' : ''].filter(Boolean).join(' · '), detail: r.snippet || '', alwaysShow: true, id: r.id }))
+			: [{ label: 'No session mentions “' + q + '”', alwaysShow: true, id: '' }];
+		qp.busy = false;
+	};
+	qp.onDidChangeValue((v) => {
+		clearTimeout(timer);
+		const q = String(v || '').trim();
+		if (q.length < 2) { qp.items = []; qp.busy = false; return; }
+		qp.busy = true;
+		timer = setTimeout(() => run(q), 200);
+	});
+	qp.onDidAccept(async () => {
+		const pick = qp.selectedItems[0];
+		if (!pick || !pick.id) { return; }
+		qp.hide();
+		await handleSessionAction('resume', pick.id);
+	});
+	qp.onDidHide(() => { clearTimeout(timer); qp.dispose(); });
+	qp.show();
+}
+
 async function handleSessionAction(action, id) {
 	const m = sessionsManager();
 	if (!m || !id) { return; }
@@ -2299,6 +2392,10 @@ async function agentFlow(text, imageBlocks) {
 			diagramsStubbed: diagramsStubbed,
 			// The recall_sessions tool: search past-session outcomes on demand. Off → the tool isn't offered at all.
 			recallSessions: (aiConfig().get('sessions.memory.enabled', true) && aiConfig().get('sessions.memory.recallTool', true)) ? recallSessionsTool : undefined,
+			// Memory the person asks for: the remember/forget tools, and the goal as typed, which is what a
+			// note's quoted words are checked against (docs/levelcode-sessions-memory.md §12).
+			goalText: String(text || ''),
+			memoryNotes: (aiConfig().get('sessions.memory.enabled', true) && aiConfig().get('sessions.memory.notes', true)) ? { remember: rememberNoteTool, forget: forgetNoteTool } : undefined,
 
 			// MCP (docs/MCP.md S3). Config is read HERE and handed in, like verify/commandTimeout, so
 			// agent.js keeps doing the loading + connecting + naming without reaching for the editor API.
@@ -3682,6 +3779,7 @@ function activate(context) {
 		// Both land on the same panel, each on its own tab, so a button says exactly where it goes.
 		vscode.commands.registerCommand('levelcode.ai.sessions', () => revealSessions('history')),
 		vscode.commands.registerCommand('levelcode.ai.memory', () => revealSessions('memory')),
+		vscode.commands.registerCommand('levelcode.ai.searchSessions', () => searchSessionsQuickPick()),
 		// Reachable from an image tab's title bar: dropping a file onto the workbench opens it there,
 		// so that is where someone already is when they realise the drop did not attach it.
 		// Called by the CORE patch in editorDropTarget.ts when an image is dropped onto the chat