@@ -177,7 +177,7 @@ const RECALL_TOOL = { name: 'recall_sessions', description: 'Search THIS project
 // 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 uses only those words, in their order, keeping every not/never; 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'] } };
+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, and those words must name what to forget. Removes the best match for `query` only when the user\'s words ask for it to go and name it, 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
 
@@ -1557,14 +1557,25 @@ 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) {
+	const said = { said: r.said, personWords: r.personWords };
+	// Typed this run? Checked before the lookup, so a quote nobody typed learns nothing about what is stored.
+	const typed = sessionMemory.asksToForget(Object.assign({ target: { text: '' } }, said));
+	if (typed.reason === 'not-said' || typed.reason === 'too-short') {
 		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 });
+	// The person's words must ask for it to go AND name it: the model's query picked it, their words decide.
+	// A credited note's own quote can name it; an uncredited one's quote was never checked, so it cannot.
+	const asked = sessionMemory.asksToForget(Object.assign({ target: { text: hit.text, said: hit.state === 'yours' ? hit.said : '' } }, said));
+	dbg('sessions.memory.forget', { key: hit.key, state: hit.state, asked: asked.reason });
+	if (!asked.ok) {
+		const why = asked.reason === 'no-request' ? 'the quoted words do not ask to forget anything' : 'the quoted words do not name this memory';
+		return { removed: '', message: 'Not removed (' + why + '). The closest memory is "' + hit.text + '". If the user wants it gone, quote the words where they asked for it, or tell them they can use Forget on it in the Memory tab.' };
+	}
+	if (!m.factAction(hit.key, 'remove')) {
+		return { removed: '', message: 'ERROR: "' + hit.text + '" could not be removed: the memory store refused the write, so it is still in effect. Tell the user.' };
+	}
 	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).' };
 }
 
@@ -304,6 +304,46 @@ function groundNote(o) {
 	return { verified: true, reason: 'ok', grounded };
 }
 
