@ruso-0/nreki 7.1.2 → 7.3.0

package/dist/handlers/code.js

@@ -43,6 +43,157 @@ async function ensureHologramReady(kernel, nrekiMode) {
         kernel.setShadows(scanResult.prunable, scanResult.unprunable, scanResult.ambientFiles);
     }
 }
+/** Shared kernel boot logic for edit handlers. */
+async function ensureKernelBooted(deps) {
+    if (!deps.kernel || deps.nrekiMode === "syntax")
+        return false;
+    if (!deps.kernel.isBooted()) {
+        logger.info(`Booting kernel (${deps.nrekiMode} mode). First edit will be slower.`);
+        try {
+            await ensureHologramReady(deps.kernel, deps.nrekiMode ?? "");
+            deps.kernel.boot(process.cwd(), deps.nrekiMode);
+        }
+        catch (err) {
+            logger.error(`Kernel boot failed: ${err.message}. Falling back to Layer 1.`);
+        }
+    }
+    return deps.kernel.isBooted();
+}
+// ─── H-07: Shared kernel verification + TTRD + Chronos logic ────────
+//
+// Extracted from handleEdit and handleBatchEdit to eliminate ~150 lines
+// of duplicated post-intercept logic.
+/**
+ * Shared kernel verification pipeline (Layer 2).
+ *
+ * Given a kernel intercept result, performs:
+ *   1. node_modules error filtering
+ *   2. Chronos error recording
+ *   3. Backup + commit/rollback
+ *   4. TTRD regression tracking + debt payment
+ *   5. Chronos friction sync
+ *
+ * @param kernelResult - result from interceptAtomicBatch
+ * @param committedFiles - paths that were committed (for backup + Chronos)
+ * @param deps - router dependencies (kernel, chronos)
+ * @param rejectionHeader - header text for the rejection response
+ */
+async function processKernelResult(kernelResult, committedFiles, deps, rejectionHeader) {
+    const kernel = deps.kernel;
+    let ttrdFeedback = "";
+    if (!kernelResult.safe) {
+        const agentErrors = kernelResult.structured?.filter(e => !e.file.match(/[/\\]node_modules[/\\]/)) || [];
+        if (agentErrors.length === 0) {
+            // All errors are in node_modules — safe to commit
+            logger.warn(`${kernelResult.structured?.length} error(s) in node_modules ignored.`);
+            for (const fp of committedFiles) {
+                try {
+                    saveBackup(process.cwd(), fp);
+                }
+                catch { }
+            }
+            await kernel.commitToDisk();
+            return { committed: true, ttrdFeedback };
+        }
+        // Real errors in agent code — record + rollback
+        if (deps.chronos) {
+            const errorByFile = new Map();
+            for (const e of agentErrors) {
+                if (!errorByFile.has(e.file))
+                    errorByFile.set(e.file, e.message);
+            }
+            for (const [fragileFile, firstMsg] of errorByFile.entries()) {
+                deps.chronos.recordSemanticError(fragileFile, firstMsg);
+            }
+        }
+        await kernel.rollbackAll();
+        const structuredInfo = "\n\nSemantic errors:\n" +
+            agentErrors.map(e => `  \u2192 ${path.relative(process.cwd(), e.file)} (${e.line},${e.column}): ${e.code} - ${e.message}`).join("\n");
+        return {
+            committed: false,
+            ttrdFeedback,
+            response: {
+                content: [{
+                        type: "text",
+                        text: `${rejectionHeader}` +
+                            `Layer 1 (syntax) passed, but Layer 2 (cross-file semantics) detected errors.\n` +
+                            `\ud83d\udee1\ufe0f **DISK UNTOUCHED: Caught in RAM. No files modified.**${structuredInfo}\n\n` +
+                            `Fix the type errors and retry. If you changed a function signature, ` +
+                            `use \`nreki_code action:"batch_edit"\` to update all callers in one atomic transaction.\n\n` +
+                            `[NREKI: validated in ${kernelResult.latencyMs}ms]`,
+                    }],
+                isError: true,
+            },
+        };
+    }
+    // ─── Safe: backup → commit → TTRD ───
+    for (const fp of committedFiles) {
+        try {
+            saveBackup(process.cwd(), fp);
+        }
+        catch { }
+    }
+    if (kernelResult.healedFiles) {
+        for (const hf of kernelResult.healedFiles) {
+            try {
+                saveBackup(process.cwd(), path.resolve(process.cwd(), hf));
+            }
+            catch { }
+            if (deps.chronos)
+                deps.chronos.recordHeal(hf);
+        }
+    }
+    await kernel.commitToDisk();
+    if (deps.chronos && kernelResult.postContracts) {
+        // Regression tracking
+        if (kernelResult.regressions && kernelResult.regressions.length > 0) {
+            const byFile = new Map();
+            for (const r of kernelResult.regressions) {
+                const arr = byFile.get(r.filePath) || [];
+                arr.push(r);
+                byFile.set(r.filePath, arr);
+            }
+            const penaltyList = [];
+            for (const [fPath, regs] of byFile.entries()) {
+                deps.chronos.recordRegressions(path.resolve(process.cwd(), fPath), regs);
+                for (const r of regs) {
+                    penaltyList.push(`  - \`${r.symbol}\` in \`${path.basename(fPath)}\`: \`${r.oldType}\` -> \`${r.newType}\``);
+                }
+            }
+            ttrdFeedback += `\n\n**TYPE REGRESSION DETECTED**\n` +
+                `The edit compiled successfully, but weakened type safety:\n` +
+                `${penaltyList.join("\n")}\n` +
+                `This technical debt has been logged. Restore strict typing instead of using any/unknown.`;
+        }
+        // Debt payment tracking
+        const allPaid = [];
+        for (const fp of committedFiles) {
+            const posixPath = kernel.resolvePosixPath(fp);
+            const fileContracts = kernelResult.postContracts.get(posixPath);
+            const paid = deps.chronos.assessDebtPayments(fp, fileContracts);
+            if (paid.length > 0) {
+                allPaid.push(`\`${path.basename(fp)}\`: ${paid.join(", ")}`);
+            }
+            const hasRegressionHere = kernelResult.regressions?.some(r => r.filePath === posixPath);
+            if (!hasRegressionHere) {
+                deps.chronos.recordSuccess(fp);
+            }
+        }
+        if (allPaid.length > 0) {
+            ttrdFeedback += `\n\n**TYPE DEBT PAID**\n` +
+                `Strict typing restored for: ${allPaid.map(s => s).join(", ")}.\n` +
+                `Friction score reduced.`;
+        }
+        deps.chronos.syncTechDebt(kernel.getInitialErrorCount(), kernel.getCurrentErrorCount());
+    }
+    else if (deps.chronos) {
+        for (const fp of committedFiles) {
+            deps.chronos.recordSuccess(fp);
+        }
+        deps.chronos.syncTechDebt(kernel.getInitialErrorCount(), kernel.getCurrentErrorCount());
+    }
+    return { committed: true, ttrdFeedback };
+}
 // ─── Read ───────────────────────────────────────────────────────────
 export async function handleRead(params, deps) {
     const { engine } = deps;
@@ -307,20 +458,7 @@ export async function handleEdit(params, deps) {
         const mode = (typeof params.mode === "string" && ["replace", "insert_before", "insert_after"].includes(params.mode))
             ? params.mode
             : "replace";
-        let useKernel = false;
-        if (deps.kernel && deps.nrekiMode !== "syntax") {
-            if (!deps.kernel.isBooted()) {
-                logger.info(`Booting kernel (${deps.nrekiMode} mode). First edit will be slower.`);
-                try {
-                    await ensureHologramReady(deps.kernel, deps.nrekiMode ?? "");
-                    deps.kernel.boot(process.cwd(), deps.nrekiMode);
-                }
-                catch (err) {
-                    logger.error(`Kernel boot failed: ${err.message}. Falling back to Layer 1.`);
-                }
-            }
-            useKernel = deps.kernel.isBooted();
-        }
+        const useKernel = await ensureKernelBooted(deps);
         const result = await semanticEdit(resolvedPath, symbol, new_code, parser, sandbox, mode, useKernel);
         if (!result.success || (useKernel && !result.newContent)) {
             return {
@@ -375,115 +513,34 @@ export async function handleEdit(params, deps) {
                 kernelResult = await deps.kernel.interceptAtomicBatch([
                     { targetFile: resolvedPath, proposedContent: result.newContent },
                 ], dependentsToInject);
-                if (!kernelResult.safe) {
-                    const agentErrors = kernelResult.structured?.filter(e => !e.file.match(/[/\\]node_modules[/\\]/)) || [];
-                    if (agentErrors.length === 0) {
-                        logger.warn(`${kernelResult.structured?.length} error(s) in node_modules ignored.`);
-                        try {
-                            saveBackup(process.cwd(), resolvedPath);
-                        }
-                        catch { }
-                        await deps.kernel.commitToDisk();
-                    }
-                    else {
-                        if (deps.chronos) {
-                            const errorByFile = new Map();
-                            for (const e of agentErrors) {
-                                if (!errorByFile.has(e.file))
-                                    errorByFile.set(e.file, e.message);
-                            }
-                            for (const [fragileFile, firstMsg] of errorByFile.entries()) {
-                                deps.chronos.recordSemanticError(fragileFile, firstMsg);
-                            }
-                        }
-                        await deps.kernel.rollbackAll();
-                        const structuredInfo = "\n\nSemantic errors:\n" +
-                            agentErrors.map(e => `  → ${path.relative(process.cwd(), e.file)} (${e.line},${e.column}): ${e.code} - ${e.message}`).join("\n");
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: `## Semantic Edit: BLOCKED BY NREKI (Layer 2)\n\n` +
-                                        `**Symbol:** ${symbol}\n` +
-                                        `**File:** ${file}\n\n` +
-                                        `Layer 1 (syntax) passed, but Layer 2 (cross-file semantics) detected errors.\n` +
-                                        `🛡️ **DISK UNTOUCHED: Caught in RAM. File not modified.**${structuredInfo}\n\n` +
-                                        `Fix the type errors and retry. If you changed a function signature, ` +
-                                        `use \`nreki_code action:"batch_edit"\` to update all callers in one atomic transaction.\n\n` +
-                                        `[NREKI: validated in ${kernelResult.latencyMs}ms]`,
-                                }],
-                            isError: true,
-                        };
-                    }
-                }
-                else {
-                    try {
-                        saveBackup(process.cwd(), resolvedPath);
-                    }
-                    catch { }
-                    if (kernelResult.healedFiles) {
-                        for (const hf of kernelResult.healedFiles) {
-                            try {
-                                saveBackup(process.cwd(), path.resolve(process.cwd(), hf));
-                            }
-                            catch { }
-                            if (deps.chronos)
-                                deps.chronos.recordHeal(hf);
-                        }
-                    }
-                    await deps.kernel.commitToDisk();
-                    if (deps.chronos && kernelResult.postContracts) {
-                        if (kernelResult.regressions && kernelResult.regressions.length > 0) {
-                            const byFile = new Map();
-                            for (const r of kernelResult.regressions) {
-                                const arr = byFile.get(r.filePath) || [];
-                                arr.push(r);
-                                byFile.set(r.filePath, arr);
-                            }
-                            const penaltyList = [];
-                            for (const [fPath, regs] of byFile.entries()) {
-                                deps.chronos.recordRegressions(path.resolve(process.cwd(), fPath), regs);
-                                for (const r of regs) {
-                                    penaltyList.push(`  - \`${r.symbol}\` in \`${path.basename(fPath)}\`: \`${r.oldType}\` -> \`${r.newType}\``);
-                                }
-                            }
-                            ttrdFeedback += `\n\n**TYPE REGRESSION DETECTED**\n` +
-                                `The edit compiled successfully, but weakened the type safety of the project:\n` +
-                                `${penaltyList.join("\n")}\n` +
-                                `This technical debt has been logged. Restore strict typing instead of using any/unknown.`;
-                        }
-                        const posixResolved = deps.kernel.resolvePosixPath(resolvedPath);
-                        const fileContracts = kernelResult.postContracts.get(posixResolved);
-                        const paidDebts = deps.chronos.assessDebtPayments(resolvedPath, fileContracts);
-                        if (paidDebts.length > 0) {
-                            ttrdFeedback += `\n\n**TYPE DEBT PAID**\n` +
-                                `Strict typing restored for: ${paidDebts.map(s => `\`${s}\``).join(", ")}.\n` +
-                                `Friction score reduced.`;
-                        }
-                        const hasRegressionHere = kernelResult.regressions?.some(r => r.filePath === posixResolved);
-                        if (!hasRegressionHere) {
-                            deps.chronos.recordSuccess(resolvedPath);
-                        }
-                        deps.chronos.syncTechDebt(deps.kernel.getInitialErrorCount(), deps.kernel.getCurrentErrorCount());
-                    }
-                    else if (deps.chronos) {
-                        deps.chronos.recordSuccess(resolvedPath);
-                        deps.chronos.syncTechDebt(deps.kernel.getInitialErrorCount(), deps.kernel.getCurrentErrorCount());
-                    }
-                }
+                const verifyResult = await processKernelResult(kernelResult, [resolvedPath], deps, `## Semantic Edit: BLOCKED BY NREKI (Layer 2)\n\n` +
+                    `**Symbol:** ${symbol}\n` +
+                    `**File:** ${file}\n\n`);
+                if (verifyResult.response)
+                    return verifyResult.response;
+                ttrdFeedback = verifyResult.ttrdFeedback;
             }
             catch (kernelError) {
                 logger.error(`Kernel error during edit verification: ${kernelError}`);
-                try {
-                    saveBackup(process.cwd(), resolvedPath);
-                }
-                catch { }
-                fs.writeFileSync(resolvedPath, result.newContent, "utf-8");
                 try {
                     await deps.kernel.rollbackAll();
                 }
                 catch (e) {
                     logger.error(`Rollback after kernel crash also failed: ${e}`);
                 }
+                return {
+                    content: [{
+                            type: "text",
+                            text: `## Edit: KERNEL ERROR\n\n` +
+                                `The edit passed AST validation (Layer 1) but the kernel crashed during ` +
+                                `cross-file semantic verification (Layer 2).\n\n` +
+                                `**Error:** ${kernelError}\n\n` +
+                                `The file was NOT modified. The kernel has been reset.\n` +
+                                `Retry the edit, or apply manually if you trust the change.\n\n` +
+                                `[NREKI saved ~0 tokens]`,
+                        }],
+                    isError: true,
+                };
             }
         }
         // ─── End NREKI Layer 2 ───────────────────────────────────────
