feat(levelcode): cross-session memory M3 — the Project memory panel

The transparency + control surface the design calls non-negotiable: a Memory tab
beside History in the Sessions sidebar. It lists what the project remembers — the
recorded outcomes with their files and date — and lets you curate it: Edit to
correct a wrong memory, Forget to drop a session's contribution (the session
itself stays in History), and "open file ↗" to read/edit MEMORY.md directly.
Correcting or forgetting immediately updates the digest the agent sees, so it
stops repeating a wrong memory.

- sessionMemory.js: latestBySession now honors a `forgotten` tombstone — a
  forgotten session leaves the digest, recall, and panel while the append-only
  journal keeps the full history (a hand-edit can restore it).
- sessions.js: forget(id) (append a tombstone + re-consolidate) and
  memoryItems() (all current outcomes, newest-first); Edit reuses refineSummary.
- extension.js: the sidebar provider serves listMemory and routes memoryAction
  (resume / edit via an input box / forget) through handleMemoryAction, then
  refreshes the panel + the welcome-back strip.
- media/sessionsView.html: a History/Memory tab bar with two panes; memory cards
  reuse the line-2 hover-swap (meta ⇄ Edit/Forget), Forget tinted danger.
- tests: +1 sessionMemory (forgotten tombstone), +1 sessions (forget drops
  memory, keeps History), +1 sessionsUi (panel wiring). 31 files green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ndemianc

extensions/levelcode-ai/extension.js

@@ -797,6 +797,27 @@ function recallSessionsTool(query) {
 	catch (e) { return 'Recall failed.'; }
 }
 
+// A memory-panel action (§M3): resume the source session, EDIT its recorded outcome (correct a wrong
+// memory), or FORGET it (drop its contribution — the session itself stays in History). Refreshes the panel
+// list + the welcome-back strip. Best-effort.
+async function handleMemoryAction(action, id, webview) {
+	const m = sessionsManager();
+	if (!m || !id) { return; }
+	dbg('sessions.memoryAction', { action, id });
+	try {
+		if (action === 'resume') { await resumeSession(id); return; }
+		if (action === 'forget') { m.forget(id); }
+		else if (action === 'edit') {
+			const cur = (m.memoryItems().find((e) => e.id === id) || {}).summary || '';
+			const text = await vscode.window.showInputBox({ prompt: 'Edit what this session is remembered for', value: cur, validateInput: (v) => (v && v.trim() ? null : 'Enter a one-line outcome') });
+			if (text == null || !text.trim()) { return; }
+			m.refineSummary(id, text);
+		} else { return; }
+		if (webview) { try { webview.postMessage({ type: 'memoryList', items: m.memoryItems() }); } catch (e) { /* view closed */ } }
+		postMemoryDigest();
+	} catch (e) { dbg('sessions.memoryAction.error', { action, id, msg: String((e && e.message) || e) }); }
+}
+
 // A card action from either surface. resume reopens the session; done/delete/rename/pin are append-only edits
 // (§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
@@ -2025,6 +2046,10 @@ class SessionsViewProvider {
 				case 'listSessions': view.webview.postMessage({ type: 'sessions', entries: sessionList() }); break;
 				case 'newSession': newChat(); vscode.commands.executeCommand('levelcodeAi.chat.focus'); break;
 				case 'sessionAction': await handleSessionAction(msg.action, msg.id); break;
+				// Memory tab (§M3): list the recorded outcomes; act on them (resume / edit / forget); open the file.
+				case 'listMemory': { const mm = sessionsManager(); view.webview.postMessage({ type: 'memoryList', items: mm ? mm.memoryItems() : [] }); break; }
+				case 'memoryAction': await handleMemoryAction(msg.action, msg.id, view.webview); break;
+				case 'openMemory': await openMemory(); break;
 			}
 		});
 	}

extensions/levelcode-ai/media/sessionsView.html

