@ruso-0/nreki 7.1.2 → 7.3.0

package/dist/kernel/nreki-kernel.js

@@ -5,7 +5,8 @@ import * as crypto from "crypto";
 import { isSensitivePath } from "../utils/path-jail.js";
 import { readSource } from "../utils/read-source.js";
 import { toPosix as toPosixUtil } from "../utils/to-posix.js";
-import { logger } from "../utils/logger.js";
+import { logger, setTxId, clearTxId } from "../utils/logger.js";
+import { latencyTracker } from "../utils/latency-tracker.js";
 import { TsCompilerWrapper } from "./backends/ts-compiler-wrapper.js";
 // ─── Async FIFO Mutex (P10) ────────────────────────────────────────
 export class AsyncMutex {
@@ -49,7 +50,7 @@ export class AsyncMutex {
     async withLock(fn) {
         const unlock = await this.lock();
         try {
-            return await Promise.resolve().then(fn);
+            return await fn();
         }
         finally {
             unlock();
@@ -115,6 +116,124 @@ export class NrekiKernel {
             return true;
         return false;
     }
+    /**
+     * Convierte una posición LSP (Línea, Carácter 0-indexed)
+     * a un índice absoluto de string. Sobrevive \r\n (Windows).
+     */
+    getLspOffset(content, line, character) {
+        let currentLine = 0;
+        let offset = 0;
+        while (currentLine < line && offset < content.length) {
+            const nl = content.indexOf('\n', offset);
+            if (nl === -1)
+                break;
+            offset = nl + 1;
+            currentLine++;
+        }
+        return Math.min(offset + character, content.length);
+    }
+    /**
+     * TTRD Sintáctico - Micro-Scanner Híbrido (O(N), Cero dependencias).
+     * Extrae firmas de Python y Go crudas del VFS a prueba de
+     * formateadores (Black/Ruff/gofmt) y strings embebidos.
+     * Usa Regex SOLO para anclar el inicio (def/func), y un
+     * Bracket Balancer para parsear el interior.
+     */
+    extractRawSignatures(content, ext) {
+        const signatures = new Map();
+        if (ext !== ".py" && ext !== ".go")
+            return signatures;
+        const startRegex = ext === ".py"
+            ? /^(?:async\s+)?def\s+([a-zA-Z_]\w*)\s*\(/gm
+            : /^func\s+(?:\([^)]*\)\s+)?([A-Z][a-zA-Z0-9_]*)\s*\(/gm;
+        let match;
+        while ((match = startRegex.exec(content)) !== null) {
+            const symbolName = match[1];
+            const startIndex = match.index;
+            let i = startIndex + match[0].length - 1;
+            let parenDepth = 0;
+            let inString = null;
+            let foundEnd = false;
+            for (; i < content.length; i++) {
+                const ch = content[i];
+                if (inString) {
+                    if (ch === '\\')
+                        i++;
+                    else if (ch === inString)
+                        inString = null;
+                    continue;
+                }
+                if (ch === '"' || ch === "'" || ch === '`') {
+                    inString = ch;
+                    continue;
+                }
+                if (ch === '(')
+                    parenDepth++;
+                else if (ch === ')') {
+                    parenDepth--;
+                    if (parenDepth === 0) {
+                        foundEnd = true;
+                        i++;
+                        break;
+                    }
+                }
+            }
+            if (foundEnd) {
+                let sigEnd = i;
+                if (ext === ".py") {
+                    while (sigEnd < content.length && content[sigEnd] !== ':')
+                        sigEnd++;
+                    if (sigEnd < content.length)
+                        sigEnd++;
+                }
+                else if (ext === ".go") {
+                    while (sigEnd < content.length && content[sigEnd] !== '{')
+                        sigEnd++;
+                }
+                const rawSig = content.substring(startIndex, sigEnd).replace(/\s+/g, ' ').trim();
+                signatures.set(symbolName, rawSig);
+            }
+        }
+        return signatures;
+    }
+    /**
+     * TTRD Sintáctico - Detector de Regresión por Toxicidad Estructural.
+     * NO cuenta caracteres. Detecta 3 crímenes específicos:
+     * 1. Inyección tóxica (Any/interface{} donde no existía)
+     * 2. Colapso de retorno (pérdida de -> en Python, return type en Go)
+     * 3. Amnesia de parámetros (pérdida total de anotaciones de tipo)
+     */
+    detectSignatureRegression(oldSig, newSig, ext) {
+        // 1. INYECCIÓN TÓXICA
+        const toxicRegex = ext === ".py" ? /\b(Any|any)\b/ : /\b(any|interface\{\})\b/;
+        if (!toxicRegex.test(oldSig) && toxicRegex.test(newSig)) {
+            return { isRegression: true, reason: `Injected toxic untyped '${ext === ".py" ? "Any" : "interface{}"}'` };
+        }
+        // 2. COLAPSO ESTRUCTURAL (Pérdida del Retorno)
+        if (ext === ".py") {
+            const hadReturn = /->\s*[^:]+/.test(oldSig);
+            const hasReturn = /->\s*[^:]+/.test(newSig);
+            if (hadReturn && !hasReturn) {
+                return { isRegression: true, reason: "Lost return type annotation (->)" };
+            }
+            // 3. AMNESIA DE PARÁMETROS (Pérdida total)
+            const oldParams = oldSig.match(/\((.*)\)/)?.[1] || "";
+            const newParams = newSig.match(/\((.*)\)/)?.[1] || "";
+            const oldAnnotations = (oldParams.match(/:/g) || []).length;
+            const newAnnotations = (newParams.match(/:/g) || []).length;
+            if (oldAnnotations > 0 && newAnnotations === 0) {
+                return { isRegression: true, reason: "Stripped all parameter type annotations" };
+            }
+        }
+        else if (ext === ".go") {
+            const oldReturn = oldSig.substring(oldSig.lastIndexOf(')') + 1).replace('{', '').trim();
+            const newReturn = newSig.substring(newSig.lastIndexOf(')') + 1).replace('{', '').trim();
+            if (oldReturn.length > 0 && newReturn.length === 0) {
+                return { isRegression: true, reason: "Lost return type annotation" };
+            }
+        }
+        return { isRegression: false, reason: "" };
+    }
     // DRY: Config loading delegated to backend (Strangler Fig Phase 2A).
     // Kernel copies references after the call. All 32 usages of this.rootNames
     // and 13 usages of this.compilerOptions continue working unchanged.
@@ -279,7 +398,7 @@ export class NrekiKernel {
                 const posixPath = self.toPosix(path.resolve(self.projectRoot, fileName));
                 if (self.vfsClock.has(posixPath))
                     return self.vfsClock.get(posixPath);
-                return ts.sys.getModifiedTime ? ts.sys.getModifiedTime(fileName) : new Date();
+                return ts.sys.getModifiedTime?.(fileName) ?? new Date();
             },
             directoryExists(dirName) {
                 const posixDir = self.toPosix(path.resolve(self.projectRoot, dirName));
@@ -350,8 +469,31 @@ export class NrekiKernel {
         if (this.mode === "project") {
             this.tsBackend.captureBaseline(undefined, this.mode);
         }
-        // D2: Clean orphaned transaction backups from previous crashes
+        // D2: WAL-aware crash recovery.
+        // If a previous session crashed mid-commit, the WAL tells us
+        // exactly which files to restore from their .bak backups.
         const txDir = path.join(this.projectRoot, ".nreki", "transactions");
+        const walPath = path.join(txDir, "wal.json");
+        if (fs.existsSync(walPath)) {
+            try {
+                const wal = JSON.parse(fs.readFileSync(walPath, "utf-8"));
+                if (wal.status === "pending" && Array.isArray(wal.files)) {
+                    logger.warn(`WAL recovery: restoring ${wal.files.length} file(s) from crashed transaction`);
+                    for (const entry of wal.files) {
+                        if (entry.backup && fs.existsSync(entry.backup)) {
+                            fs.renameSync(entry.backup, entry.target);
+                        }
+                        else if (!entry.backup && fs.existsSync(entry.target)) {
+                            // File was newly created in the crashed tx — remove it
+                            fs.unlinkSync(entry.target);
+                        }
+                    }
+                }
+            }
+            catch (walErr) {
+                logger.error(`WAL recovery failed: ${walErr}`);
+            }
+        }
         if (fs.existsSync(txDir)) {
             try {
                 fs.rmSync(txDir, { recursive: true, force: true });
@@ -565,6 +707,146 @@ export class NrekiKernel {
             finalErrors: []
         };
     }
+    /**
+     * NREKI L3.4: LSP Auto-Healing (Go / Python)
+     * DISEÑO ACORAZADO:
+     * - Latencia JSON-RPC es alta (~300ms/ciclo). Límite estricto de 2 iteraciones.
+     * - Whitelist ultra-conservadora: SOLO CodeActions con "import" o "add" en título.
+     * - Rechaza explícitamente "remove" y "delete" (destructivos).
+     * - Micro-rollback dual: VFS de NREKI + VFS del sidecar (cura Split-Brain).
+     * - Macro-rollback completo si quedan errores al final.
+     */
+    async attemptLspAutoHealing(sidecar, initialErrors, parentEditedFiles) {
+        if (initialErrors.length === 0 || sidecar.isDead) {
+            return { healed: false, appliedFixes: [], newlyTouchedFiles: new Set(), finalErrors: initialErrors };
+        }
+        const MAX_ITERATIONS = 2;
+        const fixDescriptions = new Set();
+        const localEditedFiles = new Set(parentEditedFiles);
+        const newlyTouchedFiles = new Set();
+        const healUndoLog = new Map();
+        const failedFixHashes = new Set();
+        let currentErrors = initialErrors;
+        let iteration = 0;
+        while (currentErrors.length > 0 && iteration < MAX_ITERATIONS) {
+            let appliedAnyFix = false;
+            for (const error of currentErrors) {
+                const lspRange = {
+                    start: { line: error.line - 1, character: Math.max(0, error.column - 1) },
+                    end: { line: error.line - 1, character: error.column }
+                };
+                const diagnostic = {
+                    range: lspRange,
+                    message: error.message,
+                    code: error.code.replace(`${sidecar.languageId}-`, ""),
+                };
+                let fixes = [];
+                try {
+                    fixes = await sidecar.requestCodeActions(error.file, diagnostic);
+                }
+                catch {
+                    continue;
+                }
+                if (!fixes || fixes.length === 0)
+                    continue;
+                // EL MURO DE HIELO: Whitelist estricta por title
+                const safeFixes = fixes.filter((f) => {
+                    const title = (f.title || "").toLowerCase();
+                    if (title.includes("remove") || title.includes("delete"))
+                        return false;
+                    return title.includes("import") || title.includes("add ");
+                });
+                if (safeFixes.length === 0)
+                    continue;
+                const bestFix = safeFixes[0];
+                const fixDesc = bestFix.title || `Add import in ${path.basename(error.file)}`;
+                const fixHash = `${error.file}:${error.line}:${fixDesc}`;
+                if (failedFixHashes.has(fixHash))
+                    continue;
+                const changePath = this.toPosix(path.resolve(this.projectRoot, bestFix.filePath || error.file));
+                // Backup VFS (Micro-Rollback log)
+                const state = {
+                    content: this.vfs.has(changePath) ? this.vfs.get(changePath) : undefined,
+                    time: this.vfsClock.get(changePath)
+                };
+                if (!healUndoLog.has(changePath))
+                    healUndoLog.set(changePath, state);
+                // Aplicar Fix traduciendo coordenadas LSP → byte offsets
+                let content = this.vfs.get(changePath) ?? fs.readFileSync(changePath, "utf-8");
+                const startIdx = this.getLspOffset(content, bestFix.range.start.line, bestFix.range.start.character);
+                const endIdx = this.getLspOffset(content, bestFix.range.end.line, bestFix.range.end.character);
+                content = content.slice(0, startIdx) + bestFix.newText + content.slice(endIdx);
+                this.vfs.set(changePath, content);
+                this.vfsClock.set(changePath, new Date(this.logicalTime));
+                localEditedFiles.add(changePath);
+                if (!parentEditedFiles.has(changePath))
+                    newlyTouchedFiles.add(changePath);
+                // Re-evaluar contra el Sidecar (Round-Trip)
+                this.logicalTime += 1000;
+                let newErrors = [];
+                try {
+                    const scEdits = Array.from(localEditedFiles).map(f => ({
+                        filePath: f, content: this.vfs.get(f) ?? null
+                    }));
+                    newErrors = await sidecar.validateEdits(scEdits);
+                }
+                catch {
+                    newErrors = currentErrors;
+                }
+                // TEOREMA DE REDUCCIÓN ESTRICTA
+                const oldFileErrors = currentErrors.filter(e => e.file === error.file).length;
+                const newFileErrors = newErrors.filter(e => e.file === error.file).length;
+                if (newFileErrors >= oldFileErrors) {
+                    // MICRO-ROLLBACK NREKI VFS
+                    if (state.content !== undefined)
+                        this.vfs.set(changePath, state.content);
+                    else
+                        this.vfs.delete(changePath);
+                    if (state.time)
+                        this.vfsClock.set(changePath, state.time);
+                    else
+                        this.vfsClock.delete(changePath);
+                    if (!parentEditedFiles.has(changePath))
+                        localEditedFiles.delete(changePath);
+                    newlyTouchedFiles.delete(changePath);
+                    // MICRO-ROLLBACK SIDECAR VFS (Cura Split-Brain)
+                    sidecar.validateEdits([{ filePath: changePath, content: state.content ?? null }]).catch(() => { });
+                    failedFixHashes.add(fixHash);
+                }
+                else {
+                    // FIX ACEPTADO
+                    fixDescriptions.add(`- LSP Auto-Heal (${sidecar.languageId}): ${fixDesc}`);
+                    appliedAnyFix = true;
+                    currentErrors = currentErrors.filter(e => e.file !== error.file).concat(newErrors.filter(e => e.file === error.file));
+                    break;
+                }
+            }
+            if (!appliedAnyFix)
+                break;
+            iteration++;
+        }
+        // MACRO-ROLLBACK si quedan errores
+        if (currentErrors.length > 0) {
+            const rollbacks = [];
+            for (const [p, state] of healUndoLog.entries()) {
+                if (state.content !== undefined)
+                    this.vfs.set(p, state.content);
+                else
+                    this.vfs.delete(p);
+                rollbacks.push({ filePath: p, content: state.content ?? null });
+            }
+            if (rollbacks.length > 0) {
+                this.logicalTime += 1000;
+                sidecar.validateEdits(rollbacks).catch(() => { });
+            }
+            this._healingStats.failed++;
+            return { healed: false, appliedFixes: [], newlyTouchedFiles: new Set(), finalErrors: initialErrors };
+        }
+        this._healingStats.applied++;
+        for (const file of localEditedFiles)
+            parentEditedFiles.add(file);
+        return { healed: true, appliedFixes: Array.from(fixDescriptions), newlyTouchedFiles, finalErrors: [] };
+    }
     /**
      * SINGLE ENTRY POINT (P21, P22).
      * Atomic batch validation: inject all edits into VFS, evaluate macro-state.
@@ -581,218 +863,352 @@ export class NrekiKernel {
             logger.warn("Rebuilding after timeout-corrupted state.");
         }
         return this.mutex.withLock(async () => {
-            const t0 = performance.now();
-            const rollbackState = new Map();
-            // B6: Save logicalTime for rollback
-            const savedLogicalTime = this.logicalTime;
-            this.logicalTime += 1000;
-            const explicitlyEditedFiles = new Set();
-            // A-02: Snapshot vfsDirectories for rollback
-            const savedDirectories = new Set(this.vfsDirectories);
-            // HOLOGRAM: set currentEditTargets so VFS hooks show them as real .ts
-            if (this.mode === "hologram") {
+            const txId = crypto.randomBytes(4).toString("hex");
+            setTxId(txId);
+            logger.info(`interceptAtomicBatch: ${edits.length} file(s)`);
+            try {
+                const t0 = performance.now();
+                const rollbackState = new Map();
+                // B6: Save logicalTime for rollback
+                const savedLogicalTime = this.logicalTime;
+                this.logicalTime += 1000;
+                const explicitlyEditedFiles = new Set();
+                // A-02: Snapshot vfsDirectories for rollback
+                const savedDirectories = new Set(this.vfsDirectories);
+                // PATCH-1: Track which files THIS transaction adds to mutatedFiles.
+                // On rollback, only these are removed — preserving prior valid mutations.
+                const transactionMutated = new Set();
+                // HOLOGRAM: set currentEditTargets so VFS hooks show them as real .ts
+                if (this.mode === "hologram") {
+                    for (const edit of edits) {
+                        if (edit.proposedContent !== null) {
+                            const posixPath = this.toPosix(path.resolve(this.projectRoot, edit.targetFile));
+                            this.currentEditTargets.add(posixPath);
+                            // Ensure edited file is in rootNames for hologram lazy subgraph
+                            if (this.isTypeScriptFile(posixPath) && !this.rootNames.has(posixPath)) {
+                                this.rootNames.add(posixPath);
+                            }
+                        }
+                    }
+                }
+                // TTRD PRE-SCAN: Identify files that will be edited (before VFS mutation)
                 for (const edit of edits) {
                     if (edit.proposedContent !== null) {
                         const posixPath = this.toPosix(path.resolve(this.projectRoot, edit.targetFile));
-                        this.currentEditTargets.add(posixPath);
-                        // Ensure edited file is in rootNames for hologram lazy subgraph
-                        if (this.isTypeScriptFile(posixPath) && !this.rootNames.has(posixPath)) {
-                            this.rootNames.add(posixPath);
-                        }
+                        explicitlyEditedFiles.add(posixPath);
                     }
                 }
-            }
-            // TTRD PRE-SCAN: Identify files that will be edited (before VFS mutation)
-            for (const edit of edits) {
-                if (edit.proposedContent !== null) {
-                    const posixPath = this.toPosix(path.resolve(this.projectRoot, edit.targetFile));
-                    explicitlyEditedFiles.add(posixPath);
-                }
-            }
-            // TOPOLOGICAL INJECTION: unveil dependents in hologram mode
-            const filesToEvaluate = new Set(explicitlyEditedFiles);
-            const temporarilyUnveiled = new Set();
-            if (this.mode === "hologram") {
-                for (const dep of dependents) {
-                    const posixDep = this.toPosix(path.resolve(this.projectRoot, dep));
-                    filesToEvaluate.add(posixDep);
-                    if (this.prunedTsLookup.has(posixDep)) {
-                        this.prunedTsLookup.delete(posixDep);
-                        this.shadowDtsLookup.delete(posixDep.replace(/\.([mc]?)tsx?$/, ".d.$1ts"));
-                        if (!this.rootNames.has(posixDep)) {
-                            this.rootNames.add(posixDep);
+                // TOPOLOGICAL INJECTION: unveil dependents in hologram mode
+                const filesToEvaluate = new Set(explicitlyEditedFiles);
+                const temporarilyUnveiled = new Set();
+                if (this.mode === "hologram") {
+                    for (const dep of dependents) {
+                        const posixDep = this.toPosix(path.resolve(this.projectRoot, dep));
+                        filesToEvaluate.add(posixDep);
+                        if (this.prunedTsLookup.has(posixDep)) {
+                            this.prunedTsLookup.delete(posixDep);
+                            this.shadowDtsLookup.delete(posixDep.replace(/\.([mc]?)tsx?$/, ".d.$1ts"));
+                            if (!this.rootNames.has(posixDep)) {
+                                this.rootNames.add(posixDep);
+                            }
+                            temporarilyUnveiled.add(posixDep);
                         }
-                        temporarilyUnveiled.add(posixDep);
                     }
                 }
-            }
-            // JIT baseline: recapture baseline scoped to files we will evaluate
-            if (this.mode === "hologram" || this.mode === "file") {
-                this.tsBackend.updateProgram();
-                // DR/LS synced via tsBackend
-                this.tsBackend.captureBaseline(filesToEvaluate, this.mode);
-                if (this.bootErrorCount === -1) {
-                    this.bootErrorCount = this.getBaselineErrorCount();
+                // JIT baseline: recapture baseline scoped to files we will evaluate
+                if (this.mode === "hologram" || this.mode === "file") {
+                    this.tsBackend.updateProgram();
+                    // DR/LS synced via tsBackend
+                    this.tsBackend.captureBaseline(filesToEvaluate, this.mode);
+                    if (this.bootErrorCount === -1) {
+                        this.bootErrorCount = this.getBaselineErrorCount();
+                    }
                 }
-            }
-            // TTRD: Extract pre-mutation type contracts (before VFS injection)
-            const preContracts = await this.tsBackend.extractCanonicalTypes(explicitlyEditedFiles);
-            // A-01: Wrap Phase 1-4 so partial VFS mutations are rolled back on throw
-            // Sidecar edits hoisted for catch-path compensatory rollback (Bomba 1)
-            const sidecarEdits = new Map();
-            try {
-                // PHASE 1: Inject entire batch into VFS
+                // TTRD: Extract pre-mutation type contracts (before VFS injection)
+                const preContracts = await this.tsBackend.extractCanonicalTypes(explicitlyEditedFiles);
+                // TTRD SINTÁCTICO PRE-SCAN: Python/Go
+                const preRawSignatures = new Map();
                 for (const edit of edits) {
-                    const posixPath = this.toPosix(path.resolve(this.projectRoot, edit.targetFile));
-                    const rootPosix = this.toPosix(path.resolve(this.projectRoot));
-                    // A1: Path Jail - block traversal attempts at kernel level
-                    if (!posixPath.startsWith(rootPosix + "/") && posixPath !== rootPosix) {
-                        throw new Error(`[NREKI] Security rejection: Path traversal blocked. ` +
-                            `"${edit.targetFile}" resolves outside project root.`);
-                    }
-                    const currentlyInRoots = this.rootNames.has(posixPath);
-                    // P25: Idempotent undo-log - first touch only
-                    if (!rollbackState.has(posixPath)) {
-                        rollbackState.set(posixPath, {
-                            content: this.vfs.has(posixPath) ? this.vfs.get(posixPath) : undefined,
-                            time: this.vfsClock.get(posixPath),
-                            wasInRoot: currentlyInRoots,
-                        });
-                    }
-                    this.vfs.set(posixPath, edit.proposedContent);
-                    this.vfsClock.set(posixPath, new Date(this.logicalTime));
-                    this.mutatedFiles.add(posixPath);
-                    // P29: Tombstone removes from rootNames
-                    // P30: Only TS files enter rootNames
-                    if (edit.proposedContent === null) {
-                        this.rootNames.delete(posixPath);
+                    if (edit.proposedContent !== null) {
+                        const posixPath = this.toPosix(path.resolve(this.projectRoot, edit.targetFile));
+                        const ext = path.extname(posixPath).toLowerCase();
+                        if (ext === ".py" || ext === ".go") {
+                            const oldContent = this.vfs.get(posixPath) ?? this.tsBackend.host.readFile(posixPath) ?? "";
+                            preRawSignatures.set(posixPath, this.extractRawSignatures(oldContent, ext));
+                        }
                     }
-                    else {
-                        explicitlyEditedFiles.add(posixPath);
-                        if (!currentlyInRoots && this.isTypeScriptFile(posixPath)) {
-                            this.rootNames.add(posixPath);
+                }
+                // A-01: Wrap Phase 1-4 so partial VFS mutations are rolled back on throw
+                // Sidecar edits hoisted for catch-path compensatory rollback (Bomba 1)
+                const sidecarEdits = new Map();
+                try {
+                    // PHASE 1: Inject entire batch into VFS
+                    for (const edit of edits) {
+                        const posixPath = this.toPosix(path.resolve(this.projectRoot, edit.targetFile));
+                        const rootPosix = this.toPosix(path.resolve(this.projectRoot));
+                        // A1: Path Jail - block traversal attempts at kernel level
+                        if (!posixPath.startsWith(rootPosix + "/") && posixPath !== rootPosix) {
+                            throw new Error(`[NREKI] Security rejection: Path traversal blocked. ` +
+                                `"${edit.targetFile}" resolves outside project root.`);
                         }
-                        // E1: Build directory hierarchy for O(1) lookup
-                        let dir = path.posix.dirname(posixPath);
-                        while (dir.length >= rootPosix.length && dir !== rootPosix && dir !== ".") {
-                            this.vfsDirectories.add(dir);
-                            dir = path.posix.dirname(dir);
+                        const currentlyInRoots = this.rootNames.has(posixPath);
+                        // P25: Idempotent undo-log - first touch only
+                        if (!rollbackState.has(posixPath)) {
+                            rollbackState.set(posixPath, {
+                                content: this.vfs.has(posixPath) ? this.vfs.get(posixPath) : undefined,
+                                time: this.vfsClock.get(posixPath),
+                                wasInRoot: currentlyInRoots,
+                            });
+                        }
+                        this.vfs.set(posixPath, edit.proposedContent);
+                        this.vfsClock.set(posixPath, new Date(this.logicalTime));
+                        if (!this.mutatedFiles.has(posixPath))
+                            transactionMutated.add(posixPath);
+                        this.mutatedFiles.add(posixPath);
+                        // P29: Tombstone removes from rootNames
+                        // P30: Only TS files enter rootNames
+                        if (edit.proposedContent === null) {
+                            this.rootNames.delete(posixPath);
+                        }
+                        else {
+                            explicitlyEditedFiles.add(posixPath);
+                            if (!currentlyInRoots && this.isTypeScriptFile(posixPath)) {
+                                this.rootNames.add(posixPath);
+                            }
+                            // E1: Build directory hierarchy for O(1) lookup
+                            let dir = path.posix.dirname(posixPath);
+                            while (dir.length >= rootPosix.length && dir !== rootPosix && dir !== ".") {
+                                this.vfsDirectories.add(dir);
+                                dir = path.posix.dirname(dir);
+                            }
                         }
                     }
-                }
-                // PHASE 2: Rebuild incremental program
-                this.tsBackend.updateProgram();
-                // DR/LS synced via tsBackend
-                // BUG 3 FIXED: Compute AI errors exactly ONCE.
-                // getFatalErrors consumes the stateful getSemanticDiagnosticsOfNextAffectedFile iterator.
-                // Cannot call it again without updateProgram() in between.
-                const originalFatalErrors = await this.tsBackend.getDiagnostics(filesToEvaluate, explicitlyEditedFiles, this.mode);
-                // ─── Phase 2.5: LSP Sidecar Validation (Go, Python) ─────────
-                const sidecarWarnings = [];
-                // Collect non-TS edits grouped by sidecar
-                sidecarEdits.clear();
-                for (const edit of edits) {
-                    const posixPath = this.toPosix(path.resolve(this.projectRoot, edit.targetFile));
-                    const ext = path.extname(posixPath).toLowerCase();
-                    const sidecar = this.lspSidecars.get(ext);
-                    if (!sidecar)
-                        continue;
-                    const list = sidecarEdits.get(sidecar) || [];
-                    list.push({ filePath: posixPath, content: edit.proposedContent });
-                    sidecarEdits.set(sidecar, list);
-                }
-                // Boot + validate each sidecar
-                for (const [sidecar, scEdits] of sidecarEdits) {
-                    if (!sidecar.isHealthy()) {
+                    // PHASE 2: Rebuild incremental program
+                    this.tsBackend.updateProgram();
+                    // DR/LS synced via tsBackend
+                    // BUG 3 FIXED: Compute AI errors exactly ONCE.
+                    // getFatalErrors consumes the stateful getSemanticDiagnosticsOfNextAffectedFile iterator.
+                    // Cannot call it again without updateProgram() in between.
+                    const originalFatalErrors = await this.tsBackend.getDiagnostics(filesToEvaluate, explicitlyEditedFiles, this.mode);
+                    // ─── Phase 2.5: LSP Sidecar Validation (Go, Python) ─────────
+                    const sidecarWarnings = [];
+                    // Collect non-TS edits grouped by sidecar
+                    sidecarEdits.clear();
+                    for (const edit of edits) {
+                        const posixPath = this.toPosix(path.resolve(this.projectRoot, edit.targetFile));
+                        const ext = path.extname(posixPath).toLowerCase();
+                        const sidecar = this.lspSidecars.get(ext);
+                        if (!sidecar)
+                            continue;
+                        const list = sidecarEdits.get(sidecar) || [];
+                        list.push({ filePath: posixPath, content: edit.proposedContent });
+                        sidecarEdits.set(sidecar, list);
+                    }
+                    // Boot + validate each sidecar
+                    for (const [sidecar, scEdits] of sidecarEdits) {
+                        if (!sidecar.isHealthy()) {
+                            try {
+                                await sidecar.boot();
+                            }
+                            catch {
+                                sidecarWarnings.push(`[⚠️ NREKI WARNING: '${sidecar.command[0]}' not found or crashed. ` +
+                                    `Layer 2 Semantic Shield OFFLINE for ${sidecar.languageId} files. ` +
+                                    `Code passed syntax only. Install to enable strict validation.]`);
+                                continue;
+                            }
+                        }
                         try {
-                            await sidecar.boot();
+                            const sidecarErrors = await sidecar.validateEdits(scEdits);
+                            // ACID: Merge sidecar errors. If ANY backend rejects, NOTHING touches disk.
+                            originalFatalErrors.push(...sidecarErrors);
                         }
                         catch {
-                            sidecarWarnings.push(`[⚠️ NREKI WARNING: '${sidecar.command[0]}' not found or crashed. ` +
-                                `Layer 2 Semantic Shield OFFLINE for ${sidecar.languageId} files. ` +
-                                `Code passed syntax only. Install to enable strict validation.]`);
-                            continue;
+                            sidecarWarnings.push(`[⚠️ NREKI WARNING: ${sidecar.languageId} validation timed out. ` +
+                                `Code passed without semantic check.]`);
                         }
                     }
-                    try {
-                        const sidecarErrors = await sidecar.validateEdits(scEdits);
-                        // ACID: Merge sidecar errors. If ANY backend rejects, NOTHING touches disk.
-                        originalFatalErrors.push(...sidecarErrors);
-                    }
-                    catch {
-                        sidecarWarnings.push(`[⚠️ NREKI WARNING: ${sidecar.languageId} validation timed out. ` +
-                            `Code passed without semantic check.]`);
-                    }
-                }
-                // ─── End Phase 2.5 ───────────────────────────────────────────
-                // PHASE 4: Verdict
-                if (originalFatalErrors.length > 0) {
-                    // ─── NREKI L3.3: Iterative Auto-Healing ─────────────────
-                    // Only attempt auto-healing on TypeScript errors.
-                    // LSP sidecars have supportsAutoHealing: false in v1.
-                    const tsOnlyErrors = originalFatalErrors.filter(e => this.isTypeScriptFile(e.file));
-                    const lspOnlyErrors = originalFatalErrors.filter(e => !this.isTypeScriptFile(e.file));
-                    const tHealStart = performance.now();
-                    const healing = tsOnlyErrors.length > 0
-                        ? await this.attemptAutoHealing(tsOnlyErrors, explicitlyEditedFiles, filesToEvaluate)
-                        : { healed: false, appliedFixes: [], newlyTouchedFiles: new Set(), finalErrors: [] };
-                    // If TS healed but LSP still has errors, overall still fails
-                    if (healing.healed && lspOnlyErrors.length > 0) {
-                        healing.healed = false;
-                        healing.finalErrors = lspOnlyErrors;
+                    // ─── End Phase 2.5 ───────────────────────────────────────────
+                    // ─── TTRD SINTÁCTICO: Evaluación Post-Mutación ───
+                    for (const [posixPath, oldSigsMap] of preRawSignatures.entries()) {
+                        const newContent = this.vfs.get(posixPath) ?? "";
+                        const ext = path.extname(posixPath).toLowerCase();
+                        const newSigsMap = this.extractRawSignatures(newContent, ext);
+                        for (const [symbol, oldSig] of oldSigsMap.entries()) {
+                            const newSig = newSigsMap.get(symbol);
+                            if (newSig) {
+                                const { isRegression, reason } = this.detectSignatureRegression(oldSig, newSig, ext);
+                                if (isRegression) {
+                                    sidecarWarnings.push(`[⚠️ TTRD WARNING] Type degradation detected in ${path.basename(posixPath)}::${symbol}().\n  Reason: ${reason}\n  Old: \`${oldSig}\`\n  New: \`${newSig}\``);
+                                }
+                            }
+                        }
                     }
-                    if (healing.healed) {
-                        const latency = (performance.now() - t0).toFixed(2);
-                        const healLatency = (performance.now() - tHealStart).toFixed(2);
-                        // Patch notice: tell the agent what NOT to overwrite in its next edit
-                        let extraFilesWarning = "";
-                        if (healing.newlyTouchedFiles.size > 0) {
-                            const files = Array.from(healing.newlyTouchedFiles)
-                                .map(f => path.relative(this.projectRoot, f)).join(", ");
-                            extraFilesWarning = `\nWARNING: NREKI also auto-patched collateral files: ${files}. Do NOT revert them.`;
+                    // PHASE 4: Verdict
+                    if (originalFatalErrors.length > 0) {
+                        // ─── NREKI L3.3: Iterative Auto-Healing (Dual Cascade) ─────────────────
+                        const tsOnlyErrors = originalFatalErrors.filter(e => this.isTypeScriptFile(e.file));
+                        const lspOnlyErrors = originalFatalErrors.filter(e => !this.isTypeScriptFile(e.file));
+                        const tHealStart = performance.now();
+                        let isFullyHealed = true;
+                        const allAppliedFixes = [];
+                        const allNewlyTouchedFiles = new Set();
+                        // 1. Sanación TypeScript (CodeFix API, ~20ms/ciclo)
+                        let remainingTsErrors = tsOnlyErrors;
+                        if (tsOnlyErrors.length > 0) {
+                            const tsHealing = await this.attemptAutoHealing(tsOnlyErrors, explicitlyEditedFiles, filesToEvaluate);
+                            if (!tsHealing.healed)
+                                isFullyHealed = false;
+                            remainingTsErrors = tsHealing.finalErrors;
+                            allAppliedFixes.push(...tsHealing.appliedFixes);
+                            for (const f of tsHealing.newlyTouchedFiles)
+                                allNewlyTouchedFiles.add(f);
                         }
-                        const patchNotice = `\n\nIMPORTANT: NREKI applied these patches automatically.\n` +
-                            `Your code on disk already contains these fixes. ` +
-                            `Do not revert or overwrite them in your next edit.` +
-                            extraFilesWarning;
-                        // TTRD post-contracts (healed path)
-                        const finalEditedFiles = new Set(explicitlyEditedFiles);
-                        for (const f of healing.newlyTouchedFiles)
-                            finalEditedFiles.add(f);
-                        const postContracts = await this.tsBackend.extractCanonicalTypes(finalEditedFiles);
-                        const regressions = this.tsBackend.computeTypeRegressions(preContracts, postContracts);
-                        // Restore hologram veil after healed success
-                        if (this.mode === "hologram" && temporarilyUnveiled.size > 0) {
-                            for (const file of temporarilyUnveiled) {
-                                this.prunedTsLookup.add(file);
-                                this.shadowDtsLookup.add(file.replace(/\.([mc]?)tsx?$/, ".d.$1ts"));
-                                this.rootNames.delete(file);
-                                this.vfsClock.set(file, new Date(this.logicalTime + 1));
-                                // JIT: force re-classify on next access (content may have changed)
-                                this.jitClassifiedCache.delete(file);
+                        // 2. Sanación LSP (Go/Python, ~300ms/ciclo) — SOLO SI TS SANÓ
+                        let remainingLspErrors = lspOnlyErrors;
+                        if (isFullyHealed && lspOnlyErrors.length > 0) {
+                            const errorsBySidecar = new Map();
+                            for (const err of lspOnlyErrors) {
+                                const ext = path.extname(err.file).toLowerCase();
+                                const sidecar = this.lspSidecars.get(ext);
+                                if (sidecar) {
+                                    const arr = errorsBySidecar.get(sidecar) || [];
+                                    arr.push(err);
+                                    errorsBySidecar.set(sidecar, arr);
+                                }
+                            }
+                            remainingLspErrors = [];
+                            for (const [sidecar, errors] of errorsBySidecar.entries()) {
+                                const lspHealing = await this.attemptLspAutoHealing(sidecar, errors, explicitlyEditedFiles);
+                                if (!lspHealing.healed) {
+                                    isFullyHealed = false;
+                                    remainingLspErrors.push(...lspHealing.finalErrors);
+                                }
+                                else {
+                                    allAppliedFixes.push(...lspHealing.appliedFixes);
+                                    for (const f of lspHealing.newlyTouchedFiles)
+                                        allNewlyTouchedFiles.add(f);
+                                }
                             }
                         }
-                        this.currentEditTargets.clear();
+                        // Construir resultado unificado
+                        const healing = {
+                            healed: isFullyHealed && (remainingTsErrors.length + remainingLspErrors.length) === 0,
+                            appliedFixes: allAppliedFixes,
+                            newlyTouchedFiles: allNewlyTouchedFiles,
+                            finalErrors: [...remainingTsErrors, ...remainingLspErrors],
+                        };
+                        if (healing.healed) {
+                            const latency = (performance.now() - t0).toFixed(2);
+                            const healLatency = (performance.now() - tHealStart).toFixed(2);
+                            // Patch notice: tell the agent what NOT to overwrite in its next edit
+                            let extraFilesWarning = "";
+                            if (healing.newlyTouchedFiles.size > 0) {
+                                const files = Array.from(healing.newlyTouchedFiles)
+                                    .map(f => path.relative(this.projectRoot, f)).join(", ");
+                                extraFilesWarning = `\nWARNING: NREKI also auto-patched collateral files: ${files}. Do NOT revert them.`;
+                            }
+                            const patchNotice = `\n\nIMPORTANT: NREKI applied these patches automatically.\n` +
+                                `Your code on disk already contains these fixes. ` +
+                                `Do not revert or overwrite them in your next edit.` +
+                                extraFilesWarning;
+                            // Group fixes by type for readable output
+                            const tsFixes = healing.appliedFixes.filter(f => !f.includes("LSP Auto-Heal"));
+                            const lspFixes = healing.appliedFixes.filter(f => f.includes("LSP Auto-Heal"));
+                            let fixSummary = "";
+                            if (tsFixes.length > 0) {
+                                fixSummary += `\n  TypeScript (CodeFix API):\n${tsFixes.join("\n")}`;
+                            }
+                            if (lspFixes.length > 0) {
+                                fixSummary += `\n  Go/Python (LSP codeAction):\n${lspFixes.join("\n")}`;
+                            }
+                            // TTRD post-contracts (healed path)
+                            const finalEditedFiles = new Set(explicitlyEditedFiles);
+                            for (const f of healing.newlyTouchedFiles)
+                                finalEditedFiles.add(f);
+                            const postContracts = await this.tsBackend.extractCanonicalTypes(finalEditedFiles);
+                            const regressions = this.tsBackend.computeTypeRegressions(preContracts, postContracts);
+                            this.restoreHologramVeil(temporarilyUnveiled);
+                            return {
+                                safe: true,
+                                exitCode: 0,
+                                latencyMs: latency,
+                                healedFiles: Array.from(healing.newlyTouchedFiles),
+                                errorText: `[NREKI AUTO-HEAL: ${healLatency}ms] ` +
+                                    `Your code had structural errors. NREKI applied deterministic fixes in RAM:\n` +
+                                    fixSummary +
+                                    patchNotice,
+                                regressions: regressions.length > 0 ? regressions : undefined,
+                                postContracts: postContracts.size > 0
+                                    ? new Map([...postContracts].map(([file, syms]) => [file, new Map([...syms].map(([sym, contract]) => [sym, contract.typeStr]))]))
+                                    : undefined,
+                                warnings: sidecarWarnings.length > 0 ? sidecarWarnings : undefined,
+                            };
+                        }
+                        // ─── END Auto-Healing ────────────────────────────────────
+                        // Healing failed. Use the ORIGINAL error matrix (do not recalculate).
+                        const structured = originalFatalErrors; // Already NrekiStructuredError[]
+                        // ACID rollback of the original edit
+                        for (const [posixPath, state] of rollbackState.entries()) {
+                            if (state.content !== undefined)
+                                this.vfs.set(posixPath, state.content);
+                            else
+                                this.vfs.delete(posixPath);
+                            if (state.time)
+                                this.vfsClock.set(posixPath, state.time);
+                            else
+                                this.vfsClock.delete(posixPath);
+                            if (state.wasInRoot)
+                                this.rootNames.add(posixPath);
+                            else
+                                this.rootNames.delete(posixPath);
+                        }
+                        // BOMBA 1 FIX: Compensatory Rollback — heal sidecar VFS
+                        // Without this, the LSP's internal VFS retains the rejected
+                        // edit and future validations run against a phantom state.
+                        this.rollbackSidecars(sidecarEdits, rollbackState);
+                        // PATCH-1: Remove this transaction's files from mutatedFiles
+                        // to prevent ghost deletion in the next commitToDisk().
+                        for (const file of transactionMutated)
+                            this.mutatedFiles.delete(file);
+                        // B6: Restore logicalTime on rollback
+                        this.logicalTime = savedLogicalTime;
+                        // A-02: Restore vfsDirectories
+                        this.vfsDirectories = savedDirectories;
+                        // P17 + P2 WARM-PATH: Advance clock instead of destroying program.
+                        this.logicalTime += 1000;
+                        for (const [posixPath] of rollbackState.entries()) {
+                            this.vfsClock.set(posixPath, new Date(this.logicalTime));
+                        }
+                        this.tsBackend.updateProgram();
+                        // DR/LS synced via tsBackend
+                        const latency = (performance.now() - t0).toFixed(2);
+                        latencyTracker.record("intercept", parseFloat(latency));
+                        this.restoreHologramVeil(temporarilyUnveiled);
                         return {
-                            safe: true,
-                            exitCode: 0,
-                            latencyMs: latency,
-                            healedFiles: Array.from(healing.newlyTouchedFiles),
-                            errorText: `[NREKI AUTO-HEAL: ${healLatency}ms] ` +
-                                `Your code had structural errors. NREKI applied deterministic fixes in RAM:\n\n` +
-                                healing.appliedFixes.join("\n") +
-                                patchNotice,
-                            regressions: regressions.length > 0 ? regressions : undefined,
-                            postContracts: postContracts.size > 0
-                                ? new Map([...postContracts].map(([file, syms]) => [file, new Map([...syms].map(([sym, contract]) => [sym, contract.typeStr]))]))
-                                : undefined,
-                            warnings: sidecarWarnings.length > 0 ? sidecarWarnings : undefined,
+                            safe: false, exitCode: 2, latencyMs: latency, structured,
+                            errorText: `[Edit rejected - ${latency}ms] Atomic transaction aborted. ` +
+                                `${originalFatalErrors.length} violation(s) detected in RAM.\n` +
+                                structured.map((e) => `  → ${e.file} (${e.line},${e.column}): ${e.code} - ${e.message}`).join("\n") +
+                                `\nACTION: Disk untouched. Fix the code and retry.`,
                         };
                     }
-                    // ─── END Auto-Healing ────────────────────────────────────
-                    // Healing failed. Use the ORIGINAL error matrix (do not recalculate).
-                    const structured = originalFatalErrors; // Already NrekiStructuredError[]
-                    // ACID rollback of the original edit
+                    // TTRD post-contracts (clean path)
+                    const postContracts = await this.tsBackend.extractCanonicalTypes(explicitlyEditedFiles);
+                    const regressions = this.tsBackend.computeTypeRegressions(preContracts, postContracts);
+                    this.restoreHologramVeil(temporarilyUnveiled);
+                    return {
+                        safe: true,
+                        exitCode: 0,
+                        latencyMs: (() => { const l = (performance.now() - t0).toFixed(2); latencyTracker.record("intercept", parseFloat(l)); return l; })(),
+                        regressions: regressions.length > 0 ? regressions : undefined,
+                        postContracts: postContracts.size > 0
+                            ? new Map([...postContracts].map(([file, syms]) => [file, new Map([...syms].map(([sym, contract]) => [sym, contract.typeStr]))]))
+                            : undefined,
+                        warnings: sidecarWarnings.length > 0 ? sidecarWarnings : undefined,
+                    };
+                }
+                catch (phaseError) {
+                    // A-01: Rollback partial VFS mutations from Phase 1 on any throw
                     for (const [posixPath, state] of rollbackState.entries()) {
                         if (state.content !== undefined)
                             this.vfs.set(posixPath, state.content);
@@ -807,107 +1223,25 @@ export class NrekiKernel {
                         else
                             this.rootNames.delete(posixPath);
                     }
-                    // BOMBA 1 FIX: Compensatory Rollback — heal sidecar VFS
-                    // Without this, the LSP's internal VFS retains the rejected
-                    // edit and future validations run against a phantom state.
+                    // BOMBA 1 FIX: Compensatory Rollback on crash path
                     this.rollbackSidecars(sidecarEdits, rollbackState);
-                    // B6: Restore logicalTime on rollback
-                    this.logicalTime = savedLogicalTime;
+                    // PATCH-1: Remove this transaction's files from mutatedFiles (crash path)
+                    for (const file of transactionMutated)
+                        this.mutatedFiles.delete(file);
                     // A-02: Restore vfsDirectories
                     this.vfsDirectories = savedDirectories;
-                    // P17 + P2 WARM-PATH: Advance clock instead of destroying program.
-                    this.logicalTime += 1000;
-                    for (const [posixPath] of rollbackState.entries()) {
-                        this.vfsClock.set(posixPath, new Date(this.logicalTime));
-                    }
-                    this.tsBackend.updateProgram();
-                    // DR/LS synced via tsBackend
-                    const latency = (performance.now() - t0).toFixed(2);
-                    // Restore hologram veil after rejection
-                    if (this.mode === "hologram" && temporarilyUnveiled.size > 0) {
-                        for (const file of temporarilyUnveiled) {
-                            this.prunedTsLookup.add(file);
-                            this.shadowDtsLookup.add(file.replace(/\.([mc]?)tsx?$/, ".d.$1ts"));
-                            this.rootNames.delete(file);
-                            this.vfsClock.set(file, new Date(this.logicalTime + 1));
-                            // JIT: force re-classify on next access (content may have changed)
-                            this.jitClassifiedCache.delete(file);
-                        }
-                    }
-                    this.currentEditTargets.clear();
-                    return {
-                        safe: false, exitCode: 2, latencyMs: latency, structured,
-                        errorText: `[Edit rejected - ${latency}ms] Atomic transaction aborted. ` +
-                            `${originalFatalErrors.length} violation(s) detected in RAM.\n` +
-                            structured.map((e) => `  → ${e.file} (${e.line},${e.column}): ${e.code} - ${e.message}`).join("\n") +
-                            `\nACTION: Disk untouched. Fix the code and retry.`,
-                    };
-                }
-                // TTRD post-contracts (clean path)
-                const postContracts = await this.tsBackend.extractCanonicalTypes(explicitlyEditedFiles);
-                const regressions = this.tsBackend.computeTypeRegressions(preContracts, postContracts);
-                // Restore hologram veil after successful intercept
-                if (this.mode === "hologram" && temporarilyUnveiled.size > 0) {
-                    for (const file of temporarilyUnveiled) {
-                        this.prunedTsLookup.add(file);
-                        this.shadowDtsLookup.add(file.replace(/\.([mc]?)tsx?$/, ".d.$1ts"));
-                        this.rootNames.delete(file);
-                        this.vfsClock.set(file, new Date(this.logicalTime + 1));
-                        // JIT: force re-classify on next access (content may have changed)
-                        this.jitClassifiedCache.delete(file);
-                    }
+                    this.logicalTime = savedLogicalTime;
+                    this.restoreHologramVeil(temporarilyUnveiled);
+                    // FIX: Poison the compiler cache to force cold rebuild.
+                    // Without this, the TypeScript BuilderProgram retains state
+                    // from the failed transaction, causing phantom errors on
+                    // the next interceptAtomicBatch call.
+                    this.tsBackend.purgeCache(true);
+                    throw phaseError;
                 }
-                this.currentEditTargets.clear();
-                return {
-                    safe: true,
-                    exitCode: 0,
-                    latencyMs: (performance.now() - t0).toFixed(2),
-                    regressions: regressions.length > 0 ? regressions : undefined,
-                    postContracts: postContracts.size > 0
-                        ? new Map([...postContracts].map(([file, syms]) => [file, new Map([...syms].map(([sym, contract]) => [sym, contract.typeStr]))]))
-                        : undefined,
-                    warnings: sidecarWarnings.length > 0 ? sidecarWarnings : undefined,
-                };
             }
-            catch (phaseError) {
-                // A-01: Rollback partial VFS mutations from Phase 1 on any throw
-                for (const [posixPath, state] of rollbackState.entries()) {
-                    if (state.content !== undefined)
-                        this.vfs.set(posixPath, state.content);
-                    else
-                        this.vfs.delete(posixPath);
-                    if (state.time)
-                        this.vfsClock.set(posixPath, state.time);
-                    else
-                        this.vfsClock.delete(posixPath);
-                    if (state.wasInRoot)
-                        this.rootNames.add(posixPath);
-                    else
-                        this.rootNames.delete(posixPath);
-                }
-                // BOMBA 1 FIX: Compensatory Rollback on crash path
-                this.rollbackSidecars(sidecarEdits, rollbackState);
-                // A-02: Restore vfsDirectories
-                this.vfsDirectories = savedDirectories;
-                this.logicalTime = savedLogicalTime;
-                // Restore hologram veil on failure
-                if (this.mode === "hologram" && temporarilyUnveiled.size > 0) {
-                    for (const file of temporarilyUnveiled) {
-                        this.prunedTsLookup.add(file);
-                        this.shadowDtsLookup.add(file.replace(/\.([mc]?)tsx?$/, ".d.$1ts"));
-                        this.rootNames.delete(file);
-                        this.vfsClock.set(file, new Date(this.logicalTime + 1));
-                        // JIT: force re-classify on next access (content may have changed)
-                        this.jitClassifiedCache.delete(file);
-                    }
-                }
-                this.currentEditTargets.clear();
-                // FIX: Poison the compiler cache to force cold rebuild.
-                // Without this, the TypeScript BuilderProgram retains state
-                // from the failed transaction, causing phantom errors on
-                // the next interceptAtomicBatch call.
-                this.tsBackend.purgeCache(true);
-                throw phaseError;
+            finally {
+                clearTxId();
             }
         });
     }
@@ -922,9 +1256,12 @@ export class NrekiKernel {
         return this.mutex.withLock(async () => {
             const physicalUndoLog = [];
             const createdTmps = [];
+            // Scope writes to files mutated in the current transaction only.
+            // Prevents stale VFS entries from prior intercepts leaking into this commit.
+            const filesToCommit = new Set(this.mutatedFiles);
             try {
                 // PHASE 1: Physical backup
-                for (const posixPath of this.vfs.keys()) {
+                for (const posixPath of filesToCommit) {
                     const osPath = path.normalize(posixPath);
                     if (fs.existsSync(osPath)) {
                         const txDir = path.join(this.projectRoot, ".nreki", "transactions");
@@ -938,8 +1275,24 @@ export class NrekiKernel {
                         physicalUndoLog.push({ target: osPath, backup: null });
                     }
                 }
+                // WAL: Write intent log before destructive Phase 2.
+                // If the process crashes between Phase 1 (backup) and Phase 2 (write),
+                // boot() will find this WAL and automatically restore from backups.
+                const txDir = path.join(this.projectRoot, ".nreki", "transactions");
+                const walPath = path.join(txDir, "wal.json");
+                try {
+                    if (!fs.existsSync(txDir))
+                        fs.mkdirSync(txDir, { recursive: true });
+                    fs.writeFileSync(walPath, JSON.stringify({
+                        status: "pending",
+                        ts: new Date().toISOString(),
+                        files: physicalUndoLog.map(l => ({ target: l.target, backup: l.backup })),
+                    }), "utf-8");
+                }
+                catch { /* WAL write failure is non-fatal — proceed without crash safety */ }
                 // PHASE 2: Destructive writes
-                for (const [posixPath, content] of this.vfs.entries()) {
+                for (const posixPath of filesToCommit) {
+                    const content = this.vfs.get(posixPath) ?? null;
                     const osPath = path.normalize(posixPath);
                     if (content === null) {
                         if (fs.existsSync(osPath))
@@ -1001,8 +1354,15 @@ export class NrekiKernel {
                     if (log.backup && fs.existsSync(log.backup))
                         fs.unlinkSync(log.backup);
                 }
+                // WAL: Transaction complete — delete intent log
+                try {
+                    if (fs.existsSync(walPath))
+                        fs.unlinkSync(walPath);
+                }
+                catch { /* best effort */ }
                 // Release stale AST versions from DocumentRegistry
                 this.tsBackend.releaseMutatedDocuments(this.mutatedFiles);
+                this.mutatedFiles.clear();
                 logger.info("Atomic commit materialized. Disk synchronized.");
             }
             catch (error) {
@@ -1095,6 +1455,23 @@ export class NrekiKernel {
         });
     }
     // ─── Utilities ─────────────────────────────────────────────────
+    /**
+     * Restore the hologram veil for temporarily unveiled files.
+     * Re-adds files to the pruned/shadow lookups, removes them from rootNames,
+     * and invalidates JIT classification cache. Clears currentEditTargets.
+     */
+    restoreHologramVeil(temporarilyUnveiled) {
+        if (this.mode === "hologram" && temporarilyUnveiled.size > 0) {
+            for (const file of temporarilyUnveiled) {
+                this.prunedTsLookup.add(file);
+                this.shadowDtsLookup.add(file.replace(/\.([mc]?)tsx?$/, ".d.$1ts"));
+                this.rootNames.delete(file);
+                this.vfsClock.set(file, new Date(this.logicalTime + 1));
+                this.jitClassifiedCache.delete(file);
+            }
+        }
+        this.currentEditTargets.clear();
+    }
     /**
      * Show which files depend on a symbol before the agent edits it.
      * Uses LanguageService.findReferences(). Cost: ~20ms per call.
@@ -1366,9 +1743,11 @@ export class NrekiKernel {
                 rollbacks.push({ filePath: edit.filePath, content: originalContent });
             }
             if (rollbacks.length > 0) {
-                // Fire-and-forget: don't block the error response
+                // Fire-and-forget: don't block the error response.
+                // If rollback fails, mark sidecar dead to force respawn on next use.
+                // This prevents brain-split where sidecar VFS disagrees with kernel VFS.
                 sidecar.validateEdits(rollbacks).catch(() => {
-                    // Best effort — sidecar may be dead
+                    sidecar.isDead = true;
                 });
             }
         }