diff --git a/docs/development/native-appearance-welcome/BACKUPS_AND_RESET.md b/docs/development/native-appearance-welcome/BACKUPS_AND_RESET.md
index 4f5a903b..9e48593b 100644
--- a/docs/development/native-appearance-welcome/BACKUPS_AND_RESET.md
+++ b/docs/development/native-appearance-welcome/BACKUPS_AND_RESET.md
@@ -50,3 +50,15 @@ Manual terminal checks still needed: open /changes, review and restore a harmles
 **Interrupted writes (D4).** `outcome` stays `prepared | applied` so older builds still read every entry; how an unfinished write ended is extra evidence in `resolution` (`reverted`, `rollback-incomplete`, `finalized`, `partial`). `Journal.transactionState` reconciles an entry from the bytes on disk, never from assumptions: `applied`, `in-progress` (another live process owns it), `not-applied`, `partially-applied`, `applied-unfinalized`, `conflicted` (a file now matches neither its before nor after image), `reverted`, `rollback-incomplete`, `partial`, `indeterminate` (a file cannot be read safely). An in-process failure records `reverted` or `rollback-incomplete`. In `/changes`, unfinished entries are counted in the notice and marked `!`; Enter reviews a rollback (a normal restore with its own undo checkpoint; only files whose bytes would change and differ from what NMSh wrote need the second confirmation), and `F` marks an entry applied only when every file holds the written bytes (no file is touched). A successful rollback marks the entry `reverted`, naming the undo checkpoint. Unresolved prepared entries are never pruned automatically. Tests kill a real writer process with SIGKILL after the entry is recorded, after the first of two files, and before finalization (`tests/backupsIntegrity.test.ts`).
 
 Limits: the per-host appearance and shader ownership records each describe one file group and are always restored together with that group, so they are not reconciled per tool. PID reuse can make a long-dead writer look `in-progress`; that state blocks nothing but reconciliation advice.
+
+## History, reset and retention (D5–D7, 2026-10-29)
+
+**Readable history (D5).** Each row is `HH:MM <application> · <file> [+N more] · <created|changed|removed|checkpoint> · <status>`, grouped by local day. The application comes from the path (Kitty, Ghostty, Vim colors, Starship, NMSh settings, …); NMSh's own records (settings, ownership JSON) are never named as the subject when a user-facing file is in the entry. The writer's label stays visible as "Recorded as: <source> · <label>". Status distinguishes "changed later by NMSh (<time>)" (the file holds what a newer entry wrote) from "edited since" (something else changed it).
+
+**One reset, one entry (D6).** A single-area reset is one transaction, so its own entry is the undo checkpoint (previously a separate checkpoint duplicated it). A multi-area reset keeps one "Reset checkpoint: A, B" of every file plus "Reset stage i/n: <area>" entries linked to it (`group`), because a later stage can start from a file an earlier stage changed. A failed stage marks the checkpoint `partial` with the per-area results. Navigation steps say what Enter does ("next: backup", "next: type reset", "restore now", "next: confirm overwrite"); only the typed word `reset` writes.
+
+**Scoped settings reset (D7).** `config.json` has three reset areas: NMSh preferences, first-run state (onboarding, intro, tools setup, glyph style and choice) and update policy (`updateMode`, `updateFrequency`). Preferences never touch first-run state or the update policy; no scope touches the user's themes, `customTheme`, welcome presets, agent profiles, or fields this version does not know. Selected scopes are planned together as one exact change. The impact lists every changed setting as `key: before → after` and what is kept. A missing settings file is "nothing to reset"; malformed JSON is refused, never guessed at; a second reset is a no-op.
+
+**Retention guarantees.** The journal keeps at most 200 entries / 64 MiB (unchanged). Never pruned automatically: unfinished entries (unresolved, or rollback-incomplete), the newest entry per source and file, and the 20 newest reset/restore/manual entries. Pruned oldest-first: every other entry, except each file's earliest kept backup ("original"); originals go only when nothing else can, oldest first, and each removal is recorded (path and time, newest 50) in `.pruned.json` and shown in `/changes` as a retention warning that suggests a manual snapshot. If even the never-pruned entries do not fit, the write is refused with that reason. So NMSh does not promise that the state before its first change is kept forever: it keeps it ahead of everything automatic and says when capacity pressure removed it. "Original" means the earliest backup the journal still has; files NMSh changed before the journal existed (builds before c3620236) have no pre-NMSh copy. A settings reset that keeps the update policy or first-run state writes out absent keys as their current effective value, so a legacy file cannot change meaning. Tested: 260 automatic writes to one file beside two edits of another keep both originals within 200 entries; a three-entry cap reports the original it removed.
+
+Known cost: each journaled write lists and verifies the whole history (~0.4 s per write at 200 entries on this Mac); bursts of automatic shader writes pay it each time. Not changed here.
diff --git a/docs/development/native-appearance-welcome/QA_CHECKLIST.md b/docs/development/native-appearance-welcome/QA_CHECKLIST.md
index b18a0095..d4358f11 100644
--- a/docs/development/native-appearance-welcome/QA_CHECKLIST.md
+++ b/docs/development/native-appearance-welcome/QA_CHECKLIST.md
@@ -52,5 +52,16 @@ Automated tests use private HOMEs, headless host parsers and proxy compiles. Non
 6. Export a preset. The file has no image path unless you opted in, and never contains image bytes. Import it again.
 7. On a host without verified inline graphics (for example Terminal.app), the image falls back to cell art with the reason shown.
 
+## Backups, /changes and /nmsh reset (current build; headless-covered, physical NOT RUN)
+
+Use a disposable HOME/XDG_CONFIG_HOME (see `scripts/qa/` fixtures); never the real configuration.
+1. Launch NMSh three times with Theme Bridge on. `theme-bridge/ledger.json` keeps its bytes and inode; `/changes` gains no entries and older entries stay "unchanged since".
+2. `/changes`: rows read `HH:MM <Application> · <file> · <created/changed/removed> · <status>`; the details show the full path, local time and the original label as "Recorded as". A file NMSh rewrote later says "changed later by NMSh", not "edited since".
+3. Restore an older Theme Bridge entry while a newer Vim file is managed: the review says the Vim record is kept; afterwards `/theme-bridge` still manages Vim.
+4. Replace a recorded config directory with a plain file: other appearance changes still save; that entry's row says "unsafe file"; Enter names the entry, the path and the reason, and changes nothing.
+5. Footers: restore review says "Enter restore now" (or "next: confirm overwrite"); reset Impact says "Enter next: backup", Backup says "Enter next: type reset"; only the typed word writes.
+6. `/nmsh reset` → "NMSh preferences": the impact lists `key: before → after` and "Kept: first-run state …, update policy …"; after the reset, onboarding does not reappear and `updateMode` is unchanged. Undo through `/changes`.
+7. Check every step at 80×24 and 60×20, with NO_COLOR=1.
+
 ## Record
 Note the host, version, OS, and pass/fail per item. Attach screenshots for anything visual. Report anything that writes outside NMSh's own files.
diff --git a/src/backups/ChangesPanel.ts b/src/backups/ChangesPanel.ts
index 581fa5d7..b7d9b272 100644
--- a/src/backups/ChangesPanel.ts
+++ b/src/backups/ChangesPanel.ts
@@ -3,14 +3,15 @@ import {dirname,join} from 'node:path';
 import type {Key} from '../terminal/keys.js';
 import {renderStudioLayout, renderStudioReview, studioWrap, type StudioReview} from '../ui/StudioLayout.js';
 import {Journal, type JournalEntry, type TransactionReport} from './journal.js';