+// What asks for a memory to go. "forget" on its own (not "don't forget"); "remove", "delete" and the like
+// only beside a word that names a memory, because "remove the pnpm lockfile" is about a file; or a phrase
+// that says the memory stopped being true.
+const FORGET_ASKS = [
+	/(?:^|[^a-z])(?:forget|unremember)\b/,
+	/\bstop remembering\b/,
+	/\b(?:remove|delete|drop|erase|clear|discard|scrap)\b.{0,40}\b(?:memory|memories|note|notes|rule|rules|preference|preferences)\b/,
+	/\b(?:memory|memories|note|notes|rule|rules|preference|preferences)\b.{0,40}\b(?:remove|delete|drop|erase|clear|discard|scrap)\b/,
+	/\b(?:no longer|not|isnt|is not|arent|are not) (?:true|the case|valid|right)\b/,
+	/\b(?:is|are|its|thats|it is|that is) (?:outdated|obsolete|stale|wrong)\b/,
+];
+const FORGET_NOT = /\b(?:dont|do not|never|not|didnt|did not)\s+forget\b/;
+// Words too general to say WHICH memory: every other note has them too.
+const FORGET_GENERIC = new Set(['use', 'using', 'always', 'prefer', 'keep', 'make', 'run', 'add', 'forget', 'unremember', 'remember',
+	'remembering', 'remove', 'delete', 'drop', 'erase', 'clear', 'discard', 'scrap', 'memory', 'memories', 'note', 'notes', 'rule',
+	'rules', 'preference', 'preferences', 'true', 'valid', 'right', 'case', 'outdated', 'obsolete', 'stale', 'wrong', 'longer']);
+
+/**
+ * May `forget` remove this memory? Pure. Three things, all checked here and none taken from the model:
+ *   1. `said` is in what the person typed this run (as for a note);
+ *   2. `said` asks for something to be forgotten (not "don't forget");
+ *   3. `said` names this memory: a word of its text, or of the words it was credited on, other than the
+ *      general ones every memory shares.
+ * The model picks the memory from its own `query`; 3 is what ties the person's request to that pick.
+ * @param {{said:string, personWords:string[], target:{text:string, said?:string}}} o
+ * @returns {{ok:boolean, reason:string}}
+ */
+function asksToForget(o) {
+	const said = squash(o && o.said);
+	const pool = (Array.isArray(o && o.personWords) ? o.personWords : []).map(squash).filter(Boolean);
+	if (said.length < 8 || words(said).length < 2) { return { ok: false, reason: 'too-short' }; }
+	if (!pool.some((p) => p.indexOf(said) >= 0)) { return { ok: false, reason: 'not-said' }; }
+	if (FORGET_NOT.test(said) || !FORGET_ASKS.some((re) => re.test(said))) { return { ok: false, reason: 'no-request' }; }
+	const asked = contentStream(o.said).map((x) => x.w).filter((w) => !FORGET_GENERIC.has(w));
+	const t = (o && o.target) || {};
+	const named = contentStream(String(t.text || '') + '. ' + String(t.said || '')).map((x) => x.w).filter((w) => !FORGET_GENERIC.has(w) && !SCOPE_WORDS.has(w));
+	if (!named.some((w) => asked.some((a) => sameWord(w, a)))) { return { ok: false, reason: 'not-this-memory' }; }
+	return { ok: true, reason: 'ok' };
+}
+
 /**
  * One observation of a candidate fact (append-only), sourced + dated — the raw material foldFacts counts.
  * `note` marks it as one the person asked to keep (see groundNote): its kind, their words, and whether the
@@ -650,6 +690,6 @@ module.exports = {
 	outcomeEntry, appendJournal, readJournal, latestBySession, writeMemoryMd,
 	normalizeFactKey, factObservation, factControl, appendFacts, readFacts, foldFacts, activeFacts,
 	redactSecrets, looksLikeInstruction,
-	NOTE_KINDS, groundNote, ageLabel, DIGEST_MAX_NOTES, DIGEST_MAX_FACTS, supersedableFacts,
+	NOTE_KINDS, groundNote, asksToForget, ageLabel, DIGEST_MAX_NOTES, DIGEST_MAX_FACTS, supersedableFacts,
 	queryTerms, snippetFor, recallRank, recallFacts, buildDigest, digestSummary, digestMarkdown
 };
@@ -74,6 +74,25 @@ test('GROUND: a quote too short to mean anything is not enough', () => {
 	assert.deepStrictEqual(mem.groundNote({ text: 'ok then', said: 'ok then', personWords: ['ok then'] }).reason, 'too-short');
 });
 
+// ---- asksToForget: may forget remove this memory? --------------------------------------------------
+const pnpmNote = { text: 'Use pnpm, never npm, in this repo', said: 'always use pnpm, never npm' };
+const forgetOk = (said, target, pw) => mem.asksToForget({ said, personWords: pw || ['so: ' + said + '.'], target: target || pnpmNote });
+test('FORGET: the person\'s words must ask for something to go — a typed goal is not a removal request', () => {
+	// The reviewer's case: the goal is real and quotable, and says nothing about forgetting.
+	assert.deepStrictEqual(forgetOk('fix the failing date test', pnpmNote, typed), { ok: false, reason: 'no-request' });
+	assert.strictEqual(forgetOk('don\'t forget pnpm is required').reason, 'no-request', '"don\'t forget" keeps it');
+	assert.strictEqual(forgetOk('remove the pnpm lockfile').reason, 'no-request', 'removing a file is not removing a memory');
+	assert.strictEqual(forgetOk('forget the pnpm rule', pnpmNote, ['something else']).reason, 'not-said');
+});
+test('FORGET: …and name the memory the model picked', () => {
+	assert.strictEqual(forgetOk('forget about it, just fix the test').reason, 'not-this-memory');
+	assert.strictEqual(forgetOk('forget the date test', { text: 'Never mock the database' }).reason, 'not-this-memory');
+	for (const said of ['forget the pnpm rule', 'remove the pnpm rule from memory', 'the npm note is no longer true', 'that pnpm preference is outdated']) {
+		assert.strictEqual(forgetOk(said).ok, true, said);
+	}
+	assert.strictEqual(forgetOk('forget the rebase rule', { text: 'Always rebase before merging' }).ok, true);
+});
+
 // ---- the fold: what a note does ------------------------------------------------------------------
 const note = (text, said, verified, at, src) => mem.factObservation(text, src || 's1', at || iso(DAY / 2), { kind: 'preference', said, verified });
 test('FOLD: a credited note is active at once — even phrased as an order — and marked as theirs', () => {
 
@@ -195,6 +195,27 @@ const host = new Function('env', [
 		assert.match(none.message, /Nothing in this project's memory matches/);
 	});
 
+	await testAsync('HOST: a quoted goal cannot remove a memory it does not ask about (the reviewer\'s case)', async () => {
+		host.rememberNoteTool({ kind: 'preference', text: 'Use pnpm, never npm, in this repo', said: 'always use pnpm, never npm', personWords: typed });
+		const r = host.forgetNoteTool({ query: 'pnpm', said: 'fix the failing date test', personWords: typed });
+		assert.strictEqual(r.removed, '');
+		assert.match(r.message, /do not ask to forget anything/);
+		const r2 = host.forgetNoteTool({ query: 'pnpm', said: 'forget about it, just fix the test', personWords: ['forget about it, just fix the test'] });
+		assert.strictEqual(r2.removed, '');
+		assert.match(r2.message, /do not name this memory.*Use pnpm, never npm, in this repo/);
+		assert.ok(sessions.factsList().some((x) => x.text === 'Use pnpm, never npm, in this repo' && x.active), 'the preference is gone');
+	});
+	await testAsync('HOST: a removal the store refuses is reported as not done, and the memory stays', async () => {
+		ui.manager = Object.assign({}, sessions, { factAction: () => false });
+		const r = host.forgetNoteTool({ query: 'pnpm', said: 'forget the pnpm rule', personWords: ['forget the pnpm rule'] });
+		ui.manager = undefined;
+		assert.strictEqual(r.removed, '', 'reported as removed');
+		assert.match(r.message, /could not be removed.*still in effect/);
+		assert.ok(sessions.factsList().some((x) => x.text === 'Use pnpm, never npm, in this repo' && x.active));
+		const agent = await run('forget the pnpm rule', [call('forget', { query: 'pnpm', said: 'forget the pnpm rule' })], { memoryNotes: { remember: () => ({}), forget: () => r } });
+		assert.ok(!agent.posted.some((m) => m.type === 'agentTool' && /forgot/.test(m.text)), 'a "forgot" chip for a memory that is still there');
+	});
+
 	// ---- Search Sessions -------------------------------------------------------------------------------
 	sessions.recordTurn([{ role: 'user', content: 'Fix the refund retry bug' }, { role: 'assistant', content: 'Retries use an idempotency key in Redis.' }], 'm');
 	const refundId = sessions.liveId(); sessions.seal('done');