@@ -553,12 +610,15 @@ export async function handleBatchEdit(params, deps) {
             };
         }
     }
+    const uniquePathSet = new Set();
     const uniquePaths = [];
     for (const e of edits) {
         try {
             const resolved = safePath(process.cwd(), e.path);
-            if (!uniquePaths.includes(resolved))
+            if (!uniquePathSet.has(resolved)) {
+                uniquePathSet.add(resolved);
                 uniquePaths.push(resolved);
+            }
         }
         catch (err) {
             return {
@@ -612,20 +672,7 @@ export async function handleBatchEdit(params, deps) {
                 ? e.mode
                 : "replace",
         }));
-        let useKernel = false;
-        if (deps.kernel && deps.nrekiMode !== "syntax") {
-            if (!deps.kernel.isBooted()) {
-                logger.info(`Booting kernel (${deps.nrekiMode} mode). First edit will be slower.`);
-                try {
-                    await ensureHologramReady(deps.kernel, deps.nrekiMode ?? "");
-                    deps.kernel.boot(process.cwd(), deps.nrekiMode);
-                }
-                catch (err) {
-                    logger.error(`Kernel boot failed: ${err.message}. Falling back to Layer 1.`);
-                }
-            }
-            useKernel = deps.kernel.isBooted();
-        }
+        const useKernel = await ensureKernelBooted(deps);
         const result = await batchSemanticEdit(batchOps, parser, sandbox, process.cwd(), useKernel);
         if (!result.success || (useKernel && !result.vfs)) {
             return {
@@ -681,130 +728,38 @@ export async function handleBatchEdit(params, deps) {
                 }
                 if (kernelEdits.length > 0) {
                     const kernelResult = await deps.kernel.interceptAtomicBatch(kernelEdits, batchDependents);
-                    if (!kernelResult.safe) {
-                        const agentErrors = kernelResult.structured?.filter(e => !e.file.match(/[/\\]node_modules[/\\]/)) || [];
-                        if (agentErrors.length === 0) {
-                            logger.warn(`${kernelResult.structured?.length} error(s) in node_modules ignored.`);
-                            for (const filePath of result.vfs.keys()) {
-                                try {
-                                    saveBackup(process.cwd(), filePath);
-                                }
-                                catch { }
-                            }
-                            await deps.kernel.commitToDisk();
-                        }
-                        else {
-                            if (deps.chronos) {
-                                const errorByFile = new Map();
-                                for (const e of agentErrors) {
-                                    if (!errorByFile.has(e.file))
-                                        errorByFile.set(e.file, e.message);
-                                }
-                                for (const [fragileFile, firstMsg] of errorByFile.entries()) {
-                                    deps.chronos.recordSemanticError(fragileFile, firstMsg);
-                                }
-                            }
-                            await deps.kernel.rollbackAll();
-                            const structuredInfo = "\n\nSemantic errors:\n" +
-                                agentErrors.map(e => `  → ${path.relative(process.cwd(), e.file)} (${e.line},${e.column}): ${e.code} - ${e.message}`).join("\n");
-                            return {
-                                content: [{
-                                        type: "text",
-                                        text: `## Batch Edit: BLOCKED BY NREKI (Layer 2)\n\n` +
-                                            `**Edits attempted:** ${result.editCount}\n` +
-                                            `**Files involved:** ${result.fileCount}\n\n` +
-                                            `Layer 1 (syntax) passed for all files, but Layer 2 (cross-file semantics) detected errors.\n` +
-                                            `🛡️ **DISK UNTOUCHED: Transaction aborted in RAM. No files were modified.**${structuredInfo}\n\n` +
-                                            `If you changed a function signature, include ALL callers in the same batch.\n\n` +
-                                            `[NREKI: RAM validated in ${kernelResult.latencyMs}ms]`,
-                                    }],
-                                isError: true,
-                            };
-                        }
-                    }
-                    else {
-                        for (const filePath of result.vfs.keys()) {
-                            try {
-                                saveBackup(process.cwd(), filePath);
-                            }
-                            catch { }
-                        }
-                        if (kernelResult.healedFiles) {
-                            for (const hf of kernelResult.healedFiles) {
-                                try {
-                                    saveBackup(process.cwd(), path.resolve(process.cwd(), hf));
-                                }
-                                catch { }
-                                if (deps.chronos)
-                                    deps.chronos.recordHeal(hf);
-                            }
-                        }
-                        await deps.kernel.commitToDisk();
-                        if (deps.chronos && kernelResult.postContracts) {
-                            if (kernelResult.regressions && kernelResult.regressions.length > 0) {
-                                const byFile = new Map();
-                                for (const r of kernelResult.regressions) {
-                                    const arr = byFile.get(r.filePath) || [];
-                                    arr.push(r);
-                                    byFile.set(r.filePath, arr);
-                                }
-                                const penaltyList = [];
-                                for (const [fPath, regs] of byFile.entries()) {
-                                    deps.chronos.recordRegressions(path.resolve(process.cwd(), fPath), regs);
-                                    for (const r of regs) {
-                                        penaltyList.push(`  - \`${r.symbol}\` in \`${path.basename(fPath)}\`: \`${r.oldType}\` -> \`${r.newType}\``);
-                                    }
-                                }
-                                batchTtrdFeedback += `\n\n**TYPE REGRESSION DETECTED**\n` +
-                                    `The batch compiled successfully, but weakened type safety:\n` +
-                                    `${penaltyList.join("\n")}\n` +
-                                    `This technical debt has been logged. Restore strict typing.`;
-                            }
-                            const allPaid = [];
-                            for (const filePath of result.vfs.keys()) {
-                                const posixPath = deps.kernel.resolvePosixPath(filePath);
-                                const fileContracts = kernelResult.postContracts.get(posixPath);
-                                const paid = deps.chronos.assessDebtPayments(filePath, fileContracts);
-                                if (paid.length > 0) {
-                                    allPaid.push(`\`${path.basename(filePath)}\`: ${paid.join(", ")}`);
-                                }
-                                const hasRegressionHere = kernelResult.regressions?.some(r => r.filePath === posixPath);
-                                if (!hasRegressionHere) {
-                                    deps.chronos.recordSuccess(filePath);
-                                }
-                            }
-                            if (allPaid.length > 0) {
-                                batchTtrdFeedback += `\n\n**TYPE DEBT PAID**\n` +
-                                    `Strict typing restored:\n` +
-                                    `${allPaid.join("\n")}\n` +
-                                    `Friction score reduced.`;
-                            }
-                            deps.chronos.syncTechDebt(deps.kernel.getInitialErrorCount(), deps.kernel.getCurrentErrorCount());
-                        }
-                        else if (deps.chronos) {
-                            for (const filePath of result.vfs.keys()) {
-                                deps.chronos.recordSuccess(filePath);
-                            }
-                            deps.chronos.syncTechDebt(deps.kernel.getInitialErrorCount(), deps.kernel.getCurrentErrorCount());
-                        }
-                    }
+                    const committedFiles = Array.from(result.vfs.keys());
+                    const verifyResult = await processKernelResult(kernelResult, committedFiles, deps, `## Batch Edit: BLOCKED BY NREKI (Layer 2)\n\n` +
+                        `**Edits attempted:** ${result.editCount}\n` +
+                        `**Files involved:** ${result.fileCount}\n\n`);
+                    if (verifyResult.response)
+                        return verifyResult.response;
+                    batchTtrdFeedback = verifyResult.ttrdFeedback;
                 }
             }
             catch (kernelError) {
                 logger.error(`Kernel error during batch verification: ${kernelError}`);
-                for (const [filePath, content] of result.vfs.entries()) {
-                    try {
-                        saveBackup(process.cwd(), filePath);
-                    }
-                    catch { }
-                    fs.writeFileSync(filePath, content, "utf-8");
-                }
                 try {
                     await deps.kernel.rollbackAll();
                 }
                 catch (e) {
                     logger.error(`Rollback after kernel crash also failed: ${e}`);
                 }
+                for (const rp of acquiredLocks)
+                    releaseFileLock(rp);
+                return {
+                    content: [{
+                            type: "text",
+                            text: `## Batch Edit: KERNEL ERROR\n\n` +
+                                `All ${result.editCount} edits passed AST validation (Layer 1) but the kernel ` +
+                                `crashed during cross-file semantic verification (Layer 2).\n\n` +
+                                `**Error:** ${kernelError}\n\n` +
+                                `No files were modified. The kernel has been reset.\n` +
+                                `Retry the batch edit, or apply edits individually.\n\n` +
+                                `[NREKI saved ~0 tokens]`,
+                        }],
+                    isError: true,
+                };
             }
         }
         // ─── End NREKI Layer 2 ───────────────────────────────────────