-import {describeState, needsReview} from './describe.js';
+import {applicationOf, describeEntry, describeState, displayPath, fileAction, localDay, needsReview} from './describe.js';
+import {digest, snapshot} from '../appearance/hostFiles.js';
 import {manualSnapshot, planRestore, restore, type RestorePlan} from './restore.js';
 export interface ChangesPanel {
   journal:Journal;ownershipPaths:string[];entries:JournalEntry[];statuses:Map<string,string>;states:Map<string,TransactionReport>;
   selected:number;view:'list'|'review'|'confirm'|'result';review?:StudioReview;restore?:RestorePlan;message:string;shown:boolean;
 }
 export function createChangesPanel(journal:Journal,ownershipPaths:readonly string[]):ChangesPanel {
-  const state:ChangesPanel={journal,ownershipPaths:[...new Set([join(dirname(journal.directory),'config.json'),...ownershipPaths])],entries:[],statuses:new Map(),states:new Map(),selected:0,view:'list',message:'History is capped at 200 entries / 64 MiB; newest 20 protected checkpoints and source/path anchors are kept.',shown:false};
+  const state:ChangesPanel={journal,ownershipPaths:[...new Set([join(dirname(journal.directory),'config.json'),...ownershipPaths])],entries:[],statuses:new Map(),states:new Map(),selected:0,view:'list',message:RETENTION,shown:false};
   refresh(state);return state;
 }
 function refresh(state:ChangesPanel):void {
@@ -19,10 +20,19 @@ function refresh(state:ChangesPanel):void {
   // A damaged entry is kept on disk for review and named with its reason; it no longer blocks other backups or writes.
   const damaged=[...state.journal.unreadableReasons];
   if(damaged.length)notices.push(`${damaged.length} unreadable backup ${damaged.length===1?'entry needs':'entries need'} review and ${damaged.length===1?'is':'are'} not listed: ${damaged.slice(0,3).map(([id,reason])=>`${id}: ${reason}`).join('; ')}${damaged.length>3?'; …':''} (kept in ${state.journal.directory}).`);
-  try {const count=state.journal.prunedCount();if(count)notices.push(`${count} old backup entries pruned.`);}catch{notices.push('Backup pruning record unreadable.');}
+  try {
+    const count=state.journal.prunedCount();if(count)notices.push(`${count} old backup entries pruned.`);
+    const lost=[...new Map(state.journal.lostOriginals().map(item=>[item.path,item])).values()];
+    if(lost.length)notices.unshift(`Retention warning: to stay within the backup limits, the earliest backup of ${lost.length} file${lost.length===1?' was':'s were'} removed: ${lost.slice(-3).reverse().map(item=>`${displayPath(item.path,state.journal.options.home)} (from ${new Date(item.time).toLocaleString()})`).join('; ')}${lost.length>3?'; …':''}. Press S to keep a snapshot of the current files.`);
+  }catch{notices.push('Backup pruning record unreadable.');}
   const failure=takeSettingsCheckpointFailure(state.journal.directory);if(failure)notices.push(failure);
   for(const entry of state.entries){
-    for(const file of entry.files){const seen=state.journal.inspect(file);state.statuses.set(`${entry.id}:${file.path}`,seen.reason?`unsafe: ${seen.reason}`:seen.status);}
+    for(const file of entry.files){
+      const seen=state.journal.inspect(file);
+      // "Edited since" only when something other than NMSh changed it: a later NMSh write is named as such.
+      const later=seen.status==='edited since'&&laterWrite(state,entry,file.path);
+      state.statuses.set(`${entry.id}:${file.path}`,seen.reason?`unsafe: ${seen.reason}`:later?`changed later by NMSh (${later})`:seen.status);
+    }
     state.states.set(entry.id,state.journal.transactionState(entry));
   }
   const unfinished=state.entries.filter(entry=>needsReview(state.states.get(entry.id)!.state)).length;
@@ -50,7 +60,7 @@ export function changesKey(state:ChangesPanel,key:Key):{close?:true;paths?:strin
       }
       if(key.kind==='enter'&&state.entries[state.selected]){
         state.restore=planRestore(state.journal,state.entries[state.selected]!.id);
-        state.review={plan:state.restore,offset:0};state.view='review';state.shown=false;
+        state.review={plan:state.restore,offset:0,controls:[['↑↓','scroll diff'],state.restore.edited.length?['Enter','next: confirm overwrite']:['Enter','restore now'],['Esc','cancel']]};state.view='review';state.shown=false;
       }
     }else if(state.view==='review'){
       if(key.kind==='up'||key.kind==='down')state.review!.offset=Math.max(0,state.review!.offset+(key.kind==='up'?-1:1));
@@ -83,17 +93,21 @@ export function renderChangesPanel(state:ChangesPanel,columns:number,height:numb
   if(state.view==='confirm')return renderStudioReview(state.review!,'Confirm loss of later edits',columns,height);
   if(state.view==='result')return renderStudioReview(state.review!,'Changes · result',columns,height);
   return renderStudioLayout({title:'Changes & backups',subtitle:'Newest first · Enter reviews a restore · S snapshots known managed files',
-    entries:state.entries.length?state.entries.map(item=>({group:item.time.slice(0,10),label:item.label,
+    entries:state.entries.length?state.entries.map(item=>({group:localDay(item.time),label:item.label,
       render:width=>{
-        const states=item.files.map(file=>state.statuses.get(`${item.id}:${file.path}`));
+        const states=item.files.map(file=>state.statuses.get(`${item.id}:${file.path}`)?.replace(/ \(.*$/u,''));
+        const described=describeEntry(item,configDirectory(state));
         const report=state.states.get(item.id);
         const summary=report&&report.state!=='applied'?`${needsReview(report.state)?'! ':''}${describeState(report.state)}`
-          :states.includes('edited since')?'edited since':states.includes('missing')?'missing':states.some(value=>value!=='unchanged since')?'unsafe file':'unchanged since';
-        return studioWrap(`${item.time.slice(11,16)} ${item.source} · ${summary} · ${item.files.length} files · ${item.label}`,width)[0]!;
+          :states.includes('edited since')?'edited since':states.includes('missing')?'missing':states.some(value=>value?.startsWith('unsafe'))?'unsafe file'
+          :states.includes('changed later by NMSh')?'changed later by NMSh':'unchanged since';
+        return studioWrap(`${described.when} ${described.what} · ${described.action} · ${summary}`,width)[0]!;
       }})):[{group:'History',label:'No backups yet'}],
-    selected:state.selected,notice:state.message,details:(width,budget)=>entry?[...studioWrap(`${entry.time} · ${entry.source} · ${entry.label}`,width),
+    selected:state.selected,notice:state.message,details:(width,budget)=>entry?[
+      ...studioWrap(`${describeEntry(entry,configDirectory(state)).what} · ${new Date(entry.time).toLocaleString()} · ${entry.id.slice(0,15)}`,width),
+      ...studioWrap(`Recorded as: ${entry.source} · ${entry.label}`,width),
       ...stateDetails(state,entry).flatMap(line=>studioWrap(line,width)),
-      ...entry.files.flatMap(file=>studioWrap(`${file.path}: ${state.statuses.get(`${entry.id}:${file.path}`)}`,width))].slice(0,budget):[],
+      ...entry.files.flatMap(file=>studioWrap(`${displayPath(file.path,state.journal.options.home)} · ${applicationOf(file.path,configDirectory(state))} · ${fileAction(file)} · ${state.statuses.get(`${entry.id}:${file.path}`)}`,width))].slice(0,budget):[],
     controls:[['↑↓','select'],['Enter','review restore'],['S','snapshot now'],...(entry&&state.states.get(entry.id)?.state==='applied-unfinalized'?[['F','mark applied'] as const]:[]),...(entry&&needsReview(state.states.get(entry.id)?.state??'applied')?[['D','set aside'] as const]:[]),['Esc','close']]},columns,height);
 }
 
@@ -109,3 +123,14 @@ function stateDetails(state:ChangesPanel,entry:JournalEntry):string[] {
   lines.push(...report.reasons);
   return lines;
 }
+
+const configDirectory=(state:ChangesPanel)=>dirname(state.journal.directory);
+/** What history keeps, stated as the pruner implements it (see docs/development/native-appearance-welcome/BACKUPS_AND_RESET.md). */
+export const RETENTION='Keeps up to 200 entries / 64 MiB: each file\'s earliest backup, unfinished changes, the newest backup per file and the 20 newest resets, restores and snapshots. Anything else oldest-first; a removed earliest backup is reported here.';
+/** When the file now holds exactly what a newer NMSh entry wrote, the local time of that entry. */
+function laterWrite(state:ChangesPanel,entry:JournalEntry,path:string):string|undefined {
+  let now:string;
+  try {const current=snapshot(path,state.journal.options.home);now=current.content===undefined?'absent':digest(current.content);}catch{return undefined;}
+  const newer=state.entries.find(other=>other.time>entry.time&&other.files.some(file=>file.path===path&&file.afterHash===now));
+  return newer?new Date(newer.time).toLocaleString():undefined;
+}
diff --git a/src/backups/ResetPanel.ts b/src/backups/ResetPanel.ts
index 3b800271..fd64143c 100644
--- a/src/backups/ResetPanel.ts
+++ b/src/backups/ResetPanel.ts
@@ -19,13 +19,13 @@ export function resetKey(state:ResetPanel,key:Key):{close?:true;paths?:string[]}
       if(key.kind==='up'||key.kind==='down')state.index=Math.max(0,Math.min(state.areas.length-1,state.index+(key.kind==='up'?-1:1)));
       if(key.kind==='text'&&key.value===' '){const id=state.areas[state.index]!.id;if(state.selected.has(id))state.selected.delete(id);else state.selected.add(id);}
       if(key.kind==='enter'&&state.selected.size){
-        state.plan=planReset(state.areas,state.selected,state.context);state.review={offset:0,plan:{preview:state.plan.preview,guidance:'Only recorded NMSh changes are reset. User lines are kept. Enter advances to Backup; nothing is written.'}};
+        state.plan=planReset(state.areas,state.selected,state.context);state.review={offset:0,plan:{preview:state.plan.preview,guidance:'Only recorded NMSh changes are reset. User lines are kept. Enter advances to Backup; nothing is written.'},controls:[['↑↓','scroll'],['Enter','next: backup'],['Esc','cancel']]};
         state.step='impact';state.shown=false;
       }
     }else if(state.step==='impact'){
       if(key.kind==='up'||key.kind==='down')state.review!.offset=Math.max(0,state.review!.offset+(key.kind==='up'?-1:1));
       if(key.kind==='enter'&&state.review?.shown){state.step='backup';state.shown=false;state.review={offset:0,plan:{preview:[`Backup directory: ${state.journal.directory}`, 'Includes files changed by the reset and their ownership records.',
-        ...state.plan!.changes.map(change=>change.before.path)],guidance:'Backup must be written, read back and hash verified before any reset. Enter advances to final typed confirmation.'}};}
+        ...state.plan!.changes.map(change=>change.before.path)],guidance:'Backup must be written, read back and hash verified before any reset. Enter advances to final typed confirmation; nothing is written yet.'},controls:[['↑↓','scroll'],['Enter','next: type reset'],['Esc','cancel']]};}
     }else if(state.step==='backup'){
       if(key.kind==='up'||key.kind==='down')state.review!.offset=Math.max(0,state.review!.offset+(key.kind==='up'?-1:1));
       if(key.kind==='enter'&&state.review?.shown){state.step='confirm';state.shown=false;state.message='Review complete. Type reset exactly, then Enter; Esc cancels.';}
@@ -61,8 +61,9 @@ export function renderResetPanel(state:ResetPanel,columns:number,height:number):
     controls:[['Enter','reset if word matches'],['Esc','cancel']]},columns,height);
   if(state.step==='result')return renderStudioReview(state.review!,'Reset · results',columns,height);
   return renderStudioLayout({title:'Step 1 · Choose reset areas',subtitle:'Space toggles · nothing is selected by default',selected:state.index,
-    entries:state.areas.map(item=>({group:item.id==='settings'?'NMSh settings':'Owned integrations',label:item.label,
+    entries:state.areas.map(item=>({group:item.settingsScope?'NMSh settings':'Owned integrations',label:item.label,
       render:()=>`${checkMark(state.selected.has(item.id))} ${item.label} · ${item.status}`})),
-    notice:state.message,details:width=>studioWrap(state.areas[state.index]?.reason??'Only NMSh-owned changes are offered; unrelated user lines are kept.',width),
+    notice:state.message,details:(width,budget)=>{const item=state.areas[state.index];
+      return (item?.reason?[item.reason]:item?.summary??['Only NMSh-owned changes are offered; unrelated user lines are kept.']).flatMap(line=>studioWrap(line,width)).slice(0,budget);},
     controls:[['↑↓','select'],['Space','toggle'],['Enter','impact'],['Esc','cancel']]},columns,height);
 }
diff --git a/src/backups/describe.ts b/src/backups/describe.ts
index 042c6cdb..6d7ef924 100644
--- a/src/backups/describe.ts
+++ b/src/backups/describe.ts
@@ -1,4 +1,5 @@
-import type {TransactionState} from './journal.js';
+import {basename, join, relative, sep} from 'node:path';
+import {ABSENT_HASH, type JournalEntry, type JournalFile, type TransactionState} from './journal.js';
 
 /** Plain words for a reconciled transaction state; the same wording in history, details and restore review. */
 export function describeState(state: TransactionState): string {
@@ -19,3 +20,78 @@ export function describeState(state: TransactionState): string {
 
 /** Whether an entry needs the user's review before it can be trusted as finished. */
 export const needsReview = (state: TransactionState) => !['applied', 'reverted', 'in-progress', 'reviewed'].includes(state);
+
+
+/** `~/…` inside the home; the absolute path elsewhere. */
+export function displayPath(path: string, home: string): string {
+  const inside = relative(home, path);
+  return inside && !inside.startsWith('..') && !inside.startsWith(sep) ? `~/${inside}` : path;
+}
+
+/** The application a configuration file belongs to, from its location only (nothing is read). */
+export function applicationOf(path: string, configDirectory: string): string {
+  const own = relative(configDirectory, path);
+  if (own && !own.startsWith('..')) {
+    if (own === 'config.json') return 'NMSh settings';
+    if (own === join('theme-bridge', 'ledger.json')) return 'Theme Bridge record';
+    if (own.startsWith(join('theme-bridge', 'vim'))) return 'Vim colors';
+    if (own.startsWith(join('theme-bridge', 'nvim'))) return 'Neovim colors';
+    if (own.startsWith(join('theme-bridge', 'tmux'))) return 'tmux';
+    if (own.startsWith(join('theme-bridge', 'vivid'))) return 'File listing colors';
+    if (own.startsWith('agent-context')) return 'Claude Code status line';
+    if (/kitty/u.test(own)) return /shader/u.test(own) ? 'Kitty shaders' : 'Kitty';
+    if (/ghostty/u.test(own)) return /shader|glsl/u.test(own) ? 'Ghostty shaders' : 'Ghostty';
+    return 'NMSh';
+  }
+  const lower = path.toLowerCase(), name = basename(lower);
+  if (lower.includes(`${sep}kitty${sep}`) || name.startsWith('kitty')) return 'Kitty';
+  if (lower.includes('ghostty')) return 'Ghostty';
+  if (lower.includes(`${sep}nvim${sep}`)) return 'Neovim';
+  if (name === '.vimrc' || lower.includes(`${sep}.vim${sep}`) || lower.includes(`${sep}vim${sep}`)) return 'Vim';
+  if (lower.includes(`${sep}helix${sep}`)) return 'Helix';
+  if (lower.includes(`${sep}bat${sep}`)) return 'bat';
+  if (name.includes('tmux')) return 'tmux';
+  if (name === 'starship.toml') return 'Starship';
+  if (name === '.zshrc' || name === '.zprofile') return 'zsh';
+  if (name === '.bashrc' || name === '.bash_profile') return 'Bash';
+  if (lower.includes(`${sep}fish${sep}`)) return 'Fish';
+  if (lower.includes(`${sep}.claude${sep}`)) return 'Claude Code';
+  return basename(path);
+}
+
+export type FileAction = 'created' | 'changed' | 'removed' | 'checkpoint';
+export function fileAction(file: JournalFile): FileAction {
+  if (file.beforeHash === file.afterHash && (file.afterMode === undefined || file.afterMode === file.mode)) return 'checkpoint';
+  if (!file.existed) return 'created';
+  return file.afterHash === ABSENT_HASH ? 'removed' : 'changed';
+}
+
+const KIND: Record<string, string> = {reset: 'Reset', restore: 'Restore', manual: 'Manual snapshot', settings: 'Daily settings checkpoint'};
+/** NMSh's own bookkeeping files are mentioned, but never named as the thing a change was about. */
+const bookkeeping = (path: string, configDirectory: string) => {
+  const own = relative(configDirectory, path);
+  return own === 'config.json' || own === join('theme-bridge', 'ledger.json') || (!own.startsWith('..') && own.endsWith('.json') && !own.includes(sep + 'agent-context'));
+};
+
+/** One readable line per entry: when, which application and file, what happened. Labels stay as secondary detail. */
+export function describeEntry(entry: JournalEntry, configDirectory: string): {when: string; what: string; action: string} {
+  const date = new Date(entry.time);
+  const pad = (value: number) => String(value).padStart(2, '0');
+  const when = Number.isNaN(date.getTime()) ? entry.time : `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+  const primary = entry.files.find(file => !bookkeeping(file.path, configDirectory) && fileAction(file) !== 'checkpoint')
+    ?? entry.files.find(file => fileAction(file) !== 'checkpoint') ?? entry.files[0];
+  const others = entry.files.filter(file => file !== primary && fileAction(file) !== 'checkpoint').length;
+  const target = primary ? `${applicationOf(primary.path, configDirectory)} · ${basename(primary.path)}${others ? ` +${others} more` : ''}` : 'no files';
+  const kind = KIND[entry.source];
+  const what = kind ? `${kind}${entry.source === 'manual' ? ` of ${entry.files.length} files` : ` · ${target}`}` : target;
+  const actions = new Set(entry.files.map(fileAction).filter(action => action !== 'checkpoint'));
+  const action = !actions.size ? 'checkpoint' : actions.size === 1 ? [...actions][0]! : 'changed';
+  return {when, what, action};
+}
+
+/** Local calendar day for grouping history. */
+export function localDay(time: string): string {
+  const date = new Date(time);
+  if (Number.isNaN(date.getTime())) return time.slice(0, 10);
+  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
+}
diff --git a/src/backups/journal.ts b/src/backups/journal.ts
index 96e6e88c..931303e9 100644
--- a/src/backups/journal.ts
+++ b/src/backups/journal.ts
@@ -203,6 +203,13 @@ export class Journal {
     const record = JSON.parse(text);
     return Number.isSafeInteger(record.count) && record.count >= 0 ? record.count : 0;
   }
+  /** Original backups (the earliest kept copy of a file) that capacity pressure removed, newest last. Shown in /changes. */
+  lostOriginals(): Array<{path: string; time: string}> {
+    const text = snapshot(join(this.directory, '.pruned.json'), this.options.home).content;
+    if (text === undefined) return [];
+    const record = JSON.parse(text);
+    return Array.isArray(record?.lostOriginals) ? record.lostOriginals.filter((item: {path?: unknown; time?: unknown}) => typeof item?.path === 'string' && typeof item?.time === 'string').slice(-50) : [];
+  }
   provenanceComplete(source:string,path:string):boolean {
     return !this.prunedKeys().has(digest(`${source}:${path}`));
   }
@@ -319,11 +326,14 @@ export class Journal {
     }
     // The oldest backup of each file holds what it was before NMSh first changed it: a burst of automatic writes to other
     // files (cursor shaders regenerate often) must not push that original out. It goes only when nothing else can.
-    const originals = new Set<string>(), originalPaths = new Set<string>();
+    const originals = new Set<string>(), originalOf = new Map<string, string>();
     for (const item of [...existing].reverse()) for (const file of item.files) {
-      if (!originalPaths.has(file.path)) { originals.add(item.id); originalPaths.add(file.path); }
+      if (!originalOf.has(file.path)) { originals.add(item.id); originalOf.set(file.path, item.id); }
     }
-    const markerText = () => JSON.stringify({keys:[...pruned],count:previousCount+victims.length});
+    const previousLost = this.lostOriginals();
+    // Losing an original is never silent: the path and the time of the copy that went are kept (bounded) and shown in /changes.
+    const lost = () => victims.flatMap(old => old.files.filter(file => originalOf.get(file.path) === old.id).map(file => ({path: file.path, time: old.time})));
+    const markerText = () => JSON.stringify({keys:[...pruned],count:previousCount+victims.length,lostOriginals:[...previousLost,...lost()].slice(-50)});
     const fits = () => used + size + (victims.length ? Buffer.byteLength(markerText()) - oldMarker : 0) <= maxBytes && count + 1 <= maxEntries;
     for (const lastResort of [false, true]) for (const old of [...existing].reverse()) {
       if (fits()) break;
diff --git a/src/backups/reset.ts b/src/backups/reset.ts
index 9f6eccbe..be545005 100644
--- a/src/backups/reset.ts
+++ b/src/backups/reset.ts
@@ -10,12 +10,16 @@ import {planGhosttyShaderRemoval,ghosttyShaderPaths} from '../appearance/ghostty
 import {planClaudeBridgeRemoval} from '../agents/claudeStatusLine.js';
 import {artifactPath, ledgerPath, loadLedger, ownership, planHookRemoval, type ManagedTarget, type HookTarget} from '../themeBridge/artifacts.js';
 import {nmshConfigDirectory} from '../configuration/paths.js';
-import {DEFAULT_PROMPT_CONFIGURATION} from '../prompt/configuration.js';
+import {planSettingsReset, SCOPE_LABELS, SETTINGS_SCOPES, type SettingsScope} from './settingsReset.js';
 import {Journal, type JournalEntry} from './journal.js';
 import {changeDiff} from './diff.js';
 import type {FileEditPlan} from '../ask/fileEdit.js';
 
-export interface ResetArea {id: string; label: string; status: 'set up' | 'not set up' | 'nothing to reset'; changes: FileChange[]; dependencies: FileSnapshot[]; reason?: string}
+export interface ResetArea {id: string; label: string; status: 'set up' | 'not set up' | 'nothing to reset'; changes: FileChange[]; dependencies: FileSnapshot[]; reason?: string;
+  /** Readable before → after values shown above the exact diff. */
+  summary?: string[];
+  /** NMSh's own settings: scopes selected together are planned as one change to config.json. */
+  settingsScope?: SettingsScope}
 export interface ResetPlan {areas: ResetArea[]; changes: FileChange[]; dependencies: FileSnapshot[]; preview: string[]; steps: Array<{area: ResetArea; changes: FileChange[]}>}
 const homeOf = (context: AppearanceContext) => context.env.HOME || homedir();
 function editChange(plan: FileEditPlan, home: string): FileChange {
@@ -26,9 +30,9 @@ function editChange(plan: FileEditPlan, home: string): FileChange {
   if (digest(after) !== plan.resultSha256) throw new Error('Removal did not match the reviewed result.');
   return {before,after};
 }
-function area(id: string,label: string,build:()=>{changes: readonly FileChange[]; dependencies?: readonly FileSnapshot[]}): ResetArea {
+function area(id: string,label: string,build:()=>{changes: readonly FileChange[]; dependencies?: readonly FileSnapshot[]; summary?: string[]}): ResetArea {
   try {const plan=build();const changes=plan.changes.filter(change=>change.after!==change.before.content);
-    return {id,label,status:changes.length?'set up':'nothing to reset',changes,dependencies:[...(plan.dependencies??[])]};
+    return {id,label,status:changes.length?'set up':'nothing to reset',changes,dependencies:[...(plan.dependencies??[])],...(plan.summary?{summary:plan.summary}:{})};
   } catch(error) {return {id,label,status:'not set up',changes:[],dependencies:[],reason:error instanceof Error?error.message:String(error)};}
 }
 /** A legacy adapter without a ledger can be reset only with an applied journal record and an exact after hash. */
@@ -112,9 +116,19 @@ export function discoverResetAreas(context: AppearanceContext,journal: Journal):
       const result=planClaudeBridgeRemoval(env);if('refuse' in result)throw new Error(result.refuse);if('noop' in result)return {changes:[]};
       return {changes:[editChange(result.plan,home),{before:snapshot(join(nmshConfigDirectory(env),'agent-context/claude-status-line.json'),home,true)}]};
     }),
-    area('settings','NMSh settings (config.json) → defaults',()=>({changes:[{before:snapshot(join(nmshConfigDirectory(env),'config.json'),home,true),after:`${JSON.stringify(DEFAULT_PROMPT_CONFIGURATION,null,2)}\n`}]})),
+    ...SETTINGS_SCOPES.map(scope=>({...settingsArea(env,home,new Set([scope])),settingsScope:scope})),
   ];
 }
+const settingsId=(scope:SettingsScope)=>scope==='preferences'?'settings':`settings-${scope}`;
+function settingsArea(env:NodeJS.ProcessEnv,home:string,scopes:ReadonlySet<SettingsScope>):ResetArea {
+  const list=SETTINGS_SCOPES.filter(scope=>scopes.has(scope));
+  const label=list.length===1?SCOPE_LABELS[list[0]!]:`NMSh settings: ${list.map(scope=>({preferences:'preferences',onboarding:'first-run state',updates:'update policy'})[scope]).join(', ')} → defaults`;
+  return area(list.map(settingsId).join('+'),label,()=>{
+    const before=snapshot(join(nmshConfigDirectory(env),'config.json'),home,true);
+    const plan=planSettingsReset(before.content,scopes);
+    return {changes:[{before,after:plan.after,afterMode:0o600}],summary:plan.summary};
+  });
+}
 interface Splice {start:number;end:number;text:string}
 function splice(before:string,after:string):Splice {
   // Whole-line boundaries keep adjacent includes disjoint even when their text shares a long prefix.
@@ -126,7 +140,14 @@ function splice(before:string,after:string):Splice {
 }
 /** Merge disjoint edits against the same captured file, so two areas can remove two includes safely. */
 export function planReset(areas: ResetArea[], selected: ReadonlySet<string>, context: AppearanceContext): ResetPlan {
-  const chosen=areas.filter(item=>selected.has(item.id));const byPath=new Map<string,{before:FileSnapshot;patches:Splice[];mode?:number}>();
+  let chosen=areas.filter(item=>selected.has(item.id));
+  // Several settings scopes edit the same file: plan them together, so their before → after values are exact and never overlap.
+  const scopes=chosen.filter(item=>item.settingsScope);
+  if(scopes.length>1){
+    const merged=settingsArea(context.env,homeOf(context),new Set(scopes.map(item=>item.settingsScope!)));
+    const at=chosen.indexOf(scopes[0]!);
+    chosen=chosen.filter(item=>!item.settingsScope);chosen.splice(at,0,merged);
+  }const byPath=new Map<string,{before:FileSnapshot;patches:Splice[];mode?:number}>();
   const steps:ResetPlan['steps']=[];const preview:string[]=[];const virtual=new Map<string,string|undefined>();
   for(const item of chosen){
     if(item.reason||!item.changes.length){preview.push(`${item.label}: skipped: ${item.reason??'nothing to reset'}`);continue;}
@@ -143,7 +164,7 @@ export function planReset(areas: ResetArea[], selected: ReadonlySet<string>, con
       stepChanges.push({before,after,afterMode:change.afterMode});virtual.set(change.before.path,after);
       byPath.set(change.before.path,{before:prior?.before??change.before,patches,mode:change.afterMode});
     }
-    steps.push({area:item,changes:stepChanges});preview.push(item.label,...stepChanges.flatMap(change=>changeDiff(change).lines));
+    steps.push({area:item,changes:stepChanges});preview.push(item.label,...(item.summary??[]),...stepChanges.flatMap(change=>changeDiff(change).lines));
   }
   const changes=[...byPath].map(([path,value])=>({before:value.before,after:virtual.get(path),afterMode:value.mode}));
   return {areas:chosen,changes,dependencies:chosen.flatMap(item=>item.dependencies),preview,steps};
@@ -151,23 +172,36 @@ export function planReset(areas: ResetArea[], selected: ReadonlySet<string>, con
 export function applyReset(plan:ResetPlan,journal:Journal):{entry?:JournalEntry;results:string[];paths:string[]} {
   if(!plan.steps.length||!plan.changes.length)return {results:['Nothing to reset'],paths:[]};
   for(const file of [...plan.dependencies,...plan.changes.map(change=>change.before)])unchanged(file,journal.options.home,true);
-  const entry=journal.record(plan.changes,'reset',`Reset ${plan.steps.map(step=>step.area.label).join(', ')}`);
-  for(const file of [...plan.dependencies,...plan.changes.map(change=>change.before)])unchanged(file,journal.options.home,true);
   const results=plan.areas.filter(area=>area.reason||!area.changes.length).map(area=>`${area.label}: skipped: ${area.reason??'nothing to reset'}`);
   const paths:string[]=[];
+  const current=(step:ResetPlan['steps'][number])=>step.changes.map(change=>{
+    const now=snapshot(change.before.path,journal.options.home,true);
+    if(now.content!==change.before.content)throw new Error('Configuration changed during reset; remaining areas were kept.');
+    return {...change,before:now};
+  });
+  // One area is one transaction: its own entry is the checkpoint (a separate checkpoint would only duplicate it).
+  if(plan.steps.length===1){
+    const step=plan.steps[0]!;
+    const entry=transact(current(step),plan.dependencies,journal.options.home,{source:'reset',label:`Reset ${step.area.label}`,directory:journal.directory});
+    results.push(`${step.area.label}: done`);
+    return {entry,results,paths:[...new Set(step.changes.map(change=>change.before.path))]};
+  }
+  // Several areas: one checkpoint of every file first, then one linked stage per area (each stage has its own before-images,
+  // because an earlier stage may have changed the same file).
+  const entry=journal.record(plan.changes,'reset',`Reset checkpoint: ${plan.steps.map(step=>step.area.label).join(', ')}`);
+  try {for(const file of [...plan.dependencies,...plan.changes.map(change=>change.before)])unchanged(file,journal.options.home,true);}
+  catch(error){try{journal.resolve(entry,{state:'reverted',detail:`${error instanceof Error?error.message:String(error)} No file was changed.`});}catch{/* original error wins */}throw error;}
+  let failed=false;
   for(const [stepIndex,step] of plan.steps.entries()){
     try {
-      const changes=step.changes.map(change=>{
-        const current=snapshot(change.before.path,journal.options.home,true);
-        if(current.content!==change.before.content)throw new Error('Configuration changed during reset; remaining areas were kept.');
-        return {...change,before:current};
-      });
-      transact(changes,[],journal.options.home,{source:'reset',label:step.area.label,directory:journal.directory});
+      const changes=current(step);
+      transact(changes,[],journal.options.home,{source:'reset',label:`Reset stage ${stepIndex+1}/${plan.steps.length}: ${step.area.label}`,directory:journal.directory,group:entry.id});
       results.push(`${step.area.label}: done`);paths.push(...changes.map(change=>change.before.path));
-    }catch(error){results.push(`${step.area.label}: failed: ${error instanceof Error?error.message:String(error)}`);results.push(...plan.steps.slice(stepIndex+1).map(next=>`${next.area.label}: skipped: an earlier area failed`));break;}
+    }catch(error){failed=true;results.push(`${step.area.label}: failed: ${error instanceof Error?error.message:String(error)}`);results.push(...plan.steps.slice(stepIndex+1).map(next=>`${next.area.label}: skipped: an earlier area failed`));break;}
   }
-  // A partially applied reset remains a prepared checkpoint, and is still restorable.
-  try {journal.complete(entry);}catch{/* per-area results remain authoritative */}
+  // A partially applied reset stays restorable and says so; a complete one verifies every file.
+  try {if(failed)throw new Error('partial');journal.complete(entry);}
+  catch{try{journal.resolve(entry,{state:'partial',detail:results.join('; ')});}catch{/* per-area results remain authoritative */}}
   return {entry,results,paths:[...new Set(paths)]};
 }
 export function ownedSnapshotPaths(context:AppearanceContext,journal:Journal):string[] {
diff --git a/src/backups/settingsReset.ts b/src/backups/settingsReset.ts
new file mode 100644
index 00000000..2e036e24
--- /dev/null
+++ b/src/backups/settingsReset.ts
@@ -0,0 +1,85 @@
+/**
+ * Scoped reset of NMSh's own settings file. Each scope names exactly which top-level keys it returns to their defaults, so a
+ * reset of visual and general preferences never also re-runs onboarding or changes the update policy. Everything else in
+ * config.json (the user's themes and presets, fields this version does not know) is kept byte-for-value.
+ */
+import {DEFAULT_PROMPT_CONFIGURATION, normalizePromptConfiguration} from '../prompt/configuration.js';
+
+export type SettingsScope = 'preferences' | 'onboarding' | 'updates';
+export const SETTINGS_SCOPES: readonly SettingsScope[] = ['preferences', 'onboarding', 'updates'];
+export const SCOPE_LABELS: Record<SettingsScope, string> = {
+  preferences: 'NMSh preferences → defaults (keeps first-run state, update policy and your themes)',
+  onboarding: 'First-run state → show setup again (onboarding, glyph choice, tools setup)',
+  updates: 'Update policy → default (Automatic, daily)',
+};
+const ONBOARDING = ['onboardingComplete', 'introSeen', 'toolsSetupComplete', 'glyphStyle', 'glyphChoiceComplete'];
+const UPDATES = ['updateMode', 'updateFrequency'];
+/** The user's own content in config.json: never part of a settings reset. */
+const USER_CONTENT = ['themes', 'customTheme', 'welcomePresets', 'agentProfiles'];
+/** Known optional preference keys with no default value: a preferences reset removes them. */
+const OPTIONAL_PREFERENCES = ['startingPoint', 'promptSymbolCustom'];
+const DEFAULTS = DEFAULT_PROMPT_CONFIGURATION as unknown as Record<string, unknown>;
+const KNOWN = new Set([...Object.keys(DEFAULTS), ...OPTIONAL_PREFERENCES, ...USER_CONTENT]);
+
+export function scopeKeys(scope: SettingsScope): string[] {
+  if (scope === 'onboarding') return ONBOARDING;
+  if (scope === 'updates') return UPDATES;
+  return [...Object.keys(DEFAULTS), ...OPTIONAL_PREFERENCES].filter(key => !ONBOARDING.includes(key) && !UPDATES.includes(key) && !USER_CONTENT.includes(key));
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null && !Array.isArray(value);
+const show = (value: unknown) => value === undefined ? '(not set)' : JSON.stringify(value);
+const clip = (text: string) => text.length > 96 ? `${text.slice(0, 95)}…` : text;
+
+/** Leaf-level differences, at most three levels deep, as `path: before → after`. */
+function differences(path: string, before: unknown, after: unknown, depth = 0): string[] {
+  if (JSON.stringify(before) === JSON.stringify(after)) return [];
+  if (depth < 2 && isRecord(before) && isRecord(after)) {
+    return [...new Set([...Object.keys(before), ...Object.keys(after)])].flatMap(key => differences(`${path}.${key}`, before[key], after[key], depth + 1));
+  }
+  return [`${path}: ${clip(show(before))} → ${clip(show(after))}`];
+}
+
+export interface SettingsResetPlan {after: string | undefined; summary: string[]; changed: number}
+
+/** Pure: plans the selected scopes against the current file text. Malformed settings are never guessed at. */
+export function planSettingsReset(text: string | undefined, scopes: ReadonlySet<SettingsScope>): SettingsResetPlan {
+  if (text === undefined) return {after: undefined, summary: ['There is no config.json yet: NMSh already uses its defaults.'], changed: 0};
+  let current: Record<string, unknown>;
+  {
+    let parsed: unknown;
+    try { parsed = JSON.parse(text); } catch { throw new Error('config.json is not valid JSON; NMSh will not guess at a reset. Fix or move it first.'); }
+    if (!isRecord(parsed)) throw new Error('config.json is not a settings object; NMSh will not guess at a reset. Fix or move it first.');
+    current = parsed;
+  }
+  const next: Record<string, unknown> = structuredClone(current);
+  const keys = [...scopes].flatMap(scopeKeys);
+  // A kept scope keeps its meaning, not only its bytes: an absent key whose effective value is derived from other settings
+  // (legacy update or onboarding fields) is written out as the value it has now, so the reset cannot change it indirectly.
+  const effective = normalizePromptConfiguration(current) as unknown as Record<string, unknown>;
+  const pinned: string[] = [];
+  for (const scope of ['onboarding', 'updates'] as const) if (!scopes.has(scope)) for (const key of scopeKeys(scope)) {
+    if (!(key in current) && effective[key] !== undefined) { next[key] = structuredClone(effective[key]); pinned.push(key); }
+  }
+  for (const key of keys) {
+    if (key in DEFAULTS) next[key] = structuredClone(DEFAULTS[key]);
+    else delete next[key];
+  }
+  const changes = keys.flatMap(key => differences(key, current[key], next[key]));
+  const kept = (scope: SettingsScope) => !scopes.has(scope);
+  const keptValues = (list: string[]) => list.filter(key => key in current).map(key => `${key} ${show(current[key])}`).join(', ') || 'defaults';
+  const unknown = Object.keys(current).filter(key => !KNOWN.has(key));
+  const themes = Array.isArray(current.themes) ? current.themes.length : 0;
+  const presets = Array.isArray(current.welcomePresets) ? current.welcomePresets.length : 0;
+  const summary = [
+    changes.length ? `Settings that change (${changes.length}):` : 'Settings already match their defaults for this scope.',
+    ...changes.map(line => `  ${line}`),
+    ...(kept('onboarding') ? [`Kept: first-run state (${keptValues(ONBOARDING)}).`] : []),
+    ...(kept('updates') ? [`Kept: update policy (${keptValues(UPDATES)}).`] : []),
+    `Kept: your themes (${themes}) and welcome presets (${presets}).`,
+    ...(unknown.length ? [`Kept: ${unknown.length} field${unknown.length === 1 ? '' : 's'} this version does not know (${unknown.slice(0, 6).join(', ')}${unknown.length > 6 ? ', …' : ''}).`] : []),
+  ];
+  const after = `${JSON.stringify(next, null, 2)}\n`;
+  if (changes.length && pinned.length) summary.push(`Written out to keep their current meaning: ${pinned.map(key => `${key} ${show(effective[key])}`).join(', ')}.`);
+  return {after: changes.length ? after : text, summary, changed: changes.length};
+}
diff --git a/tests/backupsIntegrity.test.ts b/tests/backupsIntegrity.test.ts
index 3faa0118..75b77324 100644
--- a/tests/backupsIntegrity.test.ts
+++ b/tests/backupsIntegrity.test.ts
@@ -299,7 +299,7 @@ test('a conflicted interrupted entry can be set aside without touching files; a
   changesKey(panel, {kind: 'text', value: 'd'});
   assert.equal(f.journal.transactionState(f.journal.read(entry!.id)).state, 'reviewed');
   assert.equal(readFileSync(f.one, 'utf8'), 'later edit\n'); assert.equal(readFileSync(f.two, 'utf8'), 'two-before\n');
-  assert.doesNotMatch(createChangesPanel(f.journal, []).message, /unfinished/u);
+  assert.doesNotMatch(createChangesPanel(f.journal, []).message, /unfinished changes? needs? review/u);
   const sleeper = spawn('sleep', ['30']); t.after(() => sleeper.kill());
   const pending = f.journal.record([{before: snapshot(f.two, f.home), after: 'x'}], 'appearance', 'Live writer');
   writeFileSync(join(f.journal.directory, pending.id, 'owner.json'), JSON.stringify({owner: 'nmsh-journal', version: 1, pid: sleeper.pid}));
diff --git a/tests/backupsPanels.test.ts b/tests/backupsPanels.test.ts
index bb487790..95f9e65b 100644
--- a/tests/backupsPanels.test.ts
+++ b/tests/backupsPanels.test.ts
@@ -38,7 +38,7 @@ test('history requires a shown review and a separate confirmation for later edit
  assert.equal(readFileSync(f.path,'utf8'),'before');assert.equal(state.view,'result');
 });
 test('reset cannot write without selected areas, impact, backup and exact typed word',t=>{
- const f=fixture(t);let state=createResetPanel({env:f.env,platform:'linux'},f.journal);
+ const f=fixture(t);const config=join(f.home,'.config/nmsh/config.json');writeFileSync(config,'{"composerPosition":"top"}\n');let state=createResetPanel({env:f.env,platform:'linux'},f.journal);
  assert.equal(state.selected.size,0);resetKey(state,enter);assert.equal(state.step,'choose');
  const settings=state.areas.findIndex(x=>x.id==='settings');state.index=settings;resetKey(state,{kind:'text',value:' '});
  resetKey(state,enter);assert.equal(state.step,'impact');
@@ -46,13 +46,13 @@ test('reset cannot write without selected areas, impact, backup and exact typed
  renderResetPanel(state,80,24);resetKey(state,enter);assert.equal(state.step,'backup');
  renderResetPanel(state,80,24);resetKey(state,enter);assert.equal(state.step,'confirm');
  renderResetPanel(state,80,24);resetKey(state,{kind:'text',value:'RESET'});resetKey(state,enter);
- assert.equal(existsSync(join(f.home,'.config/nmsh/config.json')),false);
+ assert.equal(readFileSync(config,'utf8'),'{"composerPosition":"top"}\n');
  assert.equal(state.step,'result');
  state=createResetPanel({env:f.env,platform:'linux'},f.journal);state.index=settings;resetKey(state,{kind:'text',value:' '});resetKey(state,enter);
  renderResetPanel(state,80,24);resetKey(state,enter);renderResetPanel(state,80,24);resetKey(state,enter);renderResetPanel(state,80,24);
  resetKey(state,{kind:'text',value:'reset'});resetKey(state,enter);
  assert.equal(state.step,'result');assert.match(state.message,/Undo: \/changes/u);
- assert.equal(existsSync(join(f.home,'.config/nmsh/config.json')),true);
+ assert.equal(JSON.parse(readFileSync(config,'utf8')).composerPosition,'bottom');
 });
 test('reset preserves user lines with overlapping owned plans, reports skips and stale review',t=>{
  const f=fixture(t);const context={env:f.env,platform:'linux' as const};
@@ -63,6 +63,7 @@ test('reset preserves user lines with overlapping owned plans, reports skips and
  resetKey(state,enter);renderResetPanel(state,120,40);assert.match(state.review!.plan.preview.join('\n'),/kept|skipped/u);
  resetKey(state,enter);renderResetPanel(state,120,40);resetKey(state,enter);renderResetPanel(state,120,40);resetKey(state,{kind:'text',value:'reset'});resetKey(state,enter);
  assert.equal(readFileSync(plan.plan.hostPath,'utf8'),'# personal\r\n');assert.match(state.results.join('\n'),/done|skipped/u);
+ writeFileSync(join(f.home,'.config/nmsh/config.json'),'{"composerPosition":"top"}\n');
  const stale=createResetPanel(context,f.journal);stale.selected.add('settings');resetKey(stale,enter);
  renderResetPanel(stale,80,24);resetKey(stale,enter);renderResetPanel(stale,80,24);resetKey(stale,enter);renderResetPanel(stale,80,24);
  writeFileSync(join(f.home,'.config/nmsh/config.json'),'concurrent');resetKey(stale,{kind:'text',value:'reset'});resetKey(stale,enter);
diff --git a/tests/backupsResetScope.test.ts b/tests/backupsResetScope.test.ts
new file mode 100644
index 00000000..025a8c75
--- /dev/null
+++ b/tests/backupsResetScope.test.ts
@@ -0,0 +1,183 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {dirname, join} from 'node:path';
+import {Journal} from '../src/backups/journal.js';
+import {snapshot, transact} from '../src/appearance/hostFiles.js';
+import {applyReset, discoverResetAreas, planReset, type ResetArea} from '../src/backups/reset.js';
+import {planSettingsReset} from '../src/backups/settingsReset.js';
+import {planRestore, restore} from '../src/backups/restore.js';
+import {createResetPanel, renderResetPanel, resetKey} from '../src/backups/ResetPanel.js';
+import {createChangesPanel, renderChangesPanel} from '../src/backups/ChangesPanel.js';
+import {normalizePromptConfiguration} from '../src/prompt/configuration.js';
+import {writeArtifact} from '../src/themeBridge/artifacts.js';
+import {stripAnsi} from '../src/util/text.js';
+
+type T = {after(fn: () => void): void};
+function box(t: T, settings?: Record<string, unknown> | string) {
+  const home = realpathSync(mkdtempSync(join(tmpdir(), 'reset-scope-')));
+  t.after(() => rmSync(home, {recursive: true, force: true}));
+  const env = {HOME: home, XDG_CONFIG_HOME: join(home, '.config')};
+  const config = join(home, '.config/nmsh/config.json');
+  mkdirSync(dirname(config), {recursive: true});
+  if (settings !== undefined) writeFileSync(config, typeof settings === 'string' ? settings : `${JSON.stringify(settings, null, 2)}\n`, {mode: 0o600});
+  const journal = new Journal({home, directory: join(home, '.config/nmsh/backups')});
+  return {home, env, config, journal, context: {env, platform: 'linux' as const}};
+}
+const USER = {onboardingComplete: true, introSeen: true, toolsSetupComplete: true, glyphStyle: 'unicode', glyphChoiceComplete: true,
+  updateMode: 'notify', updateFrequency: 'weekly', composerPosition: 'top', sessionNotices: false,
+  themes: [{id: 'mine', name: 'Mine'}], welcomePresets: [{id: 'p'}], futureField: {kept: 1}};
+const enter = {kind: 'enter'} as const;
+const text = (lines: string[]) => stripAnsi(lines.join('\n')).replace(/\s+/gu, ' ');
+const select = (b: ReturnType<typeof box>, ids: string[]) => planReset(discoverResetAreas(b.context, b.journal), new Set(ids), b.context);
+
+test('D7: resetting preferences keeps first-run state, the update policy, themes and unknown fields, and shows exact values', t => {
+  const b = box(t, USER);
+  const plan = select(b, ['settings']);
+  const preview = plan.preview.join('\n');
+  assert.match(preview, /composerPosition: "top" → "bottom"/u);
+  assert.match(preview, /sessionNotices: false → true/u);
+  assert.match(preview, /Kept: first-run state \(onboardingComplete true, .*glyphStyle "unicode"/u);
+  assert.match(preview, /Kept: update policy \(updateMode "notify", updateFrequency "weekly"\)/u);
+  assert.match(preview, /Kept: your themes \(1\) and welcome presets \(1\)/u);
+  assert.match(preview, /Kept: 1 field this version does not know \(futureField\)/u);
+  assert.doesNotMatch(preview, /updateMode: .*→/u);
+  applyReset(plan, b.journal);
+  const after = JSON.parse(readFileSync(b.config, 'utf8'));
+  assert.equal(after.updateMode, 'notify', 'never enables automatic updates as a side effect');
+  assert.equal(after.updateFrequency, 'weekly');
+  assert.equal(after.onboardingComplete, true); assert.equal(after.glyphStyle, 'unicode');
+  assert.deepEqual(after.themes, USER.themes); assert.deepEqual(after.futureField, {kept: 1});
+  assert.equal(after.composerPosition, 'bottom');
+});
+
+test('D7: update policy and first-run state reset only when chosen, and together form one exact change', t => {
+  const b = box(t, USER);
+  const plan = select(b, ['settings-updates', 'settings-onboarding']);
+  assert.equal(plan.steps.length, 1, 'one change to config.json, no overlap refusal');
+  assert.match(plan.preview.join('\n'), /updateMode: "notify" → "automatic"/u);
+  applyReset(plan, b.journal);
+  const after = JSON.parse(readFileSync(b.config, 'utf8'));
+  assert.equal(after.updateMode, 'automatic'); assert.equal(after.onboardingComplete, false);
+  assert.equal(after.composerPosition, 'top', 'preferences stay when not chosen');
+});
+
+test('D7: legacy settings keep their migrated meaning, repeated resets are no-ops, malformed settings are refused', t => {
+  const legacy = box(t, {onboardingComplete: true, provider: 'starship'});
+  const once = planSettingsReset(readFileSync(legacy.config, 'utf8'), new Set(['preferences']));
+  const normalized = normalizePromptConfiguration(JSON.parse(once.after!));
+  assert.equal(normalized.onboardingComplete, true);
+  assert.equal(normalized.toolsSetupComplete, true, 'legacy completed onboarding still counts as tools setup done');
+  assert.equal(normalized.glyphChoiceComplete, true);
+  assert.equal(normalized.provider, 'nmsh');
+  writeFileSync(legacy.config, once.after!);
+  const twice = planSettingsReset(once.after, new Set(['preferences']));
+  assert.equal(twice.changed, 0); assert.equal(twice.after, once.after);
+  assert.equal(discoverResetAreas(legacy.context, legacy.journal).find(area => area.id === 'settings')!.status, 'nothing to reset');
+  const broken = box(t, '{not json');
+  const area = discoverResetAreas(broken.context, broken.journal).find(item => item.id === 'settings')!;
+  assert.equal(area.status, 'not set up'); assert.match(area.reason!, /not valid JSON/u);
+  const missing = box(t);
+  assert.equal(discoverResetAreas(missing.context, missing.journal).find(item => item.id === 'settings')!.status, 'nothing to reset');
+});
+
+test('D6/D7: a single-area reset records exactly one journal entry, and restoring it undoes the reset byte for byte', t => {
+  const b = box(t, USER);
+  const original = readFileSync(b.config, 'utf8');
+  const result = applyReset(select(b, ['settings']), b.journal);
+  const entries = b.journal.list();
+  assert.equal(entries.length, 1, 'no near-duplicate checkpoint');
+  assert.equal(entries[0]!.id, result.entry!.id); assert.equal(entries[0]!.outcome, 'applied');
+  assert.match(entries[0]!.label, /^Reset NMSh preferences/u);
+  restore(b.journal, planRestore(b.journal, result.entry!.id), {reviewed: true, overwrite: false});
+  assert.equal(readFileSync(b.config, 'utf8'), original);
+});
+
+test('D6: a multi-area reset keeps one checkpoint plus linked, labelled stages', t => {
+  const b = box(t);
+  const one = join(b.home, 'one'), two = join(b.home, 'two');
+  writeFileSync(one, 'a\nowned\n'); writeFileSync(two, 'b\nowned\n');
+  const areas: ResetArea[] = [
+    {id: 'a', label: 'Area A', status: 'set up', dependencies: [], changes: [{before: snapshot(one, b.home), after: 'a\n'}]},
+    {id: 'b', label: 'Area B', status: 'set up', dependencies: [], changes: [{before: snapshot(two, b.home), after: 'b\n'}]},
+  ];
+  const result = applyReset(planReset(areas, new Set(['a', 'b']), b.context), b.journal);
+  const entries = b.journal.list();
+  assert.equal(entries.length, 3);
+  const checkpoint = entries.find(entry => entry.id === result.entry!.id)!;
+  assert.match(checkpoint.label, /^Reset checkpoint: Area A, Area B/u); assert.equal(checkpoint.outcome, 'applied');
+  const stages = entries.filter(entry => entry.group === checkpoint.id).map(entry => entry.label).sort();
+  assert.deepEqual(stages, ['Reset stage 1/2: Area A', 'Reset stage 2/2: Area B']);
+});
+
+test('D6: navigation steps say they only advance; the destructive step still needs the typed word', t => {
+  const b = box(t, USER);
+  const panel = createResetPanel(b.context, b.journal);
+  panel.index = panel.areas.findIndex(area => area.id === 'settings');
+  assert.match(text(renderResetPanel(panel, 120, 30)), /Settings that change/u, 'the selected area shows its before → after summary');
+  resetKey(panel, {kind: 'text', value: ' '}); resetKey(panel, enter);
+  const impact = text(renderResetPanel(panel, 120, 30));
+  assert.match(impact, /Enter next: backup/u); assert.doesNotMatch(impact, /confirm write/u);
+  resetKey(panel, enter);
+  const backup = text(renderResetPanel(panel, 120, 30));
+  assert.match(backup, /Enter next: type reset/u); assert.doesNotMatch(backup, /confirm write/u);
+  resetKey(panel, enter); renderResetPanel(panel, 120, 30);
+  const before = readFileSync(b.config, 'utf8');
+  for (const value of 'rest') resetKey(panel, {kind: 'text', value});
+  assert.deepEqual(resetKey(panel, enter), {close: true});
+  assert.equal(readFileSync(b.config, 'utf8'), before, 'a wrong word writes nothing');
+});
+
+test('D5: history names the application, file, action and status instead of vague labels', t => {
+  const b = box(t, USER);
+  const kitty = join(b.home, '.config/kitty/kitty.conf');
+  mkdirSync(dirname(kitty), {recursive: true}); writeFileSync(kitty, 'font_size 12\n');
+  transact([{before: snapshot(kitty, b.home), after: 'font_size 12\ninclude nmsh.conf\n'}], [], b.home, {source: 'appearance', label: 'appends 2 lines at the end', directory: b.journal.directory});
+  writeArtifact('vim', '" one', () => true, {mode: 'follow', themeRef: 'x', format: 'vim', formatVersion: 1}, b.env);
+  writeArtifact('vim', '" two', () => true, {mode: 'follow', themeRef: 'x', format: 'vim', formatVersion: 1}, b.env);
+  const panel = createChangesPanel(b.journal, []);
+  const rows = text(renderChangesPanel(panel, 160, 40));
+  assert.match(rows, /Kitty · kitty\.conf · changed · unchanged since/u);
+  assert.match(rows, /Vim colors · nmsh-bridge\.vim \+1 more · created · changed later by/u);
+  assert.doesNotMatch(rows, /\d+ files ·/u);
+  panel.selected = panel.entries.findIndex(entry => entry.label === 'appends 2 lines at the end');
+  assert.match(text(renderChangesPanel(panel, 160, 40)), /Recorded as: appearance · appends 2 lines at the end .*~\/\.config\/kitty\/kitty\.conf · Kitty · changed/u);
+});
+
+test('Retention: a burst of hundreds of automatic writes keeps every original; a tiny cap reports any original it removes', t => {
+  const b = box(t);
+  const kitty = join(b.home, 'kitty.conf'), shader = join(b.home, 'cursor.glsl');
+  writeFileSync(kitty, 'k0'); writeFileSync(shader, 's0');
+  const write = (journal: Journal, path: string, after: string) => { const entry = journal.record([{before: snapshot(path, journal.options.home), after}], 'cursor', 'auto'); writeFileSync(path, after); journal.complete(entry); };
+  write(b.journal, kitty, 'k1'); write(b.journal, kitty, 'k2');
+  for (let index = 1; index <= 260; index++) write(b.journal, shader, `s${index}`);
+  const entries = b.journal.list();
+  assert.ok(entries.length <= 200);
+  assert.ok(entries.some(entry => entry.files.some(file => file.path === kitty && file.beforeHash !== file.afterHash && b.journal.content(entry, 0) === 'k0')), 'kitty.conf original kept');
+  assert.ok(entries.some(entry => b.journal.content(entry, 0) === 's0'), 'shader original kept');
+  assert.deepEqual(b.journal.lostOriginals(), []);
+  assert.doesNotMatch(createChangesPanel(b.journal, []).message, /Retention warning/u);
+  const tiny = box(t);
+  const small = new Journal({home: tiny.home, directory: tiny.journal.directory, maxEntries: 3});
+  // The newest backup per file is always kept, so an original can go only once its file has newer backups.
+  const [a, c] = ['a', 'c'].map(name => { const path = join(tiny.home, name); writeFileSync(path, `${name}0`); return path; }) as [string, string];
+  for (const step of [1, 2, 3]) write(small, a, `a${step}`);
+  for (const step of [1, 2, 3]) write(small, c, `c${step}`);
+  assert.ok(small.list().length <= 3);
+  assert.deepEqual(small.lostOriginals().map(item => item.path), [a]);
+  const notice = createChangesPanel(small, []).message;
+  assert.match(notice, /Retention warning: .*earliest backup of 1 file was removed: ~\/a \(from /u);
+});
+
+test('D7: a sparse or legacy settings file keeps its effective update policy and first-run state through a preferences reset', t => {
+  for (const settings of [{composerPosition: 'top'}, {onboardingComplete: true, composerPosition: 'top'}, {updateMode: 'off', composerPosition: 'top'}]) {
+    const before = normalizePromptConfiguration(settings);
+    const plan = planSettingsReset(JSON.stringify(settings), new Set(['preferences']));
+    const after = normalizePromptConfiguration(JSON.parse(plan.after!));
+    assert.equal(after.updateMode, before.updateMode, JSON.stringify(settings));
+    assert.equal(after.updateFrequency, before.updateFrequency);
+    assert.equal(after.onboardingComplete, before.onboardingComplete); assert.equal(after.toolsSetupComplete, before.toolsSetupComplete);
+    assert.equal(after.composerPosition, 'bottom');
+  }
+});