claudectx 1.1.2 → 1.1.3

package/dist/index.mjs

@@ -104,19 +104,19 @@ __export(session_store_exports, {
   getStoreDir: () => getStoreDir,
   readAllEvents: () => readAllEvents
 });
-import * as fs8 from "fs";
-import * as os2 from "os";
-import * as path9 from "path";
+import * as fs9 from "fs";
+import * as os3 from "os";
+import * as path10 from "path";
 function getStoreDirPath() {
-  return path9.join(os2.homedir(), ".claudectx");
+  return path10.join(os3.homedir(), ".claudectx");
 }
 function getReadsFilePath_() {
-  return path9.join(getStoreDirPath(), "reads.jsonl");
+  return path10.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) {
@@ -126,12 +126,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);
@@ -160,8 +160,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() {
@@ -178,28 +178,28 @@ var init_session_store = __esm({
 });
 
 // src/watcher/session-reader.ts
-import * as fs9 from "fs";
-import * as os3 from "os";
-import * as path10 from "path";
+import * as fs10 from "fs";
+import * as os4 from "os";
+import * as path11 from "path";
 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 = path10.join(CLAUDE_PROJECTS_DIR, projectDir);
+      const projectPath = path11.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 = path10.join(projectPath, file);
+          const filePath = path11.join(projectPath, file);
           try {
-            const fstat = fs9.statSync(filePath);
+            const fstat = fs10.statSync(filePath);
             results.push({
               filePath,
               mtimeMs: fstat.mtimeMs,
-              sessionId: path10.basename(file, ".jsonl"),
+              sessionId: path11.basename(file, ".jsonl"),
               projectDir
             });
           } catch {
@@ -230,7 +230,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 {
@@ -265,7 +265,7 @@ var init_session_reader = __esm({
   "src/watcher/session-reader.ts"() {
     "use strict";
     init_esm_shims();
-    CLAUDE_PROJECTS_DIR = path10.join(os3.homedir(), ".claude", "projects");
+    CLAUDE_PROJECTS_DIR = path11.join(os4.homedir(), ".claude", "projects");
   }
 });
 
@@ -276,8 +276,8 @@ __export(Dashboard_exports, {
 });
 import { useState, useEffect, useCallback } from "react";
 import { Box, Text, useApp, useInput } from "ink";
-import * as fs10 from "fs";
-import * as path11 from "path";
+import * as fs11 from "fs";
+import * as path12 from "path";
 import { jsx, jsxs } from "react/jsx-runtime";
 function fmtNum(n) {
   return n.toLocaleString();
@@ -288,7 +288,7 @@ function fmtCost(tokens, model) {
   return `$${cost.toFixed(4)}`;
 }
 function shortPath(filePath) {
-  const parts = filePath.split(path11.sep);
+  const parts = filePath.split(path12.sep);
   if (parts.length <= 3) return filePath;
   return "\u2026/" + parts.slice(-3).join("/");
 }
@@ -410,9 +410,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 {
         }
       }
@@ -450,7 +450,7 @@ function Dashboard({
       ] }),
       sessionFile && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
         "  \u2014  ",
-        path11.basename(sessionFile, ".jsonl").slice(0, 8),
+        path12.basename(sessionFile, ".jsonl").slice(0, 8),
         "\u2026"
       ] }),
       !sessionFile && /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  \u2014  no session file found" })
@@ -477,10 +477,10 @@ var init_Dashboard = __esm({
 });
 
 // src/mcp/smart-reader.ts
-import * as fs12 from "fs";
-import * as path14 from "path";
+import * as fs13 from "fs";
+import * as path15 from "path";
 function detectLanguage(filePath) {
-  const ext = path14.extname(filePath).toLowerCase();
+  const ext = path15.extname(filePath).toLowerCase();
   switch (ext) {
     case ".ts":
     case ".tsx":
@@ -497,8 +497,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;
@@ -559,8 +559,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);
@@ -575,7 +575,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) {
@@ -587,7 +587,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
       };