@@ -24,6 +24,28 @@
   .sessundo .ut { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
   .sessundo .ub { flex: 0 0 auto; background: transparent; border: none; color: var(--cc-accent); font: inherit; font-size: 12.5px; font-weight: 600; cursor: pointer; padding: 2px 4px; border-radius: 4px; }
   .sessundo .ub:hover { text-decoration: underline; }
+  /* Memory tab (§M3): a second surface beside History for the recorded outcomes — edit or forget. */
+  .svtabs { display: flex; gap: 2px; padding: 6px 10px 0; flex: 0 0 auto; }
+  .svtab { flex: 1; background: transparent; border: none; border-bottom: 2px solid transparent; color: var(--cc-text3); font: inherit; font-size: 12px; padding: 6px 4px 7px; cursor: pointer; }
+  .svtab:hover { color: var(--cc-text); }
+  .svtab.on { color: var(--cc-text); border-bottom-color: var(--cc-accent); }
+  .svpane { flex: 1 1 auto; display: flex; flex-direction: column; min-height: 0; }
+  .svpane[hidden] { display: none; }
+  .svmemhead { display: flex; align-items: baseline; justify-content: space-between; gap: 8px; padding: 10px 12px 4px; font-size: 11px; color: var(--cc-text3); }
+  .svmemopen { background: transparent; border: none; color: var(--cc-accent); font: inherit; font-size: 11px; cursor: pointer; padding: 0; white-space: nowrap; }
+  .svmemopen:hover { text-decoration: underline; }
+  .memcard { position: relative; padding: 8px 8px 9px; margin-bottom: 1px; border-radius: 6px; cursor: pointer; }
+  .memcard:hover { background: color-mix(in srgb, var(--cc-text3) 13%, transparent); }
+  .memcard:focus-visible { background: color-mix(in srgb, var(--cc-accent) 15%, transparent); outline: none; }
+  .memcard .memtext { font-size: 13px; line-height: 1.45; color: var(--cc-text); }
+  .memcard .memline2 { display: flex; align-items: center; min-height: 22px; margin-top: 3px; }
+  .memcard .memmeta { flex: 1 1 auto; min-width: 0; font-size: 11.5px; color: var(--cc-text3); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .memcard .memacts { display: none; align-items: center; gap: 4px; flex: 0 0 auto; }
+  .memcard:hover .memmeta, .memcard:focus-within .memmeta { display: none; }
+  .memcard:hover .memacts, .memcard:focus-within .memacts { display: flex; }
+  .memcard .memact { background: transparent; border: none; color: var(--cc-text2); border-radius: 4px; padding: 2px 8px; font: inherit; font-size: 11px; cursor: pointer; white-space: nowrap; }
+  .memcard .memact:hover { background: color-mix(in srgb, var(--cc-text3) 20%, transparent); color: var(--cc-text); }
+  .memcard .memact[data-act="forget"]:hover { background: color-mix(in srgb, var(--cc-danger) 18%, transparent); color: var(--cc-danger); }
   .sesslist { flex: 1 1 auto; overflow-y: auto; padding: 0 10px 12px; }
   .sessbucket { display: flex; justify-content: space-between; align-items: baseline; font-family: var(--vscode-editor-font-family, ui-monospace, monospace); font-size: 10px; letter-spacing: .1em; text-transform: uppercase; color: var(--cc-text3); margin: 12px 4px 7px; }
   .sessbucket .cnt { letter-spacing: 0; }
@@ -56,8 +78,18 @@
 </head>
 <body>
   <div class="sessview">
-    <button id="svNew" class="sessnew" type="button">New Session</button>
-    <div class="sesslist" id="svList"></div>
+    <div class="svtabs">
+      <button class="svtab on" data-tab="history" type="button">History</button>
+      <button class="svtab" data-tab="memory" type="button">Memory</button>
+    </div>
+    <div class="svpane" id="paneHistory">
+      <button id="svNew" class="sessnew" type="button">New Session</button>
+      <div class="sesslist" id="svList"></div>
+    </div>
+    <div class="svpane" id="paneMemory" hidden>
+      <div class="svmemhead"><span>What this project remembers</span><button class="svmemopen" id="svMemOpen" type="button">open file &#8599;</button></div>
+      <div class="sesslist" id="svMemList"></div>
+    </div>
     <div class="sessundo" id="svUndo" hidden></div>
   </div>
 <script nonce="__NONCE__">
@@ -154,6 +186,38 @@
     const id = card.getAttribute('data-id'); const btn = e.target.closest('[data-act]');
     vscode.postMessage({ type: 'sessionAction', action: btn ? btn.getAttribute('data-act') : 'resume', id: id });
   });
