claudectx 1.1.2 → 1.1.3

package/dist/index.js

@@ -124,15 +124,15 @@ __export(session_store_exports, {
   readAllEvents: () => readAllEvents
 });
 function getStoreDirPath() {
-  return path8.join(os2.homedir(), ".claudectx");
+  return path9.join(os3.homedir(), ".claudectx");
 }
 function getReadsFilePath_() {
-  return path8.join(getStoreDirPath(), "reads.jsonl");
+  return path9.join(getStoreDirPath(), "reads.jsonl");
 }
 function ensureStoreDir() {
   const dir = getStoreDirPath();
-  if (!fs8.existsSync(dir)) {
-    fs8.mkdirSync(dir, { recursive: true });
+  if (!fs9.existsSync(dir)) {
+    fs9.mkdirSync(dir, { recursive: true });
   }
 }
 function appendFileRead(filePath, sessionId) {
@@ -142,12 +142,12 @@ function appendFileRead(filePath, sessionId) {
     filePath,
     sessionId
   };
-  fs8.appendFileSync(getReadsFilePath_(), JSON.stringify(event) + "\n", "utf-8");
+  fs9.appendFileSync(getReadsFilePath_(), JSON.stringify(event) + "\n", "utf-8");
 }
 function readAllEvents() {
   const readsFile = getReadsFilePath_();
-  if (!fs8.existsSync(readsFile)) return [];
-  const lines = fs8.readFileSync(readsFile, "utf-8").trim().split("\n").filter(Boolean);
+  if (!fs9.existsSync(readsFile)) return [];
+  const lines = fs9.readFileSync(readsFile, "utf-8").trim().split("\n").filter(Boolean);
   return lines.map((line) => {
     try {
       return JSON.parse(line);
@@ -176,8 +176,8 @@ function aggregateStats(events) {
 }
 function clearStore() {
   const readsFile = getReadsFilePath_();
-  if (fs8.existsSync(readsFile)) {
-    fs8.writeFileSync(readsFile, "", "utf-8");
+  if (fs9.existsSync(readsFile)) {
+    fs9.writeFileSync(readsFile, "", "utf-8");
   }
 }
 function getReadsFilePath() {
@@ -186,37 +186,37 @@ function getReadsFilePath() {
 function getStoreDir() {
   return getStoreDirPath();
 }
-var fs8, os2, path8;
+var fs9, os3, path9;
 var init_session_store = __esm({
   "src/watcher/session-store.ts"() {
     "use strict";
     init_cjs_shims();
-    fs8 = __toESM(require("fs"));
-    os2 = __toESM(require("os"));
-    path8 = __toESM(require("path"));
+    fs9 = __toESM(require("fs"));
+    os3 = __toESM(require("os"));
+    path9 = __toESM(require("path"));
   }
 });
 
 // src/watcher/session-reader.ts
 function listSessionFiles() {
-  if (!fs9.existsSync(CLAUDE_PROJECTS_DIR)) return [];
+  if (!fs10.existsSync(CLAUDE_PROJECTS_DIR)) return [];
   const results = [];
   try {
-    const projectDirs = fs9.readdirSync(CLAUDE_PROJECTS_DIR);
+    const projectDirs = fs10.readdirSync(CLAUDE_PROJECTS_DIR);
     for (const projectDir of projectDirs) {
-      const projectPath = path9.join(CLAUDE_PROJECTS_DIR, projectDir);
+      const projectPath = path10.join(CLAUDE_PROJECTS_DIR, projectDir);
       try {
-        const stat = fs9.statSync(projectPath);
+        const stat = fs10.statSync(projectPath);
         if (!stat.isDirectory()) continue;
-        const files = fs9.readdirSync(projectPath).filter((f) => f.endsWith(".jsonl"));
+        const files = fs10.readdirSync(projectPath).filter((f) => f.endsWith(".jsonl"));
         for (const file of files) {
-          const filePath = path9.join(projectPath, file);
+          const filePath = path10.join(projectPath, file);
           try {
-            const fstat = fs9.statSync(filePath);
+            const fstat = fs10.statSync(filePath);
             results.push({
               filePath,
               mtimeMs: fstat.mtimeMs,
-              sessionId: path9.basename(file, ".jsonl"),
+              sessionId: path10.basename(file, ".jsonl"),
               projectDir
             });
           } catch {
@@ -247,7 +247,7 @@ async function readSessionUsage(sessionFilePath) {
     cacheReadTokens: 0,
     requestCount: 0
   };
-  if (!fs9.existsSync(sessionFilePath)) return result;
+  if (!fs10.existsSync(sessionFilePath)) return result;
   const { createReadStream } = await import("fs");
   const { createInterface } = await import("readline");
   try {
@@ -277,15 +277,15 @@ async function readSessionUsage(sessionFilePath) {
   }
   return result;
 }
-var fs9, os3, path9, CLAUDE_PROJECTS_DIR;
+var fs10, os4, path10, CLAUDE_PROJECTS_DIR;
 var init_session_reader = __esm({
   "src/watcher/session-reader.ts"() {
     "use strict";
     init_cjs_shims();
-    fs9 = __toESM(require("fs"));
-    os3 = __toESM(require("os"));
-    path9 = __toESM(require("path"));
-    CLAUDE_PROJECTS_DIR = path9.join(os3.homedir(), ".claude", "projects");
+    fs10 = __toESM(require("fs"));
+    os4 = __toESM(require("os"));
+    path10 = __toESM(require("path"));
+    CLAUDE_PROJECTS_DIR = path10.join(os4.homedir(), ".claude", "projects");
   }
 });
 
@@ -303,7 +303,7 @@ function fmtCost(tokens, model) {
   return `$${cost.toFixed(4)}`;
 }
 function shortPath(filePath) {
-  const parts = filePath.split(path10.sep);
+  const parts = filePath.split(path11.sep);
   if (parts.length <= 3) return filePath;
   return "\u2026/" + parts.slice(-3).join("/");
 }
@@ -425,9 +425,9 @@ function Dashboard({
     const readsFile = getReadsFilePath();
     let watcher = null;
     const tryWatch = () => {
-      if (fs10.existsSync(readsFile)) {
+      if (fs11.existsSync(readsFile)) {
         try {
-          watcher = fs10.watch(readsFile, () => refresh());
+          watcher = fs11.watch(readsFile, () => refresh());
         } catch {
         }
       }
@@ -465,7 +465,7 @@ function Dashboard({
       ] }),
       sessionFile && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Text, { dimColor: true, children: [
         "  \u2014  ",
-        path10.basename(sessionFile, ".jsonl").slice(0, 8),
+        path11.basename(sessionFile, ".jsonl").slice(0, 8),
         "\u2026"
       ] }),
       !sessionFile && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Text, { dimColor: true, children: "  \u2014  no session file found" })
@@ -481,7 +481,7 @@ function Dashboard({
     ] })
   ] });
 }
-var import_react, import_ink, fs10, path10, import_jsx_runtime;
+var import_react, import_ink, fs11, path11, import_jsx_runtime;
 var init_Dashboard = __esm({
   "src/components/Dashboard.tsx"() {
     "use strict";
@@ -491,15 +491,15 @@ var init_Dashboard = __esm({
     init_session_store();
     init_session_reader();
     init_models();
-    fs10 = __toESM(require("fs"));
-    path10 = __toESM(require("path"));
+    fs11 = __toESM(require("fs"));
+    path11 = __toESM(require("path"));
     import_jsx_runtime = require("react/jsx-runtime");
   }
 });
 
 // src/mcp/smart-reader.ts
 function detectLanguage(filePath) {
-  const ext = path13.extname(filePath).toLowerCase();
+  const ext = path14.extname(filePath).toLowerCase();
   switch (ext) {
     case ".ts":
     case ".tsx":
@@ -516,8 +516,8 @@ function detectLanguage(filePath) {
   }
 }
 function findSymbol(filePath, symbolName) {
-  if (!fs12.existsSync(filePath)) return null;
-  const content = fs12.readFileSync(filePath, "utf-8");
+  if (!fs13.existsSync(filePath)) return null;
+  const content = fs13.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const lang = detectLanguage(filePath);
   const patterns = lang === "python" ? PYTHON_PATTERNS : TS_JS_PATTERNS;
@@ -578,8 +578,8 @@ function findPythonBlockEnd(lines, startIdx) {
   return lines.length;
 }
 function extractLineRange(filePath, startLine, endLine, contextLines = 0) {
-  if (!fs12.existsSync(filePath)) return null;
-  const allLines = fs12.readFileSync(filePath, "utf-8").split("\n");
+  if (!fs13.existsSync(filePath)) return null;
+  const allLines = fs13.readFileSync(filePath, "utf-8").split("\n");
   const totalLines = allLines.length;
   const from = Math.max(0, startLine - 1 - contextLines);
   const to = Math.min(totalLines, endLine + contextLines);
@@ -594,7 +594,7 @@ function extractLineRange(filePath, startLine, endLine, contextLines = 0) {
   };
 }
 function smartRead(filePath, symbol, startLine, endLine, contextLines = 3) {
-  if (!fs12.existsSync(filePath)) {
+  if (!fs13.existsSync(filePath)) {
     throw new Error(`File not found: ${filePath}`);
   }
   if (symbol) {
@@ -606,7 +606,7 @@ function smartRead(filePath, symbol, startLine, endLine, contextLines = 3) {
         filePath,
         startLine: extracted.startLine,
         endLine: extracted.endLine,
-        totalLines: fs12.readFileSync(filePath, "utf-8").split("\n").length,
+        totalLines: fs13.readFileSync(filePath, "utf-8").split("\n").length,
         truncated: false,
         symbolName: symbol
       };
@@ -618,7 +618,7 @@ function smartRead(filePath, symbol, startLine, endLine, contextLines = 3) {
       return { ...result, truncated: false };
     }
   }
-  const fullContent = fs12.readFileSync(filePath, "utf-8");
+  const fullContent = fs13.readFileSync(filePath, "utf-8");
   const allLines = fullContent.split("\n");
   const totalLines = allLines.length;
   const fullTokens = countTokens(fullContent);
@@ -654,13 +654,13 @@ function smartRead(filePath, symbol, startLine, endLine, contextLines = 3) {
     truncated: true
   };
 }
-var fs12, path13, TS_JS_PATTERNS, PYTHON_PATTERNS, MAX_FULL_FILE_TOKENS;
+var fs13, path14, TS_JS_PATTERNS, PYTHON_PATTERNS, MAX_FULL_FILE_TOKENS;
 var init_smart_reader = __esm({
   "src/mcp/smart-reader.ts"() {
     "use strict";
     init_cjs_shims();
-    fs12 = __toESM(require("fs"));
-    path13 = __toESM(require("path"));
+    fs13 = __toESM(require("fs"));
+    path14 = __toESM(require("path"));
     init_tokenizer();
     TS_JS_PATTERNS = [
       // export async function name / export function name / function name
@@ -699,7 +699,7 @@ function extractSymbolsFromFile(filePath) {
   if (lang === "other") return [];
   let content;
   try {
-    content = fs13.readFileSync(filePath, "utf-8");
+    content = fs14.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -728,13 +728,13 @@ function extractSymbolsFromFile(filePath) {
   }
   return results;
 }
-var fs13, path14, import_glob, TS_JS_EXTRACTORS, PYTHON_EXTRACTORS, SOURCE_GLOBS, IGNORE_DIRS, SymbolIndex, globalIndex;
+var fs14, path15, import_glob, TS_JS_EXTRACTORS, PYTHON_EXTRACTORS, SOURCE_GLOBS, IGNORE_DIRS, SymbolIndex, globalIndex;
 var init_symbol_index = __esm({
   "src/mcp/symbol-index.ts"() {
     "use strict";
     init_cjs_shims();
-    fs13 = __toESM(require("fs"));
-    path14 = __toESM(require("path"));
+    fs14 = __toESM(require("fs"));
+    path15 = __toESM(require("path"));
     import_glob = require("glob");
     init_smart_reader();
     TS_JS_EXTRACTORS = [
@@ -787,8 +787,8 @@ var init_symbol_index = __esm({
         this.entries = [];
         let files = [];
         try {
-          files = await (0, import_glob.glob)(SOURCE_GLOBS.map((g) => path14.join(projectRoot, g)), {
-            ignore: IGNORE_DIRS.map((g) => path14.join(projectRoot, g)),
+          files = await (0, import_glob.glob)(SOURCE_GLOBS.map((g) => path15.join(projectRoot, g)), {
+            ignore: IGNORE_DIRS.map((g) => path15.join(projectRoot, g)),
             absolute: true
           });
         } catch {
@@ -842,7 +842,7 @@ __export(server_exports, {
   startMcpServer: () => startMcpServer
 });
 function handleSmartRead(args) {
-  const filePath = path15.resolve(args.file);
+  const filePath = path16.resolve(args.file);
   const result = smartRead(
     filePath,
     args.symbol,
@@ -878,7 +878,7 @@ Example: index_project({ "project_root": "${process.cwd()}" })`;
   ];
   for (let i = 0; i < results.length; i++) {
     const r = results[i];
-    const rel = path15.relative(process.cwd(), r.filePath);
+    const rel = path16.relative(process.cwd(), r.filePath);
     lines.push(`${i + 1}. [${r.type}] ${r.name}`);
     lines.push(`   ${rel}:${r.lineStart}`);
     lines.push(`   ${r.signature.trim()}`);
@@ -890,7 +890,7 @@ Example: index_project({ "project_root": "${process.cwd()}" })`;
   return lines.join("\n");
 }
 async function handleIndexProject(args) {
-  const projectRoot = args.project_root ? path15.resolve(args.project_root) : process.cwd();
+  const projectRoot = args.project_root ? path16.resolve(args.project_root) : process.cwd();
   const fn = args.rebuild ? () => globalIndex.rebuild(projectRoot) : () => globalIndex.build(projectRoot);
   const { fileCount, symbolCount } = await fn();
   if (fileCount === 0 && globalIndex.isReady) {
@@ -938,12 +938,12 @@ async function startMcpServer() {
   await server.connect(transport);
   process.stderr.write("[claudectx mcp] Server started (stdio)\n");
 }
-var path15, import_server, import_stdio, import_types, TOOLS;
+var path16, import_server, import_stdio, import_types, TOOLS;
 var init_server = __esm({
   "src/mcp/server.ts"() {
     "use strict";
     init_cjs_shims();
-    path15 = __toESM(require("path"));
+    path16 = __toESM(require("path"));
     import_server = require("@modelcontextprotocol/sdk/server/index.js");
     import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
     import_types = require("@modelcontextprotocol/sdk/types.js");
@@ -1581,8 +1581,8 @@ async function analyzeCommand(options) {
 
 // src/commands/optimize.ts
 init_cjs_shims();
-var fs7 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var fs8 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var import_chalk3 = __toESM(require("chalk"));
 var import_boxen2 = __toESM(require("boxen"));
 var import_prompts = require("@inquirer/prompts");
@@ -1745,9 +1745,132 @@ function writeIgnorefile(result) {
 
 // src/optimizer/claudemd-splitter.ts
 init_cjs_shims();
+var fs5 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+init_tokenizer();
+
+// src/shared/backup-manager.ts
+init_cjs_shims();
 var fs4 = __toESM(require("fs"));
+var os2 = __toESM(require("os"));
 var path5 = __toESM(require("path"));
-init_tokenizer();
+var MAX_BACKUPS = 50;
+var _backupDirOverride = null;
+function getBackupDir() {
+  return _backupDirOverride ?? path5.join(os2.homedir(), ".claudectx", "backups");
+}
+var BACKUP_DIR = path5.join(os2.homedir(), ".claudectx", "backups");
+function ensureBackupDir() {
+  const dir = getBackupDir();
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
+  }
+}
+function getManifestPath() {
+  return path5.join(getBackupDir(), "manifest.json");
+}
+function readManifest() {
+  ensureBackupDir();
+  const manifestPath = getManifestPath();
+  if (!fs4.existsSync(manifestPath)) {
+    return { version: "1", entries: [] };
+  }
+  try {
+    return JSON.parse(fs4.readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return { version: "1", entries: [] };
+  }
+}
+function writeManifest(manifest) {
+  ensureBackupDir();
+  const manifestPath = getManifestPath();
+  const tmpPath = `${manifestPath}.tmp-${Date.now()}`;
+  try {
+    fs4.writeFileSync(tmpPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+    fs4.renameSync(tmpPath, manifestPath);
+  } catch {
+    try {
+      fs4.unlinkSync(tmpPath);
+    } catch {
+    }
+    throw new Error(`Failed to write backup manifest at ${manifestPath}`);
+  }
+}
+function generateId(originalPath) {
+  const now = /* @__PURE__ */ new Date();
+  const ts = now.toISOString().replace(/[-:]/g, "").replace("T", "T").replace(".", "m").replace("Z", "");
+  const rand = Math.floor(Math.random() * 9e3 + 1e3);
+  const basename10 = path5.basename(originalPath);
+  return `${ts}-${rand}-${basename10}`;
+}
+async function backupFile(filePath, command) {
+  const resolved = path5.resolve(filePath);
+  if (!fs4.existsSync(resolved)) {
+    throw new Error(`Cannot back up "${resolved}": file does not exist.`);
+  }
+  ensureBackupDir();
+  const id = generateId(resolved);
+  const backupPath = path5.join(getBackupDir(), id);
+  fs4.copyFileSync(resolved, backupPath);
+  const stat = fs4.statSync(backupPath);
+  const entry = {
+    id,
+    originalPath: resolved,
+    backupPath,
+    command,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sizeBytes: stat.size
+  };
+  const manifest = readManifest();
+  manifest.entries.unshift(entry);
+  writeManifest(manifest);
+  if (manifest.entries.length > MAX_BACKUPS) {
+    await pruneOldBackups();
+  }
+  return entry;
+}
+async function listBackups(filterPath) {
+  const manifest = readManifest();
+  const entries = manifest.entries;
+  if (!filterPath) return entries;
+  const resolved = path5.resolve(filterPath);
+  return entries.filter((e) => e.originalPath === resolved);
+}
+async function restoreBackup(backupId) {
+  const manifest = readManifest();
+  const entry = manifest.entries.find((e) => e.id === backupId);
+  if (!entry) {
+    throw new Error(`Backup "${backupId}" not found. Run "claudectx revert --list" to see available backups.`);
+  }
+  if (!fs4.existsSync(entry.backupPath)) {
+    throw new Error(`Backup file missing at "${entry.backupPath}". It may have been deleted manually.`);
+  }
+  let undoEntry = null;
+  if (fs4.existsSync(entry.originalPath)) {
+    undoEntry = await backupFile(entry.originalPath, "revert");
+  }
+  const targetDir = path5.dirname(entry.originalPath);
+  if (!fs4.existsSync(targetDir)) {
+    fs4.mkdirSync(targetDir, { recursive: true });
+  }
+  fs4.copyFileSync(entry.backupPath, entry.originalPath);
+  return { entry, undoEntry };
+}
+async function pruneOldBackups() {
+  const manifest = readManifest();
+  if (manifest.entries.length <= MAX_BACKUPS) return 0;
+  const toRemove = manifest.entries.splice(MAX_BACKUPS);
+  for (const entry of toRemove) {
+    try {
+      fs4.unlinkSync(entry.backupPath);
+    } catch {
+    }
+  }
+  writeManifest(manifest);
+  return toRemove.length;
+}
+
+// src/optimizer/claudemd-splitter.ts
 var SPLIT_MIN_TOKENS = 300;
 function slugify(title) {
   return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -1782,9 +1905,9 @@ function parseSections(content) {
   return sections;
 }
 function planSplit(claudeMdPath, sectionsToExtract) {
-  const content = fs4.readFileSync(claudeMdPath, "utf-8");
+  const content = fs5.readFileSync(claudeMdPath, "utf-8");
   const sections = parseSections(content);
-  const claudeDir = path5.join(path5.dirname(claudeMdPath), ".claude");
+  const claudeDir = path6.join(path6.dirname(claudeMdPath), ".claude");
   const extractedFiles = [];
   let newContent = "";
   let tokensSaved = 0;
@@ -1797,7 +1920,7 @@ function planSplit(claudeMdPath, sectionsToExtract) {
       usedSlugs.set(slug, count + 1);
       const filename = `${slug}.md`;
       const relRefPath = `.claude/${filename}`;
-      const filePath = path5.join(claudeDir, filename);
+      const filePath = path6.join(claudeDir, filename);
       const refBlock = `## ${section.title}
 
 @${relRefPath}
@@ -1821,21 +1944,24 @@ function planSplit(claudeMdPath, sectionsToExtract) {
     tokensSaved: Math.max(0, tokensSaved)
   };
 }
-function applySplit(result) {
+async function applySplit(result) {
   if (result.extractedFiles.length === 0) return;
-  const claudeDir = path5.dirname(result.extractedFiles[0].filePath);
-  if (!fs4.existsSync(claudeDir)) {
-    fs4.mkdirSync(claudeDir, { recursive: true });
+  if (fs5.existsSync(result.claudeMdPath)) {
+    await backupFile(result.claudeMdPath, "optimize");
+  }
+  const claudeDir = path6.dirname(result.extractedFiles[0].filePath);
+  if (!fs5.existsSync(claudeDir)) {
+    fs5.mkdirSync(claudeDir, { recursive: true });
   }
   for (const file of result.extractedFiles) {
-    fs4.writeFileSync(file.filePath, file.content, "utf-8");
+    fs5.writeFileSync(file.filePath, file.content, "utf-8");
   }
-  fs4.writeFileSync(result.claudeMdPath, result.newClaudeMd, "utf-8");
+  fs5.writeFileSync(result.claudeMdPath, result.newClaudeMd, "utf-8");
 }
 
 // src/optimizer/cache-applier.ts
 init_cjs_shims();
-var fs5 = __toESM(require("fs"));
+var fs6 = __toESM(require("fs"));
 function findCacheBusters(content) {
   const fixes = [];
   const lines = content.split("\n");
@@ -1865,18 +1991,21 @@ function applyCacheFixes(content, fixes) {
   return lines.join("\n");
 }
 function planCacheFixes(claudeMdPath) {
-  const content = fs5.readFileSync(claudeMdPath, "utf-8");
+  const content = fs6.readFileSync(claudeMdPath, "utf-8");
   const fixes = findCacheBusters(content);
   return { fixes, newContent: applyCacheFixes(content, fixes) };
 }
-function applyAndWriteCacheFixes(claudeMdPath, result) {
-  fs5.writeFileSync(claudeMdPath, result.newContent, "utf-8");
+async function applyAndWriteCacheFixes(claudeMdPath, result) {
+  if (fs6.existsSync(claudeMdPath)) {
+    await backupFile(claudeMdPath, "optimize");
+  }
+  fs6.writeFileSync(claudeMdPath, result.newContent, "utf-8");
 }
 
 // src/optimizer/hooks-installer.ts
 init_cjs_shims();
-var fs6 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
 var CLAUDECTX_HOOKS = {
   PostToolUse: [
     {
@@ -1894,13 +2023,13 @@ var CLAUDECTX_HOOKS = {
   ]
 };
 function planHooksInstall(projectRoot) {
-  const claudeDir = path6.join(projectRoot, ".claude");
-  const settingsPath = path6.join(claudeDir, "settings.local.json");
-  const existed = fs6.existsSync(settingsPath);
+  const claudeDir = path7.join(projectRoot, ".claude");
+  const settingsPath = path7.join(claudeDir, "settings.local.json");
+  const existed = fs7.existsSync(settingsPath);
   let existing = {};
   if (existed) {
     try {
-      existing = JSON.parse(fs6.readFileSync(settingsPath, "utf-8"));
+      existing = JSON.parse(fs7.readFileSync(settingsPath, "utf-8"));
     } catch {
       existing = {};
     }
@@ -1921,25 +2050,25 @@ function planHooksInstall(projectRoot) {
   return { settingsPath, existed, mergedSettings };
 }
 function applyHooksInstall(result) {
-  const dir = path6.dirname(result.settingsPath);
-  if (!fs6.existsSync(dir)) {
-    fs6.mkdirSync(dir, { recursive: true });
+  const dir = path7.dirname(result.settingsPath);
+  if (!fs7.existsSync(dir)) {
+    fs7.mkdirSync(dir, { recursive: true });
   }
-  fs6.writeFileSync(result.settingsPath, JSON.stringify(result.mergedSettings, null, 2) + "\n", "utf-8");
+  fs7.writeFileSync(result.settingsPath, JSON.stringify(result.mergedSettings, null, 2) + "\n", "utf-8");
 }
 function writeHooksSettings(projectRoot, mergedSettings) {
-  const settingsPath = path6.join(projectRoot, ".claude", "settings.local.json");
-  const dir = path6.dirname(settingsPath);
-  if (!fs6.existsSync(dir)) {
-    fs6.mkdirSync(dir, { recursive: true });
+  const settingsPath = path7.join(projectRoot, ".claude", "settings.local.json");
+  const dir = path7.dirname(settingsPath);
+  if (!fs7.existsSync(dir)) {
+    fs7.mkdirSync(dir, { recursive: true });
   }
-  fs6.writeFileSync(settingsPath, JSON.stringify(mergedSettings, null, 2) + "\n", "utf-8");
+  fs7.writeFileSync(settingsPath, JSON.stringify(mergedSettings, null, 2) + "\n", "utf-8");
 }
 function isAlreadyInstalled(projectRoot) {
-  const settingsPath = path6.join(projectRoot, ".claude", "settings.local.json");
-  if (!fs6.existsSync(settingsPath)) return false;
+  const settingsPath = path7.join(projectRoot, ".claude", "settings.local.json");
+  if (!fs7.existsSync(settingsPath)) return false;
   try {
-    const settings = JSON.parse(fs6.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs7.readFileSync(settingsPath, "utf-8"));
     const postToolUse = settings?.hooks?.PostToolUse ?? [];
     return postToolUse.some((h) => h.matcher === "Read");
   } catch {
@@ -1949,7 +2078,7 @@ function isAlreadyInstalled(projectRoot) {
 
 // src/commands/optimize.ts
 async function optimizeCommand(options) {
-  const projectPath = options.path ? path7.resolve(options.path) : findProjectRoot() ?? process.cwd();
+  const projectPath = options.path ? path8.resolve(options.path) : findProjectRoot() ?? process.cwd();
   const dryRun = options.dryRun ?? false;
   const autoApply = options.apply ?? false;
   const specificMode = options.claudemd || options.ignorefile || options.cache || options.hooks;
@@ -2074,12 +2203,12 @@ async function runIgnorefile(projectRoot, dryRun, autoApply) {
 }
 async function runClaudeMdSplit(projectRoot, report, dryRun, autoApply) {
   printSectionHeader("CLAUDE.md \u2192 @files");
-  const claudeMdPath = path7.join(projectRoot, "CLAUDE.md");
-  if (!fs7.existsSync(claudeMdPath)) {
+  const claudeMdPath = path8.join(projectRoot, "CLAUDE.md");
+  if (!fs8.existsSync(claudeMdPath)) {
     logger.warn("No CLAUDE.md found \u2014 skipping.");
     return;
   }
-  const content = fs7.readFileSync(claudeMdPath, "utf-8");
+  const content = fs8.readFileSync(claudeMdPath, "utf-8");
   const sections = parseSections(content);
   const largeSections = sections.filter(
     (s) => !s.isPreamble && s.tokens >= SPLIT_MIN_TOKENS
@@ -2135,18 +2264,18 @@ Would extract ${splitResult.extractedFiles.length} section(s) to .claude/`
     logger.info("Skipped.");
     return;
   }
-  applySplit(splitResult);
+  await applySplit(splitResult);
   logger.success(
     `Extracted ${splitResult.extractedFiles.length} section(s). Saved ~${splitResult.tokensSaved} tokens/request.`
   );
   for (const f of splitResult.extractedFiles) {
-    logger.info(`  Created: ${import_chalk3.default.cyan(path7.relative(projectRoot, f.filePath))}`);
+    logger.info(`  Created: ${import_chalk3.default.cyan(path8.relative(projectRoot, f.filePath))}`);
   }
 }
 async function runCacheOptimization(projectRoot, dryRun, autoApply) {
   printSectionHeader("Prompt cache optimisation");
-  const claudeMdPath = path7.join(projectRoot, "CLAUDE.md");
-  if (!fs7.existsSync(claudeMdPath)) {
+  const claudeMdPath = path8.join(projectRoot, "CLAUDE.md");
+  if (!fs8.existsSync(claudeMdPath)) {
     logger.warn("No CLAUDE.md found \u2014 skipping.");
     return;
   }
@@ -2174,14 +2303,14 @@ async function runCacheOptimization(projectRoot, dryRun, autoApply) {
     logger.info("Skipped.");
     return;
   }
-  applyAndWriteCacheFixes(claudeMdPath, result);
+  await applyAndWriteCacheFixes(claudeMdPath, result);
   logger.success(`Fixed ${result.fixes.length} cache-busting pattern(s) in CLAUDE.md.`);
 }
 async function runHooks(projectRoot, dryRun, autoApply) {
   printSectionHeader("Session hooks");
   const result = planHooksInstall(projectRoot);
   logger.info(
-    `Settings file: ${import_chalk3.default.cyan(path7.relative(projectRoot, result.settingsPath))}`
+    `Settings file: ${import_chalk3.default.cyan(path8.relative(projectRoot, result.settingsPath))}`
   );
   logger.info(result.existed ? "Will merge with existing settings." : "Will create new file.");
   console.log(import_chalk3.default.dim("\n  Hooks to install:"));
@@ -2196,7 +2325,7 @@ async function runHooks(projectRoot, dryRun, autoApply) {
   }
   applyHooksInstall(result);
   logger.success(
-    `Hooks installed \u2192 ${import_chalk3.default.cyan(path7.relative(projectRoot, result.settingsPath))}`
+    `Hooks installed \u2192 ${import_chalk3.default.cyan(path8.relative(projectRoot, result.settingsPath))}`
   );
 }
 function printSectionHeader(title) {
@@ -2206,7 +2335,7 @@ function printSectionHeader(title) {
 
 // src/commands/watch.ts
 init_cjs_shims();
-var path11 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 init_session_store();
 init_models();
 async function watchCommand(options) {
@@ -2244,30 +2373,30 @@ async function handleLogStdin() {
     const payload = JSON.parse(raw);
     const filePath = payload.tool_input?.file_path;
     if (filePath) {
-      appendFileRead(path11.resolve(filePath), payload.session_id);
+      appendFileRead(path12.resolve(filePath), payload.session_id);
     }
   } catch {
   }
 }
 function readStdin() {
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     let data = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => data += chunk);
-    process.stdin.on("end", () => resolve12(data));
-    setTimeout(() => resolve12(data), 500);
+    process.stdin.on("end", () => resolve13(data));
+    setTimeout(() => resolve13(data), 500);
   });
 }
 
 // src/commands/mcp.ts
 init_cjs_shims();
-var path16 = __toESM(require("path"));
+var path17 = __toESM(require("path"));
 var import_chalk4 = __toESM(require("chalk"));
 
 // src/mcp/installer.ts
 init_cjs_shims();
-var fs11 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var SERVER_NAME = "claudectx";
 var SERVER_ENTRY = {
   command: "claudectx",
@@ -2275,13 +2404,13 @@ var SERVER_ENTRY = {
   type: "stdio"
 };
 function planInstall(projectRoot) {
-  const claudeDir = path12.join(projectRoot, ".claude");
-  const settingsPath = path12.join(claudeDir, "settings.json");
-  const existed = fs11.existsSync(settingsPath);
+  const claudeDir = path13.join(projectRoot, ".claude");
+  const settingsPath = path13.join(claudeDir, "settings.json");
+  const existed = fs12.existsSync(settingsPath);
   let existing = {};
   if (existed) {
     try {
-      existing = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
+      existing = JSON.parse(fs12.readFileSync(settingsPath, "utf-8"));
     } catch {
       existing = {};
     }
@@ -2298,21 +2427,21 @@ function planInstall(projectRoot) {
   return { settingsPath, existed, alreadyInstalled, mergedSettings };
 }
 function applyInstall(result) {
-  const dir = path12.dirname(result.settingsPath);
-  if (!fs11.existsSync(dir)) {
-    fs11.mkdirSync(dir, { recursive: true });
+  const dir = path13.dirname(result.settingsPath);
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
   }
-  fs11.writeFileSync(
+  fs12.writeFileSync(
     result.settingsPath,
     JSON.stringify(result.mergedSettings, null, 2) + "\n",
     "utf-8"
   );
 }
 function isInstalled(projectRoot) {
-  const settingsPath = path12.join(projectRoot, ".claude", "settings.json");
-  if (!fs11.existsSync(settingsPath)) return false;
+  const settingsPath = path13.join(projectRoot, ".claude", "settings.json");
+  if (!fs12.existsSync(settingsPath)) return false;
   try {
-    const settings = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs12.readFileSync(settingsPath, "utf-8"));
     return SERVER_NAME in (settings.mcpServers ?? {});
   } catch {
     return false;
@@ -2321,7 +2450,7 @@ function isInstalled(projectRoot) {
 
 // src/commands/mcp.ts
 async function mcpCommand(options) {
-  const projectRoot = options.path ? path16.resolve(options.path) : process.cwd();
+  const projectRoot = options.path ? path17.resolve(options.path) : process.cwd();
   if (options.install) {
     await runInstall(projectRoot);
     return;
@@ -2369,13 +2498,13 @@ async function runInstall(projectRoot) {
 
 // src/commands/compress.ts
 init_cjs_shims();
-var path18 = __toESM(require("path"));
-var fs16 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
 init_session_reader();
 
 // src/compressor/session-parser.ts
 init_cjs_shims();
-var fs14 = __toESM(require("fs"));
+var fs15 = __toESM(require("fs"));
 function extractText(content) {
   if (!content) return "";
   if (typeof content === "string") return content;
@@ -2386,10 +2515,10 @@ function extractToolCalls(content) {
   return content.filter((b) => b.type === "tool_use" && b.name).map((b) => ({ tool: b.name, input: b.input ?? {} }));
 }
 function parseSessionFile(sessionFilePath) {
-  if (!fs14.existsSync(sessionFilePath)) return null;
+  if (!fs15.existsSync(sessionFilePath)) return null;
   let content;
   try {
-    content = fs14.readFileSync(sessionFilePath, "utf-8");
+    content = fs15.readFileSync(sessionFilePath, "utf-8");
   } catch {
     return null;
   }
@@ -2589,13 +2718,13 @@ function calcCost(inputTokens, outputTokens) {
 
 // src/compressor/memory-writer.ts
 init_cjs_shims();
-var fs15 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
 function parseMemoryFile(filePath) {
-  if (!fs15.existsSync(filePath)) {
+  if (!fs16.existsSync(filePath)) {
     return { preamble: "", entries: [] };
   }
-  const content = fs15.readFileSync(filePath, "utf-8");
+  const content = fs16.readFileSync(filePath, "utf-8");
   const markerRegex = /<!-- claudectx-entry: (\d{4}-\d{2}-\d{2}) \| session: ([a-z0-9-]+) -->/g;
   const indices = [];
   let match;
@@ -2646,15 +2775,15 @@ function appendEntry(memoryFilePath, sessionId, summaryText, date = /* @__PURE__
   const newBlock = buildEntryBlock(sessionId, summaryText, date);
   const allBlocks = [...entries.map((e) => e.raw), newBlock];
   const newContent = (preamble.trimEnd() ? preamble.trimEnd() + "\n\n" : "") + allBlocks.join("\n\n") + "\n";
-  const dir = path17.dirname(memoryFilePath);
-  if (!fs15.existsSync(dir)) {
-    fs15.mkdirSync(dir, { recursive: true });
+  const dir = path18.dirname(memoryFilePath);
+  if (!fs16.existsSync(dir)) {
+    fs16.mkdirSync(dir, { recursive: true });
   }
-  fs15.writeFileSync(memoryFilePath, newContent, "utf-8");
+  fs16.writeFileSync(memoryFilePath, newContent, "utf-8");
   return newContent;
 }
 function pruneOldEntries(memoryFilePath, days) {
-  if (!fs15.existsSync(memoryFilePath)) {
+  if (!fs16.existsSync(memoryFilePath)) {
     return { removed: 0, kept: 0, removedEntries: [] };
   }
   const { preamble, entries } = parseMemoryFile(memoryFilePath);
@@ -2667,7 +2796,7 @@ function pruneOldEntries(memoryFilePath, days) {
     return { removed: 0, kept: kept.length, removedEntries: [] };
   }
   const newContent = (preamble.trimEnd() ? preamble.trimEnd() + "\n\n" : "") + kept.map((e) => e.raw).join("\n\n") + (kept.length > 0 ? "\n" : "");
-  fs15.writeFileSync(memoryFilePath, newContent, "utf-8");
+  fs16.writeFileSync(memoryFilePath, newContent, "utf-8");
   return { removed: removed.length, kept: kept.length, removedEntries: removed };
 }
 function isAlreadyCompressed(memoryFilePath, sessionId) {
@@ -2678,8 +2807,8 @@ function isAlreadyCompressed(memoryFilePath, sessionId) {
 // src/commands/compress.ts
 async function compressCommand(options) {
   const chalk5 = (await import("chalk")).default;
-  const projectRoot = options.path ? path18.resolve(options.path) : process.cwd();
-  const memoryFilePath = path18.join(projectRoot, "MEMORY.md");
+  const projectRoot = options.path ? path19.resolve(options.path) : process.cwd();
+  const memoryFilePath = path19.join(projectRoot, "MEMORY.md");
   const sessionFiles = listSessionFiles();
   if (sessionFiles.length === 0) {
     process.stdout.write(chalk5.red("No Claude Code sessions found.\n"));
@@ -2704,7 +2833,7 @@ async function compressCommand(options) {
   } else {
     targetFile = sessionFiles[0].filePath;
   }
-  const sessionId = path18.basename(targetFile, ".jsonl");
+  const sessionId = path19.basename(targetFile, ".jsonl");
   if (isAlreadyCompressed(memoryFilePath, sessionId)) {
     if (!options.auto) {
       process.stdout.write(chalk5.yellow(`Session ${sessionId.slice(0, 8)}\u2026 is already in MEMORY.md \u2014 skipping.
@@ -2752,11 +2881,27 @@ async function compressCommand(options) {
   }
   if (options.prune) {
     const days = parseInt(options.days ?? "30", 10);
-    if (!fs16.existsSync(memoryFilePath)) return;
+    if (!fs17.existsSync(memoryFilePath)) return;
+    if (!options.auto) {
+      let confirmed = true;
+      try {
+        const { confirm: confirm2 } = await import("@inquirer/prompts");
+        confirmed = await confirm2({
+          message: `Prune MEMORY.md entries older than ${days} days? Run 'claudectx revert' to undo.`,
+          default: false
+        });
+      } catch {
+      }
+      if (!confirmed) {
+        process.stdout.write(chalk5.dim("Prune skipped.\n"));
+        return;
+      }
+    }
+    await backupFile(memoryFilePath, "compress");
     const pruned = pruneOldEntries(memoryFilePath, days);
     if (pruned.removed > 0 && !options.auto) {
       process.stdout.write(
-        chalk5.dim(`Pruned ${pruned.removed} entr${pruned.removed === 1 ? "y" : "ies"} older than ${days} days.
+        chalk5.dim(`Pruned ${pruned.removed} entr${pruned.removed === 1 ? "y" : "ies"} older than ${days} days. Run 'claudectx revert' to undo.
 `)
       );
     }
@@ -3034,12 +3179,12 @@ async function reportCommand(options) {
 
 // src/commands/budget.ts
 init_cjs_shims();
-var path20 = __toESM(require("path"));
+var path21 = __toESM(require("path"));
 
 // src/analyzer/budget-estimator.ts
 init_cjs_shims();
-var fs17 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 var import_glob2 = require("glob");
 init_tokenizer();
 init_session_store();
@@ -3065,20 +3210,20 @@ function classifyCacheHit(recentReadCount) {
   return "low";
 }
 function suggestClaudeignoreAdditions(files, projectRoot) {
-  const ignorePath = path19.join(projectRoot, ".claudeignore");
+  const ignorePath = path20.join(projectRoot, ".claudeignore");
   let ignorePatterns = [];
   try {
-    const content = fs17.readFileSync(ignorePath, "utf-8");
+    const content = fs18.readFileSync(ignorePath, "utf-8");
     ignorePatterns = content.split("\n").filter(Boolean);
   } catch {
   }
   const recommendations = [];
   for (const file of files) {
     if (file.tokenCount <= WASTE_THRESHOLDS.MAX_REFERENCE_FILE_TOKENS) continue;
-    const rel = path19.relative(projectRoot, file.filePath);
+    const rel = path20.relative(projectRoot, file.filePath);
     const alreadyIgnored = ignorePatterns.some((pattern) => {
       const cleanPattern = pattern.replace(/^!/, "");
-      return rel.startsWith(cleanPattern.replace(/\*/g, "").replace(/\//g, path19.sep));
+      return rel.startsWith(cleanPattern.replace(/\*/g, "").replace(/\//g, path20.sep));
     });
     if (!alreadyIgnored) {
       recommendations.push(rel);
@@ -3098,7 +3243,7 @@ async function estimateBudget(globs, projectRoot, model, thresholdTokens) {
   for (const filePath of filePaths) {
     let content = "";
     try {
-      content = fs17.readFileSync(filePath, "utf-8");
+      content = fs18.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -3147,7 +3292,7 @@ function formatBudgetReport(report) {
   }
   const LIKELIHOOD_ICON = { high: "\u{1F7E2}", medium: "\u{1F7E1}", low: "\u{1F534}" };
   const maxPathLen = Math.min(
-    Math.max(...report.files.map((f) => path19.basename(f.filePath).length)),
+    Math.max(...report.files.map((f) => path20.basename(f.filePath).length)),
     40
   );
   lines.push(
@@ -3155,7 +3300,7 @@ function formatBudgetReport(report) {
   );
   lines.push("\u2500".repeat(50));
   for (const file of report.files.slice(0, 20)) {
-    const name = path19.basename(file.filePath).slice(0, maxPathLen).padEnd(maxPathLen);
+    const name = path20.basename(file.filePath).slice(0, maxPathLen).padEnd(maxPathLen);
     const tokens = file.tokenCount.toLocaleString().padStart(7);
     const cache = `${LIKELIHOOD_ICON[file.cacheHitLikelihood]} ${file.cacheHitLikelihood.padEnd(6)}`;
     const cost = formatCost(file.estimatedCostUsd).padStart(7);
@@ -3184,7 +3329,7 @@ function formatBudgetReport(report) {
 // src/commands/budget.ts
 init_models();
 async function budgetCommand(globs, options) {
-  const projectPath = options.path ? path20.resolve(options.path) : process.cwd();
+  const projectPath = options.path ? path21.resolve(options.path) : process.cwd();
   const projectRoot = findProjectRoot(projectPath) ?? projectPath;
   const model = resolveModel(options.model ?? "sonnet");
   const thresholdTokens = parseInt(options.threshold ?? "10000", 10);
@@ -3203,7 +3348,7 @@ async function budgetCommand(globs, options) {
 
 // src/commands/warmup.ts
 init_cjs_shims();
-var path21 = __toESM(require("path"));
+var path22 = __toESM(require("path"));
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
 init_models();
 var import_fs3 = __toESM(require("fs"));
@@ -3277,6 +3422,19 @@ async function installCron(cronExpr) {
     );
     process.exit(1);
   }
+  let confirmed = true;
+  try {
+    const { confirm: confirm2 } = await import("@inquirer/prompts");
+    confirmed = await confirm2({
+      message: `Install cron job "${cronExpr} claudectx warmup" in your system crontab?`,
+      default: false
+    });
+  } catch {
+  }
+  if (!confirmed) {
+    process.stdout.write("  Cron install cancelled.\n");
+    return;
+  }
   const { execSync: execSync3 } = await import("child_process");
   const command = `claudectx warmup`;
   const cronLine = `${cronExpr} ${command}`;
@@ -3299,16 +3457,16 @@ async function installCron(cronExpr) {
 ${marker}
 ${cronLine}
 `;
-    const { writeFileSync: writeFileSync11, unlinkSync: unlinkSync2 } = await import("fs");
+    const { writeFileSync: writeFileSync12, unlinkSync: unlinkSync3 } = await import("fs");
     const { tmpdir } = await import("os");
-    const { join: join17 } = await import("path");
-    const tmpFile = join17(tmpdir(), `claudectx-cron-${Date.now()}.txt`);
+    const { join: join18 } = await import("path");
+    const tmpFile = join18(tmpdir(), `claudectx-cron-${Date.now()}.txt`);
     try {
-      writeFileSync11(tmpFile, newCrontab, "utf-8");
+      writeFileSync12(tmpFile, newCrontab, "utf-8");
       execSync3(`crontab ${tmpFile}`, { stdio: ["pipe", "pipe", "pipe"] });
     } finally {
       try {
-        unlinkSync2(tmpFile);
+        unlinkSync3(tmpFile);
       } catch {
       }
     }
@@ -3325,7 +3483,7 @@ ${cronLine}
   }
 }
 async function warmupCommand(options) {
-  const projectPath = options.path ? path21.resolve(options.path) : process.cwd();
+  const projectPath = options.path ? path22.resolve(options.path) : process.cwd();
   const projectRoot = findProjectRoot(projectPath) ?? projectPath;
   const model = resolveModel(options.model ?? "haiku");
   const ttl = options.ttl === "60" ? 60 : 5;
@@ -3337,7 +3495,7 @@ async function warmupCommand(options) {
     process.exit(1);
   }
   let claudeMdContent = "";
-  const claudeMdPath = path21.join(projectRoot, "CLAUDE.md");
+  const claudeMdPath = path22.join(projectRoot, "CLAUDE.md");
   try {
     claudeMdContent = import_fs3.default.readFileSync(claudeMdPath, "utf-8");
   } catch {
@@ -3397,13 +3555,13 @@ async function warmupCommand(options) {
 
 // src/commands/drift.ts
 init_cjs_shims();
-var path23 = __toESM(require("path"));
-var fs20 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
 
 // src/analyzer/drift-detector.ts
 init_cjs_shims();
-var fs19 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
+var fs20 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
 var childProcess = __toESM(require("child_process"));
 init_tokenizer();
 init_session_store();
@@ -3416,8 +3574,8 @@ function findDeadAtReferences(content, projectRoot) {
     const match = lines[i].match(AT_REF_RE);
     if (!match) continue;
     const ref = match[1].trim();
-    const absPath = path22.isAbsolute(ref) ? ref : path22.join(projectRoot, ref);
-    if (!fs19.existsSync(absPath)) {
+    const absPath = path23.isAbsolute(ref) ? ref : path23.join(projectRoot, ref);
+    if (!fs20.existsSync(absPath)) {
       const lineText = lines[i];
       issues.push({
         type: "dead-ref",
@@ -3450,15 +3608,15 @@ async function findGitDeletedMentions(content, projectRoot) {
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     for (const deleted of deletedFiles) {
-      const basename8 = path22.basename(deleted);
-      if (line.includes(basename8) || line.includes(deleted)) {
+      const basename10 = path23.basename(deleted);
+      if (line.includes(basename10) || line.includes(deleted)) {
         issues.push({
           type: "git-deleted",
           line: i + 1,
           text: line.trim(),
           severity: "warning",
           estimatedTokenWaste: countTokens(line),
-          suggestion: `References "${basename8}" which was deleted from git. Consider removing this mention.`
+          suggestion: `References "${basename10}" which was deleted from git. Consider removing this mention.`
         });
         break;
       }
@@ -3523,8 +3681,8 @@ function findDeadInlinePaths(content, projectRoot) {
       const rawPath = match[1].trim();
       if (seen.has(rawPath)) continue;
       seen.add(rawPath);
-      const absPath = path22.isAbsolute(rawPath) ? rawPath : path22.join(projectRoot, rawPath);
-      if (!fs19.existsSync(absPath)) {
+      const absPath = path23.isAbsolute(rawPath) ? rawPath : path23.join(projectRoot, rawPath);
+      if (!fs20.existsSync(absPath)) {
         issues.push({
           type: "dead-inline-path",
           line: i + 1,
@@ -3540,10 +3698,10 @@ function findDeadInlinePaths(content, projectRoot) {
   return issues;
 }
 async function detectDrift(projectRoot, dayWindow) {
-  const claudeMdPath = path22.join(projectRoot, "CLAUDE.md");
+  const claudeMdPath = path23.join(projectRoot, "CLAUDE.md");
   let content = "";
   try {
-    content = fs19.readFileSync(claudeMdPath, "utf-8");
+    content = fs20.readFileSync(claudeMdPath, "utf-8");
   } catch {
     return {
       claudeMdPath,
@@ -3585,7 +3743,7 @@ var TYPE_LABEL = {
   "dead-inline-path": "Dead path"
 };
 async function driftCommand(options) {
-  const projectPath = options.path ? path23.resolve(options.path) : process.cwd();
+  const projectPath = options.path ? path24.resolve(options.path) : process.cwd();
   const projectRoot = findProjectRoot(projectPath) ?? projectPath;
   const dayWindow = parseInt(options.days ?? "30", 10);
   const report = await detectDrift(projectRoot, dayWindow);
@@ -3661,25 +3819,25 @@ async function applyFix(claudeMdPath, issues) {
     process.stdout.write("No lines selected. Nothing changed.\n");
     return;
   }
-  const content = fs20.readFileSync(claudeMdPath, "utf-8");
+  const content = fs21.readFileSync(claudeMdPath, "utf-8");
   const lines = content.split("\n");
   const lineSet = new Set(selectedLines.map((l) => l - 1));
   const newLines = lines.filter((_, i) => !lineSet.has(i));
   const newContent = newLines.join("\n");
   const backupPath = `${claudeMdPath}.bak`;
-  fs20.writeFileSync(backupPath, content, "utf-8");
-  const os5 = await import("os");
+  fs21.writeFileSync(backupPath, content, "utf-8");
+  const os6 = await import("os");
   const tmpPath = `${claudeMdPath}.tmp-${Date.now()}`;
   try {
-    fs20.writeFileSync(tmpPath, newContent, "utf-8");
-    fs20.renameSync(tmpPath, claudeMdPath);
+    fs21.writeFileSync(tmpPath, newContent, "utf-8");
+    fs21.renameSync(tmpPath, claudeMdPath);
   } catch (err) {
     try {
-      fs20.copyFileSync(backupPath, claudeMdPath);
+      fs21.copyFileSync(backupPath, claudeMdPath);
     } catch {
     }
     try {
-      fs20.unlinkSync(tmpPath);
+      fs21.unlinkSync(tmpPath);
     } catch {
     }
     process.stderr.write(`Error writing CLAUDE.md: ${err instanceof Error ? err.message : String(err)}
@@ -3687,18 +3845,18 @@ async function applyFix(claudeMdPath, issues) {
     process.exit(1);
   }
   process.stdout.write(`
-  \u2713 Removed ${selectedLines.length} line(s) from ${path23.basename(claudeMdPath)}
+  \u2713 Removed ${selectedLines.length} line(s) from ${path24.basename(claudeMdPath)}
 `);
   process.stdout.write(`  \u2713 Backup saved to ${backupPath}
 
 `);
-  void os5;
+  void os6;
 }
 
 // src/commands/hooks.ts
 init_cjs_shims();
-var fs21 = __toESM(require("fs"));
-var path24 = __toESM(require("path"));
+var fs22 = __toESM(require("fs"));
+var path25 = __toESM(require("path"));
 
 // src/hooks/registry.ts
 init_cjs_shims();
@@ -3774,17 +3932,17 @@ function buildHookEntry(def, config) {
 
 // src/commands/hooks.ts
 function readInstalledHooks(projectRoot) {
-  const settingsPath = path24.join(projectRoot, ".claude", "settings.local.json");
-  if (!fs21.existsSync(settingsPath)) return {};
+  const settingsPath = path25.join(projectRoot, ".claude", "settings.local.json");
+  if (!fs22.existsSync(settingsPath)) return {};
   try {
-    return JSON.parse(fs21.readFileSync(settingsPath, "utf-8"));
+    return JSON.parse(fs22.readFileSync(settingsPath, "utf-8"));
   } catch {
     process.stderr.write(
       `Warning: ${settingsPath} exists but contains invalid JSON. Existing settings will be preserved as a backup.
 `
     );
     try {
-      fs21.copyFileSync(settingsPath, `${settingsPath}.bak`);
+      fs22.copyFileSync(settingsPath, `${settingsPath}.bak`);
     } catch {
     }
     return {};
@@ -3904,9 +4062,26 @@ async function hooksAdd(name, projectRoot, configPairs) {
 }
 async function hooksRemove(name, projectRoot) {
   const settings = readInstalledHooks(projectRoot);
+  let confirmed = true;
+  try {
+    const { confirm: confirm2 } = await import("@inquirer/prompts");
+    confirmed = await confirm2({
+      message: `Remove hook "${name}"? Run 'claudectx revert' to undo.`,
+      default: false
+    });
+  } catch {
+  }
+  if (!confirmed) {
+    process.stdout.write("  Cancelled.\n\n");
+    return;
+  }
+  const settingsPath = path25.join(projectRoot, ".claude", "settings.local.json");
+  if (fs22.existsSync(settingsPath)) {
+    await backupFile(settingsPath, "hooks");
+  }
   const updated = removeHookByName(settings, name);
   writeHooksSettings(projectRoot, updated);
-  process.stdout.write(`  \u2713 Hook "${name}" removed.
+  process.stdout.write(`  \u2713 Hook "${name}" removed. Run 'claudectx revert --list' to undo.
 
 `);
 }
@@ -3931,7 +4106,7 @@ async function hooksStatus(projectRoot) {
   process.stdout.write("\n");
 }
 async function hooksCommand(subcommand, options) {
-  const projectPath = options.path ? path24.resolve(options.path) : process.cwd();
+  const projectPath = options.path ? path25.resolve(options.path) : process.cwd();
   const projectRoot = findProjectRoot(projectPath) ?? projectPath;
   const sub = subcommand ?? "list";
   switch (sub) {
@@ -3970,8 +4145,8 @@ async function hooksCommand(subcommand, options) {
 
 // src/commands/convert.ts
 init_cjs_shims();
-var fs22 = __toESM(require("fs"));
-var path25 = __toESM(require("path"));
+var fs23 = __toESM(require("fs"));
+var path26 = __toESM(require("path"));
 function slugify2(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -4020,7 +4195,7 @@ function claudeMdToWindsurf(content) {
   return content.split("\n").filter((line) => !line.match(/^@.+$/)).join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
 async function convertCommand(options) {
-  const projectPath = options.path ? path25.resolve(options.path) : process.cwd();
+  const projectPath = options.path ? path26.resolve(options.path) : process.cwd();
   const projectRoot = findProjectRoot(projectPath) ?? projectPath;
   const from = options.from ?? "claude";
   const to = options.to;
@@ -4029,10 +4204,10 @@ async function convertCommand(options) {
 `);
     process.exit(1);
   }
-  const claudeMdPath = path25.join(projectRoot, "CLAUDE.md");
+  const claudeMdPath = path26.join(projectRoot, "CLAUDE.md");
   let content = "";
   try {
-    content = fs22.readFileSync(claudeMdPath, "utf-8");
+    content = fs23.readFileSync(claudeMdPath, "utf-8");
   } catch {
     process.stderr.write(`Error: CLAUDE.md not found at ${claudeMdPath}
 `);
@@ -4040,33 +4215,45 @@ async function convertCommand(options) {
   }
   if (to === "cursor") {
     const files = claudeMdToCursorRules(content);
-    const targetDir = path25.join(projectRoot, ".cursor", "rules");
+    const targetDir = path26.join(projectRoot, ".cursor", "rules");
     process.stdout.write(`
 Converting CLAUDE.md \u2192 ${files.length} Cursor rule file(s)
-
 `);
+    if (!options.dryRun) {
+      process.stdout.write(`  \u26A0  Existing .mdc files will be overwritten. A backup is saved automatically.
+`);
+      process.stdout.write(`     Run 'claudectx revert --list' to see backups.
+`);
+    }
+    process.stdout.write("\n");
     for (const file of files) {
-      const filePath = path25.join(targetDir, file.filename);
-      const exists = fs22.existsSync(filePath);
+      const filePath = path26.join(targetDir, file.filename);
+      const exists = fs23.existsSync(filePath);
       const prefix = options.dryRun ? "[dry-run] " : exists ? "[overwrite] " : "";
       process.stdout.write(`  ${prefix}\u2192 .cursor/rules/${file.filename}
 `);
       if (!options.dryRun) {
-        fs22.mkdirSync(targetDir, { recursive: true });
-        fs22.writeFileSync(filePath, file.content, "utf-8");
+        fs23.mkdirSync(targetDir, { recursive: true });
+        if (exists) await backupFile(filePath, "convert");
+        fs23.writeFileSync(filePath, file.content, "utf-8");
       }
     }
     process.stdout.write("\n");
   } else if (to === "copilot") {
     const converted = claudeMdToCopilot(content);
-    const targetPath = path25.join(projectRoot, ".github", "copilot-instructions.md");
-    const exists = fs22.existsSync(targetPath);
+    const targetPath = path26.join(projectRoot, ".github", "copilot-instructions.md");
+    const exists = fs23.existsSync(targetPath);
     process.stdout.write(`
 Converting CLAUDE.md \u2192 .github/copilot-instructions.md${exists ? " [overwrite]" : ""}
 `);
+    if (!options.dryRun && exists) {
+      process.stdout.write(`  \u26A0  Existing file will be overwritten. Run 'claudectx revert --list' to undo.
+`);
+    }
     if (!options.dryRun) {
-      fs22.mkdirSync(path25.dirname(targetPath), { recursive: true });
-      fs22.writeFileSync(targetPath, converted, "utf-8");
+      fs23.mkdirSync(path26.dirname(targetPath), { recursive: true });
+      if (exists) await backupFile(targetPath, "convert");
+      fs23.writeFileSync(targetPath, converted, "utf-8");
       process.stdout.write(`  \u2713 Written to ${targetPath}
 
 `);
@@ -4077,13 +4264,18 @@ Converting CLAUDE.md \u2192 .github/copilot-instructions.md${exists ? " [overwri
     }
   } else if (to === "windsurf") {
     const converted = claudeMdToWindsurf(content);
-    const targetPath = path25.join(projectRoot, ".windsurfrules");
-    const exists = fs22.existsSync(targetPath);
+    const targetPath = path26.join(projectRoot, ".windsurfrules");
+    const exists = fs23.existsSync(targetPath);
     process.stdout.write(`
 Converting CLAUDE.md \u2192 .windsurfrules${exists ? " [overwrite]" : ""}
 `);
+    if (!options.dryRun && exists) {
+      process.stdout.write(`  \u26A0  Existing file will be overwritten. Run 'claudectx revert --list' to undo.
+`);
+    }
     if (!options.dryRun) {
-      fs22.writeFileSync(targetPath, converted, "utf-8");
+      if (exists) await backupFile(targetPath, "convert");
+      fs23.writeFileSync(targetPath, converted, "utf-8");
       process.stdout.write(`  \u2713 Written to ${targetPath}
 
 `);
@@ -4101,15 +4293,15 @@ Converting CLAUDE.md \u2192 .windsurfrules${exists ? " [overwrite]" : ""}
 
 // src/commands/teams.ts
 init_cjs_shims();
-var path27 = __toESM(require("path"));
-var fs24 = __toESM(require("fs"));
+var path28 = __toESM(require("path"));
+var fs25 = __toESM(require("fs"));
 init_models();
 
 // src/reporter/team-aggregator.ts
 init_cjs_shims();
-var fs23 = __toESM(require("fs"));
-var path26 = __toESM(require("path"));
-var os4 = __toESM(require("os"));
+var fs24 = __toESM(require("fs"));
+var path27 = __toESM(require("path"));
+var os5 = __toESM(require("os"));
 var childProcess2 = __toESM(require("child_process"));
 init_session_reader();
 init_session_store();
@@ -4120,7 +4312,7 @@ function getDeveloperIdentity() {
     if (email) return email;
   } catch {
   }
-  return os4.hostname();
+  return os5.hostname();
 }
 function calcCost3(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens, model) {
   const p = MODEL_PRICING[model];
@@ -4237,19 +4429,19 @@ function aggregateTeamReports(exports2) {
 }
 function writeTeamExport(exportData) {
   const storeDir = getStoreDir();
-  if (!fs23.existsSync(storeDir)) fs23.mkdirSync(storeDir, { recursive: true });
+  if (!fs24.existsSync(storeDir)) fs24.mkdirSync(storeDir, { recursive: true });
   const date = isoDate2(/* @__PURE__ */ new Date());
-  const filePath = path26.join(storeDir, `team-export-${date}.json`);
-  fs23.writeFileSync(filePath, JSON.stringify(exportData, null, 2), "utf-8");
+  const filePath = path27.join(storeDir, `team-export-${date}.json`);
+  fs24.writeFileSync(filePath, JSON.stringify(exportData, null, 2), "utf-8");
   return filePath;
 }
 function readTeamExports(dir) {
   const exports2 = [];
-  if (!fs23.existsSync(dir)) return exports2;
-  const files = fs23.readdirSync(dir).filter((f) => f.match(/^team-export-.*\.json$/));
+  if (!fs24.existsSync(dir)) return exports2;
+  const files = fs24.readdirSync(dir).filter((f) => f.match(/^team-export-.*\.json$/));
   for (const file of files) {
     try {
-      const raw = fs23.readFileSync(path26.join(dir, file), "utf-8");
+      const raw = fs24.readFileSync(path27.join(dir, file), "utf-8");
       exports2.push(JSON.parse(raw));
     } catch {
     }
@@ -4336,7 +4528,7 @@ Run "claudectx teams export" on each developer machine first.
     process.stdout.write("  Top shared files (by read count across team):\n");
     for (const f of report.topWasteFiles.slice(0, 5)) {
       const devList = f.developers.slice(0, 3).join(", ");
-      process.stdout.write(`    ${f.readCount}x  ${path27.basename(f.filePath)}  (${devList})
+      process.stdout.write(`    ${f.readCount}x  ${path28.basename(f.filePath)}  (${devList})
 `);
     }
     process.stdout.write("\n");
@@ -4349,24 +4541,24 @@ async function teamsShare(options) {
     process.exit(1);
   }
   const storeDir = getStoreDir();
-  const exportFiles = fs24.readdirSync(storeDir).filter((f) => f.match(/^team-export-.*\.json$/)).sort().reverse();
+  const exportFiles = fs25.readdirSync(storeDir).filter((f) => f.match(/^team-export-.*\.json$/)).sort().reverse();
   if (exportFiles.length === 0) {
     process.stderr.write('No team export files found. Run "claudectx teams export" first.\n');
     process.exit(1);
   }
   const latest = exportFiles[0];
-  const src = path27.join(storeDir, latest);
+  const src = path28.join(storeDir, latest);
   let destPath;
   try {
-    const stat = fs24.statSync(dest);
-    destPath = stat.isDirectory() ? path27.join(dest, latest) : dest;
+    const stat = fs25.statSync(dest);
+    destPath = stat.isDirectory() ? path28.join(dest, latest) : dest;
   } catch {
     destPath = dest;
   }
-  const destDir = path27.dirname(path27.resolve(destPath));
+  const destDir = path28.dirname(path28.resolve(destPath));
   let resolvedDir;
   try {
-    resolvedDir = fs24.realpathSync(destDir);
+    resolvedDir = fs25.realpathSync(destDir);
   } catch {
     resolvedDir = destDir;
   }
@@ -4376,7 +4568,7 @@ async function teamsShare(options) {
 `);
     process.exit(1);
   }
-  fs24.copyFileSync(src, destPath);
+  fs25.copyFileSync(src, destPath);
   process.stdout.write(`  \u2713 Copied ${latest} \u2192 ${destPath}
 
 `);
@@ -4401,8 +4593,148 @@ async function teamsCommand(subcommand, options) {
   }
 }
 
+// src/commands/revert.ts
+init_cjs_shims();
+var path29 = __toESM(require("path"));
+function timeAgo(isoString) {
+  const diffMs = Date.now() - new Date(isoString).getTime();
+  const minutes = Math.floor(diffMs / 6e4);
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes} min ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+  const days = Math.floor(hours / 24);
+  return `${days} day${days === 1 ? "" : "s"} ago`;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  return `${Math.round(bytes / 1024)} KB`;
+}
+function printBackupTable(entries) {
+  if (entries.length === 0) {
+    process.stdout.write("  No backups found.\n");
+    process.stdout.write(`  Backups are created automatically when claudectx modifies your files.
+`);
+    process.stdout.write(`  Backup directory: ${BACKUP_DIR}
+
+`);
+    return;
+  }
+  const idWidth = 26;
+  const fileWidth = 20;
+  const cmdWidth = 10;
+  const timeWidth = 14;
+  const sizeWidth = 7;
+  const hr = "\u2550".repeat(idWidth + fileWidth + cmdWidth + timeWidth + sizeWidth + 16);
+  process.stdout.write("\n");
+  process.stdout.write("claudectx \u2014 Backup History\n");
+  process.stdout.write(hr + "\n");
+  process.stdout.write(
+    `  ${"ID".padEnd(idWidth)}  ${"File".padEnd(fileWidth)}  ${"Command".padEnd(cmdWidth)}  ${"When".padEnd(timeWidth)}  ${"Size".padEnd(sizeWidth)}
+`
+  );
+  process.stdout.write("\u2500".repeat(idWidth + fileWidth + cmdWidth + timeWidth + sizeWidth + 16) + "\n");
+  for (const entry of entries) {
+    const id = entry.id.slice(0, idWidth).padEnd(idWidth);
+    const file = path29.basename(entry.originalPath).slice(0, fileWidth).padEnd(fileWidth);
+    const cmd = entry.command.slice(0, cmdWidth).padEnd(cmdWidth);
+    const when = timeAgo(entry.createdAt).slice(0, timeWidth).padEnd(timeWidth);
+    const size = formatBytes(entry.sizeBytes).padEnd(sizeWidth);
+    process.stdout.write(`  ${id}  ${file}  ${cmd}  ${when}  ${size}
+`);
+  }
+  process.stdout.write("\n");
+  process.stdout.write(`  Backup directory: ${BACKUP_DIR}
+`);
+  process.stdout.write("  To restore: claudectx revert --id <ID>\n\n");
+}
+async function interactivePick(entries) {
+  try {
+    const { select } = await import("@inquirer/prompts");
+    const choices = entries.map((e) => ({
+      name: `${timeAgo(e.createdAt).padEnd(14)}  ${path29.basename(e.originalPath).padEnd(16)}  [${e.command}]  ${e.id}`,
+      value: e.id
+    }));
+    choices.push({ name: "Cancel", value: "" });
+    return await select({ message: "Choose a backup to restore:", choices });
+  } catch {
+    process.stderr.write("Interactive mode unavailable. Use --id <id> to restore a specific backup.\n");
+    return null;
+  }
+}
+async function doRestore(id) {
+  const chalk5 = (await import("chalk")).default;
+  process.stdout.write("\n");
+  try {
+    const entries = await listBackups();
+    const entry = entries.find((e) => e.id === id);
+    if (!entry) {
+      process.stderr.write(chalk5.red(`Backup "${id}" not found.
+`));
+      process.stderr.write('Run "claudectx revert --list" to see available backups.\n');
+      process.exitCode = 1;
+      return;
+    }
+    process.stdout.write(chalk5.yellow(`\u26A0  This will overwrite: ${entry.originalPath}
+`));
+    process.stdout.write(`   Backup from: ${timeAgo(entry.createdAt)} (${entry.command})
+`);
+    process.stdout.write(`   Your current file will be backed up first (so you can undo this).
+
+`);
+    let confirmed = true;
+    try {
+      const { confirm: confirm2 } = await import("@inquirer/prompts");
+      confirmed = await confirm2({ message: "Restore this backup?", default: false });
+    } catch {
+    }
+    if (!confirmed) {
+      process.stdout.write("  Cancelled.\n\n");
+      return;
+    }
+    const { undoEntry } = await restoreBackup(id);
+    process.stdout.write(chalk5.green("  \u2713 ") + `Restored to ${entry.originalPath}
+`);
+    if (undoEntry) {
+      process.stdout.write(
+        chalk5.dim(`  Your previous version was saved as backup "${undoEntry.id}" \u2014 run 'claudectx revert --id ${undoEntry.id}' to undo.
+`)
+      );
+    }
+    process.stdout.write("\n");
+  } catch (err) {
+    process.stderr.write(chalk5.red(`Error: ${err instanceof Error ? err.message : String(err)}
+`));
+    process.exitCode = 1;
+  }
+}
+async function revertCommand(options) {
+  const entries = await listBackups(options.file);
+  if (options.json) {
+    process.stdout.write(JSON.stringify({ backups: entries }, null, 2) + "\n");
+    return;
+  }
+  if (options.list) {
+    printBackupTable(entries);
+    return;
+  }
+  if (options.id) {
+    await doRestore(options.id);
+    return;
+  }
+  if (entries.length === 0) {
+    process.stdout.write("\n  No backups found. Backups are created automatically when claudectx modifies your files.\n\n");
+    return;
+  }
+  printBackupTable(entries);
+  const picked = await interactivePick(entries);
+  if (picked) {
+    await doRestore(picked);
+  }
+}
+
 // src/index.ts
-var VERSION = "1.1.2";
+var VERSION = "1.1.3";
 var DESCRIPTION = "Reduce Claude Code token usage by up to 80%. Context analyzer, auto-optimizer, live dashboard, and smart MCP tools.";
 var program = new import_commander.Command();
 program.name("claudectx").description(DESCRIPTION).version(VERSION);
@@ -4442,5 +4774,8 @@ program.command("convert").description("Convert CLAUDE.md to another AI assistan
 program.command("teams [subcommand]").description("Multi-developer cost attribution (export | aggregate | share)").option("--days <n>", "Days to include", "30").option("-m, --model <model>", "Model", "sonnet").option("--anonymize", "Replace identities with Dev 1, Dev 2...").option("--dir <path>", "Directory with team export JSON files").option("--to <path>", "Destination for share sub-command").option("--json", "JSON output").action(async (subcommand, options) => {
   await teamsCommand(subcommand ?? "export", options);
 });
+program.command("revert").description("List and restore backups created automatically by claudectx commands").option("--list", "Show all backups").option("--id <id>", "Restore a specific backup by ID").option("--file <path>", "Filter backups by original file path").option("--json", "JSON output").action(async (options) => {
+  await revertCommand(options);
+});
 program.parse();
 //# sourceMappingURL=index.js.map