@@ -599,7 +599,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);
@@ -673,15 +673,15 @@ var init_smart_reader = __esm({
 });
 
 // src/mcp/symbol-index.ts
-import * as fs13 from "fs";
-import * as path15 from "path";
+import * as fs14 from "fs";
+import * as path16 from "path";
 import { glob } from "glob";
 function extractSymbolsFromFile(filePath) {
   const lang = detectLanguage(filePath);
   if (lang === "other") return [];
   let content;
   try {
-    content = fs13.readFileSync(filePath, "utf-8");
+    content = fs14.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -766,8 +766,8 @@ var init_symbol_index = __esm({
         this.entries = [];
         let files = [];
         try {
-          files = await glob(SOURCE_GLOBS.map((g) => path15.join(projectRoot, g)), {
-            ignore: IGNORE_DIRS.map((g) => path15.join(projectRoot, g)),
+          files = await glob(SOURCE_GLOBS.map((g) => path16.join(projectRoot, g)), {
+            ignore: IGNORE_DIRS.map((g) => path16.join(projectRoot, g)),
             absolute: true
           });
         } catch {
@@ -820,7 +820,7 @@ var server_exports = {};
 __export(server_exports, {
   startMcpServer: () => startMcpServer
 });
-import * as path16 from "path";
+import * as path17 from "path";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
@@ -828,7 +828,7 @@ import {
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 function handleSmartRead(args) {
-  const filePath = path16.resolve(args.file);
+  const filePath = path17.resolve(args.file);
   const result = smartRead(
     filePath,
     args.symbol,
@@ -864,7 +864,7 @@ Example: index_project({ "project_root": "${process.cwd()}" })`;
   ];
   for (let i = 0; i < results.length; i++) {
     const r = results[i];
-    const rel = path16.relative(process.cwd(), r.filePath);
+    const rel = path17.relative(process.cwd(), r.filePath);
     lines.push(`${i + 1}. [${r.type}] ${r.name}`);
     lines.push(`   ${rel}:${r.lineStart}`);
     lines.push(`   ${r.signature.trim()}`);
@@ -876,7 +876,7 @@ Example: index_project({ "project_root": "${process.cwd()}" })`;
   return lines.join("\n");
 }
 async function handleIndexProject(args) {
-  const projectRoot = args.project_root ? path16.resolve(args.project_root) : process.cwd();
+  const projectRoot = args.project_root ? path17.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) {
@@ -1563,8 +1563,8 @@ async function analyzeCommand(options) {
 
 // src/commands/optimize.ts
 init_esm_shims();
-import * as fs7 from "fs";
-import * as path8 from "path";
+import * as fs8 from "fs";
+import * as path9 from "path";
 import chalk3 from "chalk";
 import boxen2 from "boxen";
 import { checkbox, confirm } from "@inquirer/prompts";
@@ -1728,8 +1728,131 @@ function writeIgnorefile(result) {
 // src/optimizer/claudemd-splitter.ts
 init_esm_shims();
 init_tokenizer();
+import * as fs5 from "fs";
+import * as path7 from "path";
+
+// src/shared/backup-manager.ts
+init_esm_shims();
 import * as fs4 from "fs";
+import * as os2 from "os";
 import * as path6 from "path";
+var MAX_BACKUPS = 50;
+var _backupDirOverride = null;
+function getBackupDir() {
+  return _backupDirOverride ?? path6.join(os2.homedir(), ".claudectx", "backups");
+}
+var BACKUP_DIR = path6.join(os2.homedir(), ".claudectx", "backups");
+function ensureBackupDir() {
+  const dir = getBackupDir();
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
+  }
+}
+function getManifestPath() {
+  return path6.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 = path6.basename(originalPath);
+  return `${ts}-${rand}-${basename10}`;
+}
+async function backupFile(filePath, command) {
+  const resolved = path6.resolve(filePath);
+  if (!fs4.existsSync(resolved)) {
+    throw new Error(`Cannot back up "${resolved}": file does not exist.`);
+  }
+  ensureBackupDir();
+  const id = generateId(resolved);
+  const backupPath = path6.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 = path6.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 = path6.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, "");
@@ -1764,9 +1887,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 = path6.join(path6.dirname(claudeMdPath), ".claude");
+  const claudeDir = path7.join(path7.dirname(claudeMdPath), ".claude");
   const extractedFiles = [];
   let newContent = "";
   let tokensSaved = 0;
@@ -1779,7 +1902,7 @@ function planSplit(claudeMdPath, sectionsToExtract) {
       usedSlugs.set(slug, count + 1);
       const filename = `${slug}.md`;
       const relRefPath = `.claude/${filename}`;
-      const filePath = path6.join(claudeDir, filename);
+      const filePath = path7.join(claudeDir, filename);
       const refBlock = `## ${section.title}
 
 @${relRefPath}
@@ -1803,21 +1926,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 = path6.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 = path7.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_esm_shims();
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 function findCacheBusters(content) {
   const fixes = [];
   const lines = content.split("\n");
@@ -1847,18 +1973,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_esm_shims();
-import * as fs6 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 var CLAUDECTX_HOOKS = {
   PostToolUse: [
     {
@@ -1876,13 +2005,13 @@ var CLAUDECTX_HOOKS = {
   ]
 };
 function planHooksInstall(projectRoot) {
-  const claudeDir = path7.join(projectRoot, ".claude");
-  const settingsPath = path7.join(claudeDir, "settings.local.json");
-  const existed = fs6.existsSync(settingsPath);
+  const claudeDir = path8.join(projectRoot, ".claude");
+  const settingsPath = path8.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 = {};
     }
@@ -1903,25 +2032,25 @@ function planHooksInstall(projectRoot) {
   return { settingsPath, existed, mergedSettings };
 }
 function applyHooksInstall(result) {
-  const dir = path7.dirname(result.settingsPath);
-  if (!fs6.existsSync(dir)) {
-    fs6.mkdirSync(dir, { recursive: true });
+  const dir = path8.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 = path7.join(projectRoot, ".claude", "settings.local.json");
-  const dir = path7.dirname(settingsPath);
-  if (!fs6.existsSync(dir)) {
-    fs6.mkdirSync(dir, { recursive: true });
+  const settingsPath = path8.join(projectRoot, ".claude", "settings.local.json");
+  const dir = path8.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 = path7.join(projectRoot, ".claude", "settings.local.json");
-  if (!fs6.existsSync(settingsPath)) return false;
+  const settingsPath = path8.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 {
@@ -1931,7 +2060,7 @@ function isAlreadyInstalled(projectRoot) {
 
 // src/commands/optimize.ts
 async function optimizeCommand(options) {
-  const projectPath = options.path ? path8.resolve(options.path) : findProjectRoot() ?? process.cwd();
+  const projectPath = options.path ? path9.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;
@@ -2056,12 +2185,12 @@ async function runIgnorefile(projectRoot, dryRun, autoApply) {
 }
 async function runClaudeMdSplit(projectRoot, report, dryRun, autoApply) {
   printSectionHeader("CLAUDE.md \u2192 @files");
-  const claudeMdPath = path8.join(projectRoot, "CLAUDE.md");
-  if (!fs7.existsSync(claudeMdPath)) {
+  const claudeMdPath = path9.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
@@ -2117,18 +2246,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: ${chalk3.cyan(path8.relative(projectRoot, f.filePath))}`);
+    logger.info(`  Created: ${chalk3.cyan(path9.relative(projectRoot, f.filePath))}`);
   }
 }
 async function runCacheOptimization(projectRoot, dryRun, autoApply) {
   printSectionHeader("Prompt cache optimisation");
-  const claudeMdPath = path8.join(projectRoot, "CLAUDE.md");
-  if (!fs7.existsSync(claudeMdPath)) {
+  const claudeMdPath = path9.join(projectRoot, "CLAUDE.md");
+  if (!fs8.existsSync(claudeMdPath)) {
     logger.warn("No CLAUDE.md found \u2014 skipping.");
     return;
   }
@@ -2156,14 +2285,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: ${chalk3.cyan(path8.relative(projectRoot, result.settingsPath))}`
+    `Settings file: ${chalk3.cyan(path9.relative(projectRoot, result.settingsPath))}`
   );
   logger.info(result.existed ? "Will merge with existing settings." : "Will create new file.");
   console.log(chalk3.dim("\n  Hooks to install:"));
@@ -2178,7 +2307,7 @@ async function runHooks(projectRoot, dryRun, autoApply) {
   }
   applyHooksInstall(result);
   logger.success(
-    `Hooks installed \u2192 ${chalk3.cyan(path8.relative(projectRoot, result.settingsPath))}`
+    `Hooks installed \u2192 ${chalk3.cyan(path9.relative(projectRoot, result.settingsPath))}`
   );
 }
 function printSectionHeader(title) {
@@ -2190,7 +2319,7 @@ function printSectionHeader(title) {
 init_esm_shims();
 init_session_store();
 init_models();
-import * as path12 from "path";
+import * as path13 from "path";
 async function watchCommand(options) {
   if (options.logStdin) {
     await handleLogStdin();
@@ -2226,30 +2355,30 @@ async function handleLogStdin() {
     const payload = JSON.parse(raw);
     const filePath = payload.tool_input?.file_path;
     if (filePath) {
-      appendFileRead(path12.resolve(filePath), payload.session_id);
+      appendFileRead(path13.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_esm_shims();
-import * as path17 from "path";
+import * as path18 from "path";
 import chalk4 from "chalk";
 
 // src/mcp/installer.ts
 init_esm_shims();
-import * as fs11 from "fs";
-import * as path13 from "path";
+import * as fs12 from "fs";
+import * as path14 from "path";
 var SERVER_NAME = "claudectx";
 var SERVER_ENTRY = {
   command: "claudectx",
@@ -2257,13 +2386,13 @@ var SERVER_ENTRY = {
   type: "stdio"
 };
 function planInstall(projectRoot) {
-  const claudeDir = path13.join(projectRoot, ".claude");
-  const settingsPath = path13.join(claudeDir, "settings.json");
-  const existed = fs11.existsSync(settingsPath);
+  const claudeDir = path14.join(projectRoot, ".claude");
+  const settingsPath = path14.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 = {};
     }
@@ -2280,21 +2409,21 @@ function planInstall(projectRoot) {
   return { settingsPath, existed, alreadyInstalled, mergedSettings };
 }
 function applyInstall(result) {
-  const dir = path13.dirname(result.settingsPath);
-  if (!fs11.existsSync(dir)) {
-    fs11.mkdirSync(dir, { recursive: true });
+  const dir = path14.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 = path13.join(projectRoot, ".claude", "settings.json");
-  if (!fs11.existsSync(settingsPath)) return false;
+  const settingsPath = path14.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;
@@ -2303,7 +2432,7 @@ function isInstalled(projectRoot) {
 
 // src/commands/mcp.ts
 async function mcpCommand(options) {
-  const projectRoot = options.path ? path17.resolve(options.path) : process.cwd();
+  const projectRoot = options.path ? path18.resolve(options.path) : process.cwd();
   if (options.install) {
     await runInstall(projectRoot);
     return;
@@ -2352,12 +2481,12 @@ async function runInstall(projectRoot) {
 // src/commands/compress.ts
 init_esm_shims();
 init_session_reader();
-import * as path19 from "path";
-import * as fs16 from "fs";
+import * as path20 from "path";
+import * as fs17 from "fs";
 
 // src/compressor/session-parser.ts
 init_esm_shims();
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 function extractText(content) {
   if (!content) return "";
   if (typeof content === "string") return content;
@@ -2368,10 +2497,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;
   }
@@ -2571,13 +2700,13 @@ function calcCost(inputTokens, outputTokens) {
 
 // src/compressor/memory-writer.ts
 init_esm_shims();
-import * as fs15 from "fs";
-import * as path18 from "path";
+import * as fs16 from "fs";
+import * as path19 from "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;
@@ -2628,15 +2757,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 = path18.dirname(memoryFilePath);
-  if (!fs15.existsSync(dir)) {
-    fs15.mkdirSync(dir, { recursive: true });
+  const dir = path19.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);
@@ -2649,7 +2778,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) {
@@ -2660,8 +2789,8 @@ function isAlreadyCompressed(memoryFilePath, sessionId) {
 // src/commands/compress.ts
 async function compressCommand(options) {
   const chalk5 = (await import("chalk")).default;
-  const projectRoot = options.path ? path19.resolve(options.path) : process.cwd();
-  const memoryFilePath = path19.join(projectRoot, "MEMORY.md");
+  const projectRoot = options.path ? path20.resolve(options.path) : process.cwd();
+  const memoryFilePath = path20.join(projectRoot, "MEMORY.md");
   const sessionFiles = listSessionFiles();
   if (sessionFiles.length === 0) {
     process.stdout.write(chalk5.red("No Claude Code sessions found.\n"));
@@ -2686,7 +2815,7 @@ async function compressCommand(options) {
   } else {
     targetFile = sessionFiles[0].filePath;
   }
-  const sessionId = path19.basename(targetFile, ".jsonl");
+  const sessionId = path20.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.
@@ -2734,11 +2863,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.
 `)
       );
     }
@@ -3016,13 +3161,13 @@ async function reportCommand(options) {
 
 // src/commands/budget.ts
 init_esm_shims();
-import * as path21 from "path";
+import * as path22 from "path";
 
 // src/analyzer/budget-estimator.ts
 init_esm_shims();
 init_tokenizer();
-import * as fs17 from "fs";
-import * as path20 from "path";
+import * as fs18 from "fs";
+import * as path21 from "path";
 import { glob as glob2 } from "glob";
 init_session_store();
 function resolveGlobs(globs, projectRoot) {
@@ -3047,20 +3192,20 @@ function classifyCacheHit(recentReadCount) {
   return "low";
 }
 function suggestClaudeignoreAdditions(files, projectRoot) {
-  const ignorePath = path20.join(projectRoot, ".claudeignore");
+  const ignorePath = path21.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 = path20.relative(projectRoot, file.filePath);
+    const rel = path21.relative(projectRoot, file.filePath);
     const alreadyIgnored = ignorePatterns.some((pattern) => {
       const cleanPattern = pattern.replace(/^!/, "");
-      return rel.startsWith(cleanPattern.replace(/\*/g, "").replace(/\//g, path20.sep));
+      return rel.startsWith(cleanPattern.replace(/\*/g, "").replace(/\//g, path21.sep));
     });
     if (!alreadyIgnored) {
       recommendations.push(rel);
@@ -3080,7 +3225,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;
     }
@@ -3129,7 +3274,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) => path20.basename(f.filePath).length)),
+    Math.max(...report.files.map((f) => path21.basename(f.filePath).length)),
     40
   );
   lines.push(
@@ -3137,7 +3282,7 @@ function formatBudgetReport(report) {
   );
   lines.push("\u2500".repeat(50));
   for (const file of report.files.slice(0, 20)) {
-    const name = path20.basename(file.filePath).slice(0, maxPathLen).padEnd(maxPathLen);
+    const name = path21.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);
@@ -3166,7 +3311,7 @@ function formatBudgetReport(report) {
 // src/commands/budget.ts
 init_models();
 async function budgetCommand(globs, 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 ?? "sonnet");
   const thresholdTokens = parseInt(options.threshold ?? "10000", 10);
@@ -3185,10 +3330,10 @@ async function budgetCommand(globs, options) {
 
 // src/commands/warmup.ts
 init_esm_shims();
-import * as path22 from "path";
+import * as path23 from "path";
 import Anthropic from "@anthropic-ai/sdk";
 init_models();
-import fs18 from "fs";
+import fs19 from "fs";
 function buildWarmupMessages(claudeMdContent) {
   const systemBlock = {
     type: "text",
@@ -3259,6 +3404,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}`;
@@ -3281,16 +3439,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 {
       }
     }
@@ -3307,7 +3465,7 @@ ${cronLine}
   }
 }
 async function warmupCommand(options) {
-  const projectPath = options.path ? path22.resolve(options.path) : process.cwd();
+  const projectPath = options.path ? path23.resolve(options.path) : process.cwd();
   const projectRoot = findProjectRoot(projectPath) ?? projectPath;
   const model = resolveModel(options.model ?? "haiku");
   const ttl = options.ttl === "60" ? 60 : 5;
@@ -3319,9 +3477,9 @@ async function warmupCommand(options) {
     process.exit(1);
   }
   let claudeMdContent = "";
-  const claudeMdPath = path22.join(projectRoot, "CLAUDE.md");
+  const claudeMdPath = path23.join(projectRoot, "CLAUDE.md");
   try {
-    claudeMdContent = fs18.readFileSync(claudeMdPath, "utf-8");
+    claudeMdContent = fs19.readFileSync(claudeMdPath, "utf-8");
   } catch {
     process.stderr.write(`Warning: No CLAUDE.md found at ${claudeMdPath}
 `);
@@ -3379,15 +3537,15 @@ async function warmupCommand(options) {
 
 // src/commands/drift.ts
 init_esm_shims();
-import * as path24 from "path";
-import * as fs20 from "fs";
+import * as path25 from "path";
+import * as fs21 from "fs";
 
 // src/analyzer/drift-detector.ts
 init_esm_shims();
 init_tokenizer();
 init_session_store();
-import * as fs19 from "fs";
-import * as path23 from "path";
+import * as fs20 from "fs";
+import * as path24 from "path";
 import * as childProcess from "child_process";
 var INLINE_PATH_RE = /(?:^|\s)((?:\.{1,2}\/|src\/|lib\/|docs\/|app\/|tests?\/)\S+\.\w{1,6})/gm;
 var AT_REF_RE = /^@(.+)$/;
@@ -3398,8 +3556,8 @@ function findDeadAtReferences(content, projectRoot) {
     const match = lines[i].match(AT_REF_RE);
     if (!match) continue;
     const ref = match[1].trim();
-    const absPath = path23.isAbsolute(ref) ? ref : path23.join(projectRoot, ref);
-    if (!fs19.existsSync(absPath)) {
+    const absPath = path24.isAbsolute(ref) ? ref : path24.join(projectRoot, ref);
+    if (!fs20.existsSync(absPath)) {
       const lineText = lines[i];
       issues.push({
         type: "dead-ref",
@@ -3432,15 +3590,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 = path23.basename(deleted);
-      if (line.includes(basename8) || line.includes(deleted)) {
+      const basename10 = path24.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;
       }
@@ -3505,8 +3663,8 @@ function findDeadInlinePaths(content, projectRoot) {
       const rawPath = match[1].trim();
       if (seen.has(rawPath)) continue;
       seen.add(rawPath);
-      const absPath = path23.isAbsolute(rawPath) ? rawPath : path23.join(projectRoot, rawPath);
-      if (!fs19.existsSync(absPath)) {
+      const absPath = path24.isAbsolute(rawPath) ? rawPath : path24.join(projectRoot, rawPath);
+      if (!fs20.existsSync(absPath)) {
         issues.push({
           type: "dead-inline-path",
           line: i + 1,
@@ -3522,10 +3680,10 @@ function findDeadInlinePaths(content, projectRoot) {
   return issues;
 }
 async function detectDrift(projectRoot, dayWindow) {
-  const claudeMdPath = path23.join(projectRoot, "CLAUDE.md");
+  const claudeMdPath = path24.join(projectRoot, "CLAUDE.md");
   let content = "";
   try {
-    content = fs19.readFileSync(claudeMdPath, "utf-8");
+    content = fs20.readFileSync(claudeMdPath, "utf-8");
   } catch {
     return {
       claudeMdPath,
@@ -3567,7 +3725,7 @@ var TYPE_LABEL = {
   "dead-inline-path": "Dead path"
 };
 async function driftCommand(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 dayWindow = parseInt(options.days ?? "30", 10);
   const report = await detectDrift(projectRoot, dayWindow);
@@ -3643,25 +3801,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)}
@@ -3669,18 +3827,18 @@ async function applyFix(claudeMdPath, issues) {
     process.exit(1);
   }
   process.stdout.write(`
-  \u2713 Removed ${selectedLines.length} line(s) from ${path24.basename(claudeMdPath)}
+  \u2713 Removed ${selectedLines.length} line(s) from ${path25.basename(claudeMdPath)}
 `);
   process.stdout.write(`  \u2713 Backup saved to ${backupPath}
 
 `);
-  void os5;
+  void os6;
 }
 
 // src/commands/hooks.ts
 init_esm_shims();
-import * as fs21 from "fs";
-import * as path25 from "path";
+import * as fs22 from "fs";
+import * as path26 from "path";
 
 // src/hooks/registry.ts
 init_esm_shims();
@@ -3756,17 +3914,17 @@ function buildHookEntry(def, config) {
 
 // src/commands/hooks.ts
 function readInstalledHooks(projectRoot) {
-  const settingsPath = path25.join(projectRoot, ".claude", "settings.local.json");
-  if (!fs21.existsSync(settingsPath)) return {};
+  const settingsPath = path26.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 {};
@@ -3886,9 +4044,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 = path26.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.
 
 `);
 }
@@ -3913,7 +4088,7 @@ async function hooksStatus(projectRoot) {
   process.stdout.write("\n");
 }
 async function hooksCommand(subcommand, 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 sub = subcommand ?? "list";
   switch (sub) {
@@ -3952,8 +4127,8 @@ async function hooksCommand(subcommand, options) {
 
 // src/commands/convert.ts
 init_esm_shims();
-import * as fs22 from "fs";
-import * as path26 from "path";
+import * as fs23 from "fs";
+import * as path27 from "path";
 function slugify2(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -4002,7 +4177,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 ? path26.resolve(options.path) : process.cwd();
+  const projectPath = options.path ? path27.resolve(options.path) : process.cwd();
   const projectRoot = findProjectRoot(projectPath) ?? projectPath;
   const from = options.from ?? "claude";
   const to = options.to;
@@ -4011,10 +4186,10 @@ async function convertCommand(options) {
 `);
     process.exit(1);
   }
-  const claudeMdPath = path26.join(projectRoot, "CLAUDE.md");
+  const claudeMdPath = path27.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}
 `);
@@ -4022,33 +4197,45 @@ async function convertCommand(options) {
   }
   if (to === "cursor") {
     const files = claudeMdToCursorRules(content);
-    const targetDir = path26.join(projectRoot, ".cursor", "rules");
+    const targetDir = path27.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 = path26.join(targetDir, file.filename);
-      const exists = fs22.existsSync(filePath);
+      const filePath = path27.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 = path26.join(projectRoot, ".github", "copilot-instructions.md");
-    const exists = fs22.existsSync(targetPath);
+    const targetPath = path27.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(path26.dirname(targetPath), { recursive: true });
-      fs22.writeFileSync(targetPath, converted, "utf-8");
+      fs23.mkdirSync(path27.dirname(targetPath), { recursive: true });
+      if (exists) await backupFile(targetPath, "convert");
+      fs23.writeFileSync(targetPath, converted, "utf-8");
       process.stdout.write(`  \u2713 Written to ${targetPath}
 
 `);
@@ -4059,13 +4246,18 @@ Converting CLAUDE.md \u2192 .github/copilot-instructions.md${exists ? " [overwri
     }
   } else if (to === "windsurf") {
     const converted = claudeMdToWindsurf(content);
-    const targetPath = path26.join(projectRoot, ".windsurfrules");
-    const exists = fs22.existsSync(targetPath);
+    const targetPath = path27.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}
 
 `);
@@ -4084,17 +4276,17 @@ Converting CLAUDE.md \u2192 .windsurfrules${exists ? " [overwrite]" : ""}
 // src/commands/teams.ts
 init_esm_shims();
 init_models();
-import * as path28 from "path";
-import * as fs24 from "fs";
+import * as path29 from "path";
+import * as fs25 from "fs";
 
 // src/reporter/team-aggregator.ts
 init_esm_shims();
 init_session_reader();
 init_session_store();
 init_models();
-import * as fs23 from "fs";
-import * as path27 from "path";
-import * as os4 from "os";
+import * as fs24 from "fs";
+import * as path28 from "path";
+import * as os5 from "os";
 import * as childProcess2 from "child_process";
 function getDeveloperIdentity() {
   try {
@@ -4102,7 +4294,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];
@@ -4219,19 +4411,19 @@ function aggregateTeamReports(exports) {
 }
 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 = path27.join(storeDir, `team-export-${date}.json`);
-  fs23.writeFileSync(filePath, JSON.stringify(exportData, null, 2), "utf-8");
+  const filePath = path28.join(storeDir, `team-export-${date}.json`);
+  fs24.writeFileSync(filePath, JSON.stringify(exportData, null, 2), "utf-8");
   return filePath;
 }
 function readTeamExports(dir) {
   const exports = [];
-  if (!fs23.existsSync(dir)) return exports;
-  const files = fs23.readdirSync(dir).filter((f) => f.match(/^team-export-.*\.json$/));
+  if (!fs24.existsSync(dir)) return exports;
+  const files = fs24.readdirSync(dir).filter((f) => f.match(/^team-export-.*\.json$/));
   for (const file of files) {
     try {
-      const raw = fs23.readFileSync(path27.join(dir, file), "utf-8");
+      const raw = fs24.readFileSync(path28.join(dir, file), "utf-8");
       exports.push(JSON.parse(raw));
     } catch {
     }
@@ -4318,7 +4510,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  ${path28.basename(f.filePath)}  (${devList})
+      process.stdout.write(`    ${f.readCount}x  ${path29.basename(f.filePath)}  (${devList})
 `);
     }
     process.stdout.write("\n");
@@ -4331,24 +4523,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 = path28.join(storeDir, latest);
+  const src = path29.join(storeDir, latest);
   let destPath;
   try {
-    const stat = fs24.statSync(dest);
-    destPath = stat.isDirectory() ? path28.join(dest, latest) : dest;
+    const stat = fs25.statSync(dest);
+    destPath = stat.isDirectory() ? path29.join(dest, latest) : dest;
   } catch {
     destPath = dest;
   }
-  const destDir = path28.dirname(path28.resolve(destPath));
+  const destDir = path29.dirname(path29.resolve(destPath));
   let resolvedDir;
   try {
-    resolvedDir = fs24.realpathSync(destDir);
+    resolvedDir = fs25.realpathSync(destDir);
   } catch {
     resolvedDir = destDir;
   }
@@ -4358,7 +4550,7 @@ async function teamsShare(options) {
 `);
     process.exit(1);
   }
-  fs24.copyFileSync(src, destPath);
+  fs25.copyFileSync(src, destPath);
   process.stdout.write(`  \u2713 Copied ${latest} \u2192 ${destPath}
 
 `);
@@ -4383,8 +4575,148 @@ async function teamsCommand(subcommand, options) {
   }
 }
 
+// src/commands/revert.ts
+init_esm_shims();
+import * as path30 from "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 = path30.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)}  ${path30.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 Command();
 program.name("claudectx").description(DESCRIPTION).version(VERSION);
@@ -4424,5 +4756,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.mjs.map