+  // ── Memory tab (§M3): the recorded outcomes, each with Edit / Forget; click the card to resume it ──
+  function memCardHtml(e){
+    const files = Array.isArray(e.files) ? e.files : [];
+    const when = e.at ? new Date(e.at).toLocaleDateString(undefined, { month: 'short', day: 'numeric' }) : '';
+    const meta = (files.length ? esc(files[0]) + (files.length > 1 ? ' +' + (files.length - 1) : '') + ' · ' : '') + esc(when);
+    return '<div class="memcard" data-id="' + escAttr(e.id || '') + '" tabindex="0" role="button" title="' + escAttr(e.summary || '') + '">'
+      + '<div class="memtext">' + esc(e.summary || e.title || 'a session') + '</div>'
+      + '<div class="memline2"><span class="memmeta">' + meta + '</span>'
+      + '<span class="memacts"><button type="button" class="memact" data-act="edit" title="Edit this memory">Edit</button>'
+      + '<button type="button" class="memact" data-act="forget" title="Forget this session">Forget</button></span></div>'
+      + '</div>';
+  }
+  function renderMemory(items){
+    const list = document.getElementById('svMemList'); if (!list) { return; }
+    const arr = Array.isArray(items) ? items : [];
+    if (!arr.length){ list.innerHTML = '<div class="sessempty">Nothing remembered yet. As sessions finish, what they achieved appears here — plain text you can edit or forget.</div>'; return; }
+    list.innerHTML = arr.map(memCardHtml).join('');
+  }
+  document.getElementById('svMemList').addEventListener('click', (e) => {
+    const card = e.target.closest && e.target.closest('.memcard'); if (!card) { return; }
+    const id = card.getAttribute('data-id'); const btn = e.target.closest('[data-act]');
+    vscode.postMessage({ type: 'memoryAction', action: btn ? btn.getAttribute('data-act') : 'resume', id: id });
+  });
+  document.getElementById('svMemOpen').addEventListener('click', () => vscode.postMessage({ type: 'openMemory' }));
+  function showTab(tab){
+    const hist = tab === 'history';
+    document.getElementById('paneHistory').hidden = !hist;
+    document.getElementById('paneMemory').hidden = hist;
+    document.querySelectorAll('.svtab').forEach((b) => b.classList.toggle('on', b.getAttribute('data-tab') === tab));
+    if (!hist) { vscode.postMessage({ type: 'listMemory' }); }
+  }
+  document.querySelectorAll('.svtab').forEach((b) => b.addEventListener('click', () => showTab(b.getAttribute('data-tab'))));
   // The Undo toast for Done/Delete — a quick, recoverable safety net. Auto-hides after a few seconds.
   let sessUndoTimer = null;
   function showUndo(m){
@@ -168,7 +232,7 @@
     vscode.postMessage({ type: 'sessionAction', action: 'restore', id: b.getAttribute('data-id') });
     document.getElementById('svUndo').hidden = true; clearTimeout(sessUndoTimer);
   });
-  window.addEventListener('message', (ev) => { const m = ev.data; if (m && m.type === 'sessions'){ sessData = Array.isArray(m.entries) ? m.entries : []; renderSessions(); } else if (m && m.type === 'sessionUndo'){ showUndo(m); } });
+  window.addEventListener('message', (ev) => { const m = ev.data; if (m && m.type === 'sessions'){ sessData = Array.isArray(m.entries) ? m.entries : []; renderSessions(); } else if (m && m.type === 'memoryList'){ renderMemory(m.items); } else if (m && m.type === 'sessionUndo'){ showUndo(m); } });
   renderSessions();
   vscode.postMessage({ type: 'listSessions' });
 </script>

extensions/levelcode-ai/sessionMemory.js

@@ -93,7 +93,9 @@ function latestBySession(entries) {
 		if (!e || e.id == null) { continue; }
 		byId.set(String(e.id), e);                        // later lines overwrite earlier → latest wins
 	}
-	const out = [...byId.values()];
+	// A `forgotten` tombstone (the newest line for an id) drops it from all memory — digest, recall, panel —
+	// while the append-only journal.jsonl keeps the full history (a hand-edit can bring it back).
+	const out = [...byId.values()].filter((e) => !e.forgotten);
 	out.sort((a, b) => String(b.at || '').localeCompare(String(a.at || '')));
 	return out;
 }

extensions/levelcode-ai/sessions.js

@@ -170,6 +170,17 @@ function createSessions(opts) {
 		try { return memory.recallRank(memory.latestBySession(memory.readJournal(root, slug)), query, opts); }
 		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 []; } }
