@@ -43,6 +43,7 @@ const SYSTEM_PROMPT =
 let ctx;
 /** @type {vscode.Webview | undefined} */
 let activeWebview;
+let sessionsWebview;   // the Sessions sidebar webview (for pushing list refreshes after a History action)
 /** @type {{role:string,content:string}[]} */
 let conversation = [];
 /** @type {string | null} */
@@ -684,6 +685,68 @@ function sessionList() {
 	return shown;
 }
 
+// Push the current list to whichever surfaces are open — the /sessions modal (in the chat webview) and the
+// Sessions sidebar. Called after any lifecycle edit so both stay live.
+function refreshSessions() {
+	const entries = sessionList();
+	try { post({ type: 'sessions', entries, open: false }); } catch (e) { /* chat webview may be closed */ }
+	try { if (sessionsWebview) { sessionsWebview.postMessage({ type: 'sessions', entries }); } } catch (e) { /* sidebar may be closed */ }
+}
+
+// A card action from either surface. resume reopens the session; done/rename/delete are append-only edits
+// (§4.9): Done archives (reversible, never deletes), Delete soft-trashes, Rename retitles. All refresh both
+// surfaces. Best-effort — a History action must never throw into the UI.
+async function handleSessionAction(action, id) {
+	const m = sessionsManager();
+	if (!m || !id) { return; }
+	dbg('sessions.action', { action, id });
+	try {
+		if (action === 'resume') { await resumeSession(id); return; }
+		if (action === 'done') { m.archive(id); refreshSessions(); return; }
+		if (action === 'delete') { m.trash(id); refreshSessions(); return; }
+		if (action === 'rename') {
+			const cur = (m.list().find((e) => e.id === id) || {}).title || '';
+			const title = await vscode.window.showInputBox({ prompt: 'Rename this session', value: cur, validateInput: (v) => (v && v.trim() ? null : 'Enter a name') });
+			if (title != null && title.trim()) { m.rename(id, title); refreshSessions(); }
+			return;
+		}
+	} catch (e) { dbg('sessions.action.error', { action, id, msg: String((e && e.message) || e) }); }
+}
+
+// Reopen a past session: restore its transcript as the live agent context (budget-fitted, §4.5), reset the
+// per-turn UI, and replay the readable conversation into the chat so it feels like walking back in.
+async function resumeSession(id) {
+	const m = sessionsManager();
+	if (!m) { return; }
+	if (abort) { abort.abort(); }               // stop any running turn before we swap the context out
+	let r = null;
+	try { r = m.resume(id, { contextWindow: currentContextLimit(), budgetPct: aiConfig().get('sessions.resumeBudgetPct', 40) }); }
+	catch (e) { dbg('sessions.resume.error', { id, msg: String((e && e.message) || e) }); }
+	if (!r) { post({ type: 'agentError', message: 'That session could not be opened — it may have been deleted.' }); return; }
+
+	agentMessages = Array.isArray(r.messages) ? r.messages.slice() : [];   // what the model resumes with
+	// Tier 2/3: the head didn't fit the window, so only the recent tail is in context. Prepend a factual
+	// note so the model KNOWS earlier turns exist (a real head-summary is a later refinement) — the user
+	// still sees the whole transcript in the replay. Ephemeral: never persisted (recordTurn appends only
+	// new turns from the goal onward).
+	if (r.plan && r.plan.tier > 1) {
+		const omitted = Math.max(0, (Array.isArray(r.full) ? r.full.length : 0) - agentMessages.length);
+		agentMessages.unshift({ role: 'user', content: '[Resumed session — the earlier part of this conversation (' + omitted + ' message' + (omitted === 1 ? '' : 's') + ') was omitted to fit the context window. It is shown above in the transcript but not included here; ask if you need details from it.]' });
+	}
+	conversation = [];
+	checkpoints.length = 0; currentCheckpoint = null;                       // old file-snapshots can't be restored
+	if (!agentMode) { agentMode = true; post({ type: 'mode', agent: true }); }
+	const turns = Array.isArray(r.turns) ? r.turns : [];
+	const lastUser = turns.filter((t) => t.role === 'user').pop();
+	if (lastUser) { lastAgentGoal = lastUser.text; }                        // keep Continue/Retry meaningful
+	post({ type: 'reset' });
+	post({ type: 'sessionResumed', id, title: (r.entry && r.entry.title) || 'Session', note: r.note || '', tier: r.plan && r.plan.tier, turns });
+	postContextFiles();
+	refreshSessions();                          // the resumed session bumps to the top — keep both surfaces current
+	vscode.commands.executeCommand('levelcodeAi.chat.focus');
+	dbg('sessions.resumed', { id, tier: r.plan && r.plan.tier, restored: agentMessages.length, shown: turns.length });
+}
+
 function newChat() {
 	// Seal the outgoing session (its terminal state + a final index row) BEFORE the transcript is cleared,
 	// so it lands in History as a finished session and the next turn opens a fresh one.
@@ -1788,7 +1851,7 @@ class ChatViewProvider {
 				case 'listSkills': { const en = aiConfig().get('skills.enabled', true); const idx = en ? loadSkills(ctx.extensionPath, dbg) : new Map(); dbg('listSkills', { enabled: en, count: idx.size }); post({ type: 'skillsList', enabled: en, skills: skillsMenu(idx) }); break; }
 				case 'listMcp': post({ type: 'mcpList', mcp: mcpOverview() }); break;
 				case 'listSessions': post({ type: 'sessions', entries: sessionList(), open: false }); break; // reply into the already-open modal
-				case 'sessionAction': dbg('sessions.action', { action: msg.action, id: msg.id }); break; // TODO(next): resume/done/rename/delete
+				case 'sessionAction': await handleSessionAction(msg.action, msg.id); break;
 				case 'feedback': dbg('feedback', { value: msg.value, model: msg.model }); await recordFeedback(msg.value, msg.model); break;
 				case 'openFile': await openWorkspaceFile(msg.path); break;
 				case 'reviewKeepFile': dbg('review.keep', { id: msg.id }); review.keepFile(msg.id, 'kept'); break;
@@ -1834,16 +1897,16 @@ function getHtml() {
 class SessionsViewProvider {
 	/** @param {vscode.WebviewView} view */
 	resolveWebviewView(view) {
+		sessionsWebview = view.webview;
 		view.webview.options = { enableScripts: true, localResourceRoots: [ctx.extensionUri] };
 		view.webview.html = getSessionsHtml();
-		view.webview.onDidReceiveMessage((msg) => {
+		view.webview.onDidReceiveMessage(async (msg) => {
 			switch (msg.type) {
 				// The real session index for this workspace (empty on a fresh install — the view shows its
 				// own empty state). Posted to THIS view's webview, not the chat's.
 				case 'listSessions': view.webview.postMessage({ type: 'sessions', entries: sessionList() }); break;
 				case 'newSession': newChat(); vscode.commands.executeCommand('levelcodeAi.chat.focus'); break;
-				// TODO(next): resume/done/rename/delete once the read side (planResume + replay) lands.
-				case 'sessionAction': dbg('sessions.action', { action: msg.action, id: msg.id }); break;
+				case 'sessionAction': await handleSessionAction(msg.action, msg.id); break;
 			}
 		});
 	}
 
@@ -622,6 +622,13 @@
   .diff .dl.del .s { color: var(--vscode-gitDecoration-deletedResourceForeground, #e06c75); }
   .diff .dl.ctx { opacity: .55; }
   .autoctx { font-size: 11px; opacity: .55; margin: -4px 2px 2px; }
+  /* The "Resumed" banner at the top of a replayed session (message-list notice, so it uses log tokens). */
+  .sessresumed { margin: 2px 2px 12px; padding: 8px 11px; border: 1px solid var(--border); border-left: 2px solid var(--vscode-textLink-foreground, #6a9955); border-radius: 8px; background: var(--field-bg); }
+  .sessresumed .rrow { display: flex; align-items: center; gap: 6px; min-width: 0; }
+  .sessresumed .ci { width: 13px; height: 13px; opacity: .8; flex: 0 0 auto; }
+  .sessresumed .rtag { font-size: 10px; letter-spacing: .08em; text-transform: uppercase; color: var(--vscode-descriptionForeground); flex: 0 0 auto; }
+  .sessresumed .rtitle { font-size: 12.5px; font-weight: 600; color: var(--vscode-foreground); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .sessresumed .rnote { margin-top: 5px; font-size: 11px; color: var(--vscode-descriptionForeground); }
   .autoctx .files { font-family: var(--vscode-editor-font-family, ui-monospace, monospace); }
   #empty { margin: auto; max-width: min(560px, 92vw); text-align: center; opacity: .65; line-height: 1.55; padding: 20px; }
   #empty .empty-copy { max-width: 280px; margin: 0 auto; }
@@ -3355,6 +3362,25 @@
     renderSessions(); ov.style.display = 'flex';
   }
   function closeSessions(){ const ov = document.getElementById('sessOverlay'); if (ov) { ov.style.display = 'none'; } }
+  // Replay a resumed session into the chat: a compact "Resumed" banner (+ the honest summary note, if the
+  // transcript was too big to carry verbatim) followed by the readable conversation — user prompts and the
+  // assistant's prose, tool plumbing dropped. The host has already reset the log and restored the model's
+  // context; this is the visible half, so it feels like stepping back into the session.
+  function resumeTranscript(m){
+    closeSessions();
+    clearEmpty();
+    const banner = document.createElement('div');
+    banner.className = 'sessresumed';
+    banner.innerHTML = '<div class="rrow">' + codicon('sync') + '<span class="rtag">Resumed</span>'
+      + '<span class="rtitle" title="' + escAttr(m.title || '') + '">' + esc(m.title || 'Session') + '</span></div>'
+      + (m.note ? '<div class="rnote">' + esc(m.note) + '</div>' : '');
+    log.appendChild(banner);
+    turnLabeled = false;
+    for (const t of (Array.isArray(m.turns) ? m.turns : [])){
+      add(t.role, t.role === 'user' ? esc(t.text) : render(t.text));
+    }
+    forceStick();
+  }
   (function wireSessions(){
     const close = document.getElementById('sessClose'); if (close) { close.onclick = closeSessions; }
     const ov = document.getElementById('sessOverlay'); if (ov) { ov.addEventListener('click', (e) => { if (e.target === ov) { closeSessions(); } }); }
@@ -3423,6 +3449,7 @@
     else if (m.type === 'skillsList'){ renderSkillsList(m); }
     else if (m.type === 'mcpList'){ renderMcpList(m.mcp || {}); }
     else if (m.type === 'sessions'){ sessData = Array.isArray(m.entries) ? m.entries : []; if (m.open === false) { renderSessions(); } else { openSessions(); } }
+    else if (m.type === 'sessionResumed'){ resumeTranscript(m); }
     else if (m.type === 'verifyRun'){ addVerifyRun(m); }
     else if (m.type === 'verifyOutput'){ verifyOutputAppend(m); }
     else if (m.type === 'verifyDone'){ verifyDoneFinish(m); }
 
@@ -441,6 +441,13 @@
           "description": "Folder to store session History in. Empty = ~/.levelcode/sessions. Each project gets its own subfolder; the files are append-only JSONL you can back up, diff, or delete by hand.",
           "scope": "machine"
         },
+        "levelcode.ai.sessions.resumeBudgetPct": {
+          "type": "number",
+          "default": 40,
+          "minimum": 5,
+          "maximum": 100,
+          "description": "When you resume a session, the share of the model's context window its restored transcript may fill before it is summarized to fit. Lower = resume with less history (cheaper, faster); higher = carry more of the past conversation verbatim. The full transcript is always kept on disk and shown in the replay regardless."
+        },
         "levelcode.ai.verify.enabled": {
           "type": "boolean",
           "default": true,
 
@@ -84,6 +84,37 @@ function eventsToMessages(events) {
 	return out;
 }
 
+// ── the readable transcript for a resume replay (pure) ───────────────────────────────────────────
+
+/** The human-visible text of a provider message: a string as-is, or the joined `text` blocks of an array. */
+function messageText(content) {
+	if (content == null) { return ''; }
+	if (typeof content === 'string') { return content; }
+	if (Array.isArray(content)) {
+		return content.filter((b) => b && b.type === 'text' && typeof b.text === 'string').map((b) => b.text).join('\n\n');
+	}
+	return '';
+}
+
+/**
+ * Fold a rebuilt messages array into the readable conversation to REPLAY on resume: one entry per user
+ * prompt and per assistant answer, in order. Tool plumbing is dropped — a user message that is only a
+ * `tool_result`, and an assistant turn that is only `tool_use` (no prose) — so the replay reads like the
+ * chat did, not like the raw transcript. Pure, so the webview never has to know provider message shapes.
+ */
+function toDisplayTurns(messages) {
+	const out = [];
+	for (const m of (Array.isArray(messages) ? messages : [])) {
+		if (!m || (m.role !== 'user' && m.role !== 'assistant')) { continue; }
+		// a user message whose content is purely tool_result blocks is plumbing, not something the user typed
+		if (m.role === 'user' && Array.isArray(m.content) && m.content.length && m.content.every((b) => b && b.type === 'tool_result')) { continue; }
+		const text = messageText(m.content);
+		if (!text.trim()) { continue; }   // e.g. an assistant turn that was only tool calls
+		out.push({ role: m.role, text });
+	}
+	return out;
+}
+
 /** How many messages are already persisted — so a per-turn append stores only the new tail, not the lot. */
 function tailFrom(messages, storedCount) {
 	const msgs = Array.isArray(messages) ? messages : [];
@@ -95,5 +126,5 @@ module.exports = {
 	EDIT_TOOLS,
 	toolStatsFromMessages,
 	userTurnEvent, agentTurnEvent, endEvent, titleEvent, labelEvent,
-	eventsToMessages, tailFrom
+	eventsToMessages, messageText, toDisplayTurns, tailFrom
 };
@@ -17,6 +17,7 @@
 
 const store = require('./sessionStore');
 const events = require('./sessionEvents');
+const planner = require('./sessionResume');
 
 /**
  * @param {{ root: string, slug: string, projectPath: string,
@@ -32,16 +33,18 @@ function createSessions(opts) {
 
 	const iso = () => clock().toISOString();
 
-	// Refresh this session's index row from its file. Best-effort: the index is a cache (scan rebuilds it),
-	// so a failure here must never surface into a chat turn.
-	function reindex() {
-		if (!live) { return; }
+	// Refresh a session's index row from its file. Best-effort: the index is a cache (scan rebuilds it), so
+	// a failure here must never surface into a chat turn. Works for any id, so lifecycle actions on a past
+	// (non-live) session update the list too.
+	function reindexId(id) {
+		if (!id) { return; }
 		try {
-			const s = store.readSession(live.file);
+			const s = store.readSession(store.sessionFile(root, slug, id));
 			const idx = store.loadIndex(root, slug);
 			store.writeIndex(root, slug, store.upsertEntry(idx.entries, store.deriveEntry(s.meta, s.events)));
 		} catch (e) { /* index is a rebuildable cache */ }
 	}
+	function reindex() { if (live) { reindexId(live.id); } }
 
 	/** Open a fresh session (its dir + meta birth line) if none is live. Idempotent while one is live. */
 	function ensure() {
@@ -81,12 +84,53 @@ function createSessions(opts) {
 		if (state) { try { state.set('liveSessionId', null); } catch (e) { /* convenience */ } }
 	}
 
+	/**
+	 * Reopen a past session as the LIVE one. Rebuilds its full transcript, plans how much fits the model's
+	 * window (three-tier, §4.5), and re-attaches so further turns append to THIS session. Returns:
+	 *   full     — the whole conversation (for the visible replay),
+	 *   messages — the budget-fitted subset the model resumes with (== full for a verbatim/tier-1 resume),
+	 *   plan     — the resume plan (tier + cut), note — the honest "resumed from a summary" line, entry.
+	 * null if the session is gone/unreadable. Append-only: the prior `end` event is harmless (rebuild skips
+	 * it, and the next turn's events simply extend the history).
+	 */
+	function resume(id, opts) {
+		let s;
+		try { s = store.readSession(store.sessionFile(root, slug, id)); } catch (e) { return null; }
+		const full = events.eventsToMessages(s.events);
+		const plan = planner.planResume(full, opts || {});
+		const messages = plan.tier === 1 ? full : (Array.isArray(plan.tail) ? plan.tail : full);
+		const head = full.slice(0, plan.cutIndex || 0);
+		const turnsSummarized = head.filter((m) => m && m.role === 'user').length;
+		live = { id, file: store.sessionFile(root, slug, id) };
+		if (state) { try { state.set('liveSessionId', id); } catch (e) { /* convenience */ } }
+		reindexId(id);
+		return { id, meta: s.meta, entry: store.deriveEntry(s.meta, s.events), full, messages, plan,
+			turns: events.toDisplayTurns(full),   // the readable transcript to replay in the webview
+			note: planner.describeResume(plan, turnsSummarized) };
+	}
+
+	// Append-only lifecycle edits (§4.9): each writes one event, then refreshes that id's index row. All
+	// best-effort (return false rather than throw) — a History edit must never disrupt anything.
+	function appendTo(id, event) {
+		try { store.appendEvent(store.sessionFile(root, slug, id), event); reindexId(id); return true; }
+		catch (e) { return false; }
+	}
+	/** Completion = ARCHIVE (reversible, keeps the work), never delete. Drops out of the active list. */
+	function archive(id) { return appendTo(id, events.labelEvent({ lifecycle: 'archived' }, iso())); }
+	/** Soft delete — moves to the `trashed` lifecycle (reversible, append-only; the file is left on disk). */
+	function trash(id) { return appendTo(id, events.labelEvent({ lifecycle: 'trashed' }, iso())); }
+	function setPinned(id, on) { return appendTo(id, events.labelEvent({ pinned: !!on }, iso())); }
+	function rename(id, title) {
+		if (title == null || !String(title).trim()) { return false; }
+		return appendTo(id, events.titleEvent(String(title).trim(), iso()));
+	}
+
 	/** The session index for this project (what the panel/view list). Empty (never throws) if unreadable. */
 	function list() { try { return store.loadIndex(root, slug).entries; } catch (e) { return []; } }
 
 	function liveId() { return live ? live.id : null; }
 
-	return { ensure, recordTurn, seal, list, liveId };
+	return { ensure, recordTurn, seal, resume, archive, trash, setPinned, rename, list, liveId };
 }
 
 module.exports = { createSessions };
@@ -93,4 +93,20 @@ test('END-TO-END: events built here derive the right card in sessionStore (one s
 	assert.deepStrictEqual(card.filesEdited, ['refund.rb', 'redis_lock.rb'], 'and so did the files-edited chips');
 });
 
+test('DISPLAY: toDisplayTurns folds a raw transcript into the readable prompts + prose to replay', () => {
+	const turns = E.toDisplayTurns(conversation());
+	assert.deepStrictEqual(turns, [
+		{ role: 'user', text: 'add idempotency to refunds' },   // the user's typed prompt
+		{ role: 'assistant', text: 'reading' },                 // the text block, not the read_file tool_use
+		{ role: 'assistant', text: 'Done: idempotent refunds via Redis keys' }
+	], 'tool_result user messages and tool_use-only assistant turns are dropped');
+});
+
+test('DISPLAY: toDisplayTurns is tolerant of junk and joins multiple text blocks', () => {
+	assert.deepStrictEqual(E.toDisplayTurns(null), []);
+	assert.deepStrictEqual(E.toDisplayTurns([null, { role: 'system', content: 'x' }, { role: 'user', content: '' }]), [], 'empty/other roles skipped');
+	const joined = E.toDisplayTurns([{ role: 'assistant', content: [{ type: 'text', text: 'one' }, { type: 'tool_use', id: 'a', name: 'x' }, { type: 'text', text: 'two' }] }]);
+	assert.deepStrictEqual(joined, [{ role: 'assistant', text: 'one\n\ntwo' }]);
+});
+
 console.log('sessionEvents: ' + n + ' tests passed');