@@ -73,7 +73,7 @@ const TOOLS_TOKENS_EST = Math.round(JSON.stringify(TOOLS).length / 4);
 // Cross-session memory recall (docs/levelcode-sessions-memory.md). Added to a run's tools ONLY when the host
 // 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) and the files they touched. 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 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'] } };
+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'] } };
 
 // 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
 
@@ -785,7 +785,9 @@ function formatRecall(hits, query) {
 	const lines = arr.map((e) => {
 		const when = e.at ? String(e.at).slice(0, 10) : 'undated';
 		const files = Array.isArray(e.files) && e.files.length ? ' — files: ' + e.files.slice(0, 4).join(', ') : '';
-		return '- ' + (e.summary || e.title || 'a session') + files + ' (' + when + ')';
+		let line = '- ' + (e.summary || e.title || 'a session') + files + ' (' + when + ')';
+		if (e.snippet) { line += '\n    ↳ ' + e.snippet; }   // a cited line from the actual transcript (deep recall)
+		return line;
 	});
 	return 'Recalled from earlier sessions in this project (memory — informative but possibly stale; verify against the current code):\n' + lines.join('\n');
 }
 
@@ -110,10 +110,40 @@ function latestBySession(entries) {
  * @param {string} query
  * @param {{ limit?: number }} [opts]
  */
+/** Normalize a query into searchable terms (lowercased, punctuation-trimmed, ≥2 chars). Shared by recall. */
+function queryTerms(query) {
+	return String(query || '').toLowerCase().split(/\s+/).map((t) => t.replace(/[^a-z0-9_.-]/g, '')).filter((t) => t.length >= 2);
+}
+
+/**
+ * Find the first place a query term appears in a session's readable transcript and return a short, cited
+ * snippet around it (role-prefixed). Pure — the caller feeds display turns; this never reads files. Empty
+ * when nothing matches. `terms` may be a pre-split array or a raw query string.
+ */
+function snippetFor(displayTurns, terms) {
+	const ts = Array.isArray(terms) ? terms : queryTerms(terms);
+	if (!ts.length) { return ''; }
+	for (const turn of (Array.isArray(displayTurns) ? displayTurns : [])) {
+		const text = String((turn && turn.text) || '');
+		const low = text.toLowerCase();
+		for (const term of ts) {
+			const i = low.indexOf(term);
+			if (i >= 0) {
+				const start = Math.max(0, i - 40);
+				let snip = text.slice(start, i + term.length + 90).replace(/\s+/g, ' ').trim();
+				if (start > 0) { snip = '…' + snip; }
+				if (i + term.length + 90 < text.length) { snip += '…'; }
+				return (turn.role === 'user' ? 'you: ' : 'ai: ') + snip;
+			}
+		}
+	}
+	return '';
+}
+
 function recallRank(entries, query, opts) {
 	const o = opts || {};
 	const limit = Number.isFinite(o.limit) && o.limit > 0 ? o.limit : 6;
-	const terms = String(query || '').toLowerCase().split(/\s+/).map((t) => t.replace(/[^a-z0-9_.-]/g, '')).filter((t) => t.length >= 2);
+	const terms = queryTerms(query);
 	if (!terms.length) { return []; }
 	const scored = [];
 	for (const e of (Array.isArray(entries) ? entries : [])) {
@@ -193,5 +223,5 @@ module.exports = {
 	SCHEMA_V,
 	memoryDir, journalFile, factsFile, memoryMdFile,
 	outcomeEntry, appendJournal, readJournal, latestBySession, writeMemoryMd,
-	recallRank, buildDigest, digestSummary, digestMarkdown
+	queryTerms, snippetFor, recallRank, buildDigest, digestSummary, digestMarkdown
 };
@@ -165,10 +165,37 @@ function createSessions(opts) {
 		try { return memory.buildDigest(memory.readJournal(root, slug), Object.assign({ nowMs: clock().getTime() }, opts)); }
 		catch (e) { return { recently: [], pinned: [], total: 0 }; }
 	}
-	/** On-demand recall: the top past-session outcomes matching a query (journal search). Empty on error. */
+	/**
+	 * On-demand recall: past-session outcomes matching a query — ranked by journal metadata (summary/title/
+	 * files, all sessions) AND a bounded DEEP scan of recent transcripts, so a match that lives only in the
+	 * conversation (never the one-line summary) is still found and returns a cited snippet. Empty on error.
+	 */
 	function recall(query, opts) {
-		try { return memory.recallRank(memory.latestBySession(memory.readJournal(root, slug)), query, opts); }
-		catch (e) { return []; }
+		const o = opts || {};
+		const limit = Number.isFinite(o.limit) && o.limit > 0 ? o.limit : 6;
+		const scanMax = Number.isFinite(o.scanMax) ? o.scanMax : 40;   // bound the deep transcript reads
+		try {
+			const entries = memory.latestBySession(memory.readJournal(root, slug));   // newest-first
+			const terms = memory.queryTerms(query);
+			if (!terms.length) { return []; }
+			const metaIds = new Set(memory.recallRank(entries, query, { limit: entries.length }).map((e) => e.id));
+			const hits = [];
+			let scanned = 0;
+			for (const e of entries) {
+				let snippet = '';
+				if (scanned < scanMax) {
+					scanned++;
+					try {
+						const turns = events.toDisplayTurns(events.eventsToMessages(store.readSession(store.sessionFile(root, slug, e.id)).events));
+						snippet = memory.snippetFor(turns, terms);
+					} catch (err) { /* a gone/corrupt session just yields no snippet */ }
+				}
+				const score = (metaIds.has(e.id) ? 2 : 0) + (snippet ? 1 : 0);   // a metadata hit weighs more than a body hit
+				if (score > 0) { hits.push(Object.assign({}, e, { score, snippet })); }
+			}
+			hits.sort((a, b) => b.score - a.score || String(b.at || '').localeCompare(String(a.at || '')));
+			return hits.slice(0, limit);
+		} catch (e) { return []; }
 	}
 	/** All current memory outcomes (one per session, newest-first) — what the memory panel lists. */
 	function memoryItems() { try { return memory.latestBySession(memory.readJournal(root, slug)); } catch (e) { return []; } }
 
@@ -92,6 +92,18 @@ test('RECALL: ranks journal entries by term matches in summary/title/files, best
 	assert.ok(M.recallRank(j, 'the', { limit: 2 }).length <= 2, 'respects the limit');
 });
 
+test('SNIPPET: finds the first matching turn and returns a short, role-prefixed citation', () => {
+	const turns = [
+		{ role: 'user', text: 'Add idempotency to refunds' },
+		{ role: 'assistant', text: 'I used a Redis SETNX lock keyed on the idempotency-key header to dedupe retries.' }
+	];
+	const s = M.snippetFor(turns, 'redis');
+	assert.match(s, /^ai: /, 'role-prefixed');
+	assert.match(s, /Redis SETNX/, 'quotes around the match');
+	assert.strictEqual(M.snippetFor(turns, 'zzz'), '', 'no match → empty');
+	assert.strictEqual(M.snippetFor(turns, 'a'), '', 'too-short term → empty');
+});
+
 test('DIGEST: recent (windowed, newest-first) + pinned, built from the journal', () => {
 	const DAY = 86400000, T0 = Date.parse('2026-08-01T12:00:00Z');
 	const ago = (d) => new Date(T0 - d * DAY).toISOString();
 
@@ -274,6 +274,21 @@ test('MEMORY: recall finds a past session by a query over its outcome + files',
 	assert.deepStrictEqual(m.recall('zzz-nomatch'), [], 'no match → empty');
 });
 
+test('MEMORY: recall DEEP-scans transcripts — finds a match that lives only in the conversation, with a snippet', () => {
+	const root = freshRoot(), slug = store.projectSlug('/pdeep');
+	const m = createSessions({ root, slug, projectPath: '/pdeep' });
+	// "kubernetes" appears in the conversation but NOT in the title / summary / files
+	m.recordTurn([
+		{ role: 'user', content: 'Set up the deploy' },
+		{ role: 'assistant', content: 'I configured the Kubernetes ingress and a health probe.' }
+	], 'm');
+	m.seal('done');
+	assert.strictEqual(m.recall('deploy').length, 1, 'metadata match (title) still works');
+	const deep = m.recall('kubernetes');
+	assert.strictEqual(deep.length, 1, 'found by the deep transcript scan, not the metadata');
+	assert.match(deep[0].snippet, /Kubernetes ingress/, 'and returns a cited snippet from the conversation');
+});
+
 test('MEMORY: forget drops a session from memory (digest/recall/panel) but keeps it in History', () => {
 	const root = freshRoot(), slug = store.projectSlug('/pfg');
 	const m = createSessions({ root, slug, projectPath: '/pfg' });