+	/**
+	 * Forget a session's memory contribution: a tombstone that drops it from the digest/recall/panel while
+	 * the session itself stays in History. Append-only + re-consolidate MEMORY.md. Best-effort.
+	 */
+	function forget(id) {
+		if (!id) { return false; }
+		try { memory.appendJournal(root, slug, { v: memory.SCHEMA_V, id: String(id), at: iso(), forgotten: true }); consolidate(); return true; }
+		catch (e) { return false; }
+	}
 	/** The deterministic consolidation pass: rewrite MEMORY.md from the current journal. Returns the digest. */
 	function consolidate(opts) {
 		const o = Object.assign({ nowMs: clock().getTime() }, opts);
@@ -207,7 +218,7 @@ function createSessions(opts) {
 
 	function liveId() { return live ? live.id : null; }
 
-	return { ensure, recordTurn, seal, resume, archive, trash, restore, setPinned, rename, autoArchiveStale, digest, consolidate, transcript, refineSummary, recall, memoryPaths, list, liveId };
+	return { ensure, recordTurn, seal, resume, archive, trash, restore, setPinned, rename, autoArchiveStale, digest, consolidate, transcript, refineSummary, recall, memoryItems, forget, memoryPaths, list, liveId };
 }
 
 module.exports = { createSessions };

extensions/levelcode-ai/test/sessionMemory.test.js

@@ -70,6 +70,15 @@ test('LATEST: one outcome per session — the latest supersedes, newest-first',
 	assert.strictEqual(latest.find((e) => e.id === 'a').title, 'a-new', 'the later line supersedes the earlier');
 });
 
+test('LATEST: a forgotten tombstone drops the session from memory', () => {
+	const entries = [
+		{ id: 'a', at: '2026-01-01', summary: 'alpha' },
+		{ id: 'b', at: '2026-02-01', summary: 'beta' },
+		{ id: 'a', at: '2026-03-01', forgotten: true }   // a is forgotten (its newest line)
+	];
+	assert.deepStrictEqual(M.latestBySession(entries).map((e) => e.id), ['b'], 'forgotten a is gone; b remains');
+});
+
 test('RECALL: ranks journal entries by term matches in summary/title/files, best-first', () => {
 	const j = [
 		{ id: 'a', at: '2026-07-01', summary: 'Made refunds idempotent with a Redis lock', title: 'refund retries', files: ['refund.rb'] },

extensions/levelcode-ai/test/sessions.test.js

@@ -274,4 +274,17 @@ 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: 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' });
+	m.recordTurn(turn('Add idempotency to refunds', 'refund.rb'), 'm'); m.seal('done');
+	assert.strictEqual(m.memoryItems().length, 1, 'the outcome is in memory');
+	const id = m.memoryItems()[0].id;
+	assert.ok(m.forget(id));
+	assert.deepStrictEqual(m.memoryItems(), [], 'forgotten → gone from the panel');
+	assert.deepStrictEqual(m.digest().recently, [], 'and from the welcome-back digest');
+	assert.deepStrictEqual(m.recall('refund'), [], 'and from recall');
+	assert.strictEqual(m.list().length, 1, 'but the session itself stays in History (resumable)');
+});
+
 console.log('sessions: ' + n + ' tests passed');

extensions/levelcode-ai/test/sessionsUi.test.js

@@ -185,6 +185,18 @@ test('MEMORY (recall): a recall_sessions agent tool searches past-session outcom
 	assert.ok((pkg.contributes.configuration.properties || {})['levelcode.ai.sessions.memory.recallTool'], 'the setting is contributed');
 });
 
+test('MEMORY (panel M3): a Memory tab in the sidebar to view / edit / forget the recorded outcomes', () => {
+	assert.match(view, /data-tab="memory"/, 'a Memory tab beside History');
+	assert.match(view, /id="svMemList"/, 'a memory list container');
+	assert.match(view, /function renderMemory/, 'renders the outcomes');
+	assert.match(view, /type: 'memoryAction'/, 'posts edit/forget/resume');
+	assert.match(view, /data-act="forget"/, 'a Forget control');
+	assert.match(view, /type: 'listMemory'/, 'requests the list when the tab opens');
+	assert.match(ext, /case 'listMemory'/, 'the provider serves the memory list');
+	assert.match(ext, /async function handleMemoryAction/, 'and handles the actions');
+	assert.match(ext, /m\.forget\(id\)/, 'forget drops the contribution (session stays in History)');
+});
+
 test('VIEW: the sidebar view and the modal share the EXACT same render block (no drift)', () => {
 	const grab = (s) => s.slice(s.indexOf('// [SESSIONS-PURE-START]'), s.indexOf('// [SESSIONS-PURE-END]'));
 	assert.ok(grab(view).length > 500, 'the view carries the pure block');