@stevenvo780/st-lang 2.6.0 → 2.7.0

package/dist/runtime/interpreter.js

@@ -7,12 +7,17 @@ exports.Interpreter = void 0;
 const parser_1 = require("../parser/parser");
 const interface_1 = require("../profiles/interface");
 const propositional_1 = require("../profiles/classical/propositional");
+const arithmetic_1 = require("../profiles/arithmetic");
 const format_1 = require("./format");
 const fallacies_1 = require("./fallacies");
 // Barrel import: registra todos los perfiles automáticamente
 require("../profiles");
 const compiler_1 = require("../text-layer/compiler");
 const formula_classifier_1 = require("./formula-classifier");
+const formula_factory_1 = require("./formula-factory");
+const MAX_CALL_DEPTH = 10000;
+const DEFAULT_MAX_RUNTIME_STEPS = 100000;
+const DEFAULT_MAX_RUNTIME_CALLS = 7000;
 class Interpreter {
     theory;
     profile = null;
@@ -40,6 +45,14 @@ class Interpreter {
     exportedTheorems = new Map();
     exportedFunctions = new Map();
     exportedTheories = new Map();
+    /** Profundidad de llamadas a funciones (anti-recursión infinita) */
+    callDepth = 0;
+    currentBindingFrame = null;
+    runtimeStepCount = 0;
+    runtimeCallCount = 0;
+    /** Cache de resolución: fórmula original → fórmula resuelta (invalidado al cambiar bindings) */
+    resolveCache = new WeakMap();
+    resolveCacheGeneration = 0;
     constructor() {
         this.theory = this.createEmptyTheory();
         this.textLayer = (0, compiler_1.createTextLayerState)();
@@ -47,7 +60,17 @@ class Interpreter {
     }
     /** Registra funciones nativas (Built-ins) para metaprogramación e interactividad */
     registerBuiltins() {
-        const builtins = ['typeof', 'is_valid', 'is_satisfiable', 'get_atoms', 'input'];
+        const builtins = [
+            'typeof',
+            'is_valid',
+            'is_satisfiable',
+            'get_atoms',
+            'atoms_of',
+            'len',
+            'at',
+            'formula_eq',
+            'input',
+        ];
         for (const name of builtins) {
             this.functions.set(name, {
                 kind: 'fn_decl',
@@ -90,11 +113,123 @@ class Interpreter {
         this.exportedTheorems.clear();
         this.exportedFunctions.clear();
         this.exportedTheories.clear();
+        this.currentBindingFrame = null;
+        this.runtimeStepCount = 0;
+        this.runtimeCallCount = 0;
+    }
+    getRuntimeStepLimit() {
+        const configured = this.getBinding('max_steps') || this.getBinding('max_runtime_steps');
+        if (configured?.kind === 'number' && configured.value && configured.value > 0) {
+            return Math.floor(configured.value);
+        }
+        return DEFAULT_MAX_RUNTIME_STEPS;
+    }
+    getRuntimeCallLimit() {
+        const configured = this.getBinding('max_calls') || this.getBinding('max_runtime_calls');
+        if (configured?.kind === 'number' && configured.value && configured.value > 0) {
+            return Math.floor(configured.value);
+        }
+        return DEFAULT_MAX_RUNTIME_CALLS;
+    }
+    tickRuntimeStep() {
+        this.runtimeStepCount++;
+        const limit = this.getRuntimeStepLimit();
+        if (this.runtimeStepCount > limit) {
+            throw new Error(`Límite de ejecución excedido (${limit} pasos).`);
+        }
+    }
+    isSafetyLimitMessage(message) {
+        return /Límite de (recursión|ejecución|llamadas ST)/i.test(message);
+    }
+    createBindingFrame() {
+        return {
+            bindings: new Map(),
+            descriptions: new Map(),
+            parent: this.currentBindingFrame,
+        };
+    }
+    findBindingOwner(name) {
+        let frame = this.currentBindingFrame;
+        while (frame) {
+            if (frame.bindings.has(name))
+                return frame;
+            frame = frame.parent;
+        }
+        if (this.letBindings.has(name))
+            return 'global';
+        return undefined;
+    }
+    hasBinding(name) {
+        return this.findBindingOwner(name) !== undefined;
+    }
+    getBinding(name) {
+        const owner = this.findBindingOwner(name);
+        if (!owner)
+            return undefined;
+        return owner === 'global' ? this.letBindings.get(name) : owner.bindings.get(name);
+    }
+    defineBinding(name, value, description) {
+        this.invalidateResolveCache();
+        if (this.currentBindingFrame) {
+            this.currentBindingFrame.bindings.set(name, value);
+            if (description)
+                this.currentBindingFrame.descriptions.set(name, description);
+            return;
+        }
+        this.letBindings.set(name, value);
+        if (description)
+            this.letDescriptions.set(name, description);
+    }
+    setBinding(name, value) {
+        this.invalidateResolveCache();
+        const owner = this.findBindingOwner(name);
+        if (owner === 'global') {
+            this.letBindings.set(name, value);
+            return;
+        }
+        if (owner) {
+            owner.bindings.set(name, value);
+            return;
+        }
+        if (this.currentBindingFrame) {
+            this.currentBindingFrame.bindings.set(name, value);
+            return;
+        }
+        this.letBindings.set(name, value);
+    }
+    captureBindingSnapshot(name) {
+        const owner = this.findBindingOwner(name);
+        if (!owner)
+            return { exists: false, owner: 'global' };
+        return {
+            exists: true,
+            value: owner === 'global' ? this.letBindings.get(name) : owner.bindings.get(name),
+            owner,
+        };
+    }
+    restoreBindingSnapshot(name, snapshot) {
+        if (!snapshot.exists) {
+            if (this.currentBindingFrame && this.currentBindingFrame.bindings.has(name)) {
+                this.currentBindingFrame.bindings.delete(name);
+            }
+            this.letBindings.delete(name);
+            return;
+        }
+        if (snapshot.owner === 'global') {
+            this.letBindings.set(name, snapshot.value);
+            return;
+        }
+        snapshot.owner.bindings.set(name, snapshot.value);
+    }
+    shouldEmitLocalBindings() {
+        return this.currentBindingFrame === null;
     }
     execute(source, file = '<stdin>') {
         this.diagnostics = [];
         this.results = [];
         this.stdoutLines = [];
+        this.runtimeStepCount = 0;
+        this.runtimeCallCount = 0;
         const parser = new parser_1.Parser(file);
         const program = parser.parse(source);
         this.diagnostics.push(...parser.diagnostics);
@@ -110,21 +245,7 @@ class Interpreter {
                 results: [],
             };
         }
-        for (const stmt of program.statements) {
-            try {
-                this.executeStatement(stmt);
-            }
-            catch (e) {
-                const message = e instanceof Error ? e.message : String(e);
-                this.diagnostics.push({
-                    severity: 'error',
-                    message: message || 'Error de runtime',
-                    file,
-                    line: stmt.source.line,
-                    column: stmt.source.column,
-                });
-            }
-        }
+        this.executeStatementsIterative(program.statements, file);
         const hasErrors = this.diagnostics.some((d) => d.severity === 'error');
         return {
             stdout: this.stdoutLines.join('\n'),
@@ -145,6 +266,8 @@ class Interpreter {
         this.diagnostics = [...parser.diagnostics];
         this.results = [];
         this.stdoutLines = [];
+        this.runtimeStepCount = 0;
+        this.runtimeCallCount = 0;
         if (parser.diagnostics.some((d) => d.severity === 'error')) {
             return {
                 stdout: '',
@@ -154,18 +277,7 @@ class Interpreter {
                 results: [],
             };
         }
-        for (const stmt of program.statements) {
-            try {
-                this.executeStatement(stmt);
-            }
-            catch (e) {
-                const message = e instanceof Error ? e.message : String(e);
-                this.diagnostics.push({
-                    severity: 'error',
-                    message: message || 'Error de runtime',
-                });
-            }
-        }
+        this.executeStatementsIterative(program.statements, '<repl>');
         return {
             stdout: this.stdoutLines.join('\n'),
             stderr: this.diagnostics
@@ -261,9 +373,268 @@ class Interpreter {
                 return this.execExportDecl(stmt);
         }
     }
+    executeStatementsIterative(statements, fallbackFile) {
+        const runtimeStack = [{ kind: 'statements', statements, index: 0 }];
+        while (runtimeStack.length > 0) {
+            if (this.returnSignal)
+                break;
+            const frame = runtimeStack[runtimeStack.length - 1];
+            if (frame.kind === 'statements') {
+                if (frame.index >= frame.statements.length) {
+                    runtimeStack.pop();
+                    continue;
+                }
+                const stmt = frame.statements[frame.index++];
+                try {
+                    this.dispatchRuntimeStatement(stmt, runtimeStack);
+                }
+                catch (e) {
+                    const message = e instanceof Error ? e.message : String(e);
+                    this.diagnostics.push({
+                        severity: this.isSafetyLimitMessage(message || '') ? 'warning' : 'error',
+                        message: message || 'Error de runtime',
+                        file: stmt.source.file || fallbackFile,
+                        line: stmt.source.line,
+                        column: stmt.source.column,
+                    });
+                }
+                continue;
+            }
+            if (frame.kind === 'for') {
+                if (this.returnSignal || frame.index >= frame.stmt.items.length) {
+                    this.restoreBindingSnapshot(frame.stmt.variable, frame.savedBinding);
+                    runtimeStack.pop();
+                    continue;
+                }
+                const resolved = this.evaluateFormulaValue(frame.stmt.items[frame.index]);
+                this.setBinding(frame.stmt.variable, resolved);
+                frame.index++;
+                runtimeStack.push({ kind: 'statements', statements: frame.stmt.body, index: 0 });
+                continue;
+            }
+            if (this.returnSignal) {
+                runtimeStack.pop();
+                continue;
+            }
+            const profile = this.requireProfile();
+            const maxIter = frame.stmt.maxIterations || 1000;
+            if (frame.iterations >= maxIter) {
+                this.diagnostics.push({
+                    severity: 'warning',
+                    message: `while: se alcanzó el límite de ${maxIter} iteraciones`,
+                    file: frame.stmt.source.file,
+                    line: frame.stmt.source.line,
+                    column: frame.stmt.source.column,
+                });
+                runtimeStack.pop();
+                continue;
+            }
+            const resolved = this.evaluateFormulaValue(frame.stmt.formula);
+            const matched = this.matchesRuntimeCondition(profile, frame.stmt.condition, resolved);
+            if (!matched) {
+                runtimeStack.pop();
+                continue;
+            }
+            frame.iterations++;
+            runtimeStack.push({ kind: 'statements', statements: frame.stmt.body, index: 0 });
+        }
+    }
+    dispatchRuntimeStatement(stmt, runtimeStack) {
+        if (this.returnSignal)
+            return;
+        this.tickRuntimeStep();
+        const directCall = this.getDirectFunctionCall(stmt);
+        if (directCall) {
+            const result = this.executeFnCall(directCall.call);
+            this.applyFunctionContinuation({ type: directCall.type, stmt: directCall.stmt }, result);
+            return;
+        }
+        if (this.isImporting) {
+            const sideEffects = [
+                'derive_cmd',
+                'check_valid_cmd',
+                'check_satisfiable_cmd',
+                'check_equivalent_cmd',
+                'prove_cmd',
+                'countermodel_cmd',
+                'truth_table_cmd',
+                'print_cmd',
+                'analyze_cmd',
+                'explain_cmd',
+                'render_cmd',
+            ];
+            if (sideEffects.includes(stmt.kind) || stmt.kind === 'logic_decl')
+                return;
+        }
+        switch (stmt.kind) {
+            case 'if_stmt': {
+                const selectedBody = this.selectIfBody(stmt);
+                if (selectedBody)
+                    runtimeStack.push({ kind: 'statements', statements: selectedBody, index: 0 });
+                return;
+            }
+            case 'for_stmt':
+                runtimeStack.push({
+                    kind: 'for',
+                    stmt,
+                    index: 0,
+                    savedBinding: this.captureBindingSnapshot(stmt.variable),
+                });
+                return;
+            case 'while_stmt':
+                runtimeStack.push({ kind: 'while', stmt, iterations: 0 });
+                return;
+            case 'logic_decl':
+                return this.execLogicDecl(stmt);
+            case 'axiom_decl':
+                return this.execAxiomDecl(stmt);
+            case 'theorem_decl':
+                return this.execTheoremDecl(stmt);
+            case 'derive_cmd':
+                return this.execDeriveCmd(stmt);
+            case 'check_valid_cmd':
+                return this.execCheckValidCmd(stmt);
+            case 'check_satisfiable_cmd':
+                return this.execCheckSatisfiableCmd(stmt);
+            case 'check_equivalent_cmd':
+                return this.execCheckEquivalentCmd(stmt);
+            case 'prove_cmd':
+                return this.execProveCmd(stmt);
+            case 'countermodel_cmd':
+                return this.execCountermodelCmd(stmt);
+            case 'truth_table_cmd':
+                return this.execTruthTableCmd(stmt);
+            case 'let_decl':
+                return this.execLetDecl(stmt);
+            case 'claim_decl':
+                return this.execClaimDecl(stmt);
+            case 'support_decl':
+                return this.execSupportDecl(stmt);
+            case 'confidence_decl':
+                return this.execConfidenceDecl(stmt);
+            case 'context_decl':
+                return this.execContextDecl(stmt);
+            case 'render_cmd':
+                return this.execRenderCmd(stmt);
+            case 'analyze_cmd':
+                return this.execAnalyzeCmd(stmt);
+            case 'explain_cmd':
+                return this.execExplainCmd(stmt);
+            case 'import_decl':
+                return this.execImportDecl(stmt);
+            case 'proof_block':
+                return this.execProofBlock(stmt);
+            case 'theory_decl':
+                return this.execTheoryDecl(stmt);
+            case 'print_cmd':
+                return this.execPrintCmd(stmt);
+            case 'set_cmd':
+                return this.execSetCmd(stmt);
+            case 'fn_decl':
+                return this.execFnDecl(stmt);
+            case 'return_stmt':
+                return this.execReturnStmt(stmt);
+            case 'fn_call':
+                this.executeFnCall(stmt);
+                return;
+            case 'export_decl':
+                return this.execExportDecl(stmt);
+        }
+    }
+    selectIfBody(stmt) {
+        const profile = this.requireProfile();
+        for (const branch of stmt.branches) {
+            const resolved = this.evaluateFormulaValue(branch.formula);
+            const matched = this.matchesRuntimeCondition(profile, branch.condition, resolved);
+            if (matched)
+                return branch.body;
+        }
+        return stmt.elseBranch;
+    }
+    matchesRuntimeCondition(profile, condition, formula) {
+        if (profile.name === 'arithmetic') {
+            const numeric = (0, arithmetic_1.evalNumeric)(formula);
+            const truthy = !Number.isNaN(numeric) && numeric !== 0;
+            if (condition === 'valid' || condition === 'satisfiable')
+                return truthy;
+            return !truthy;
+        }
+        if (condition === 'valid' || condition === 'invalid') {
+            const result = profile.checkValid(formula);
+            return condition === 'valid' ? result.status === 'valid' : result.status !== 'valid';
+        }
+        const result = profile.checkSatisfiable(formula);
+        return condition === 'satisfiable'
+            ? result.status === 'satisfiable' || result.status === 'valid'
+            : result.status === 'unsatisfiable';
+    }
+    evaluateFormulaValue(formula) {
+        if (formula.kind === 'fn_call' && formula.name) {
+            const result = this.executeFnCall({ name: formula.name, args: formula.args || [] });
+            return result || { kind: 'atom', name: 'undefined', source: formula.source };
+        }
+        return this.resolveFormula(formula);
+    }
+    getDirectFunctionCall(stmt) {
+        if (stmt.kind === 'fn_call') {
+            return { call: { name: stmt.name, args: stmt.args }, type: 'discard' };
+        }
+        if (stmt.kind === 'let_decl' && stmt.letType === 'formula' && stmt.formula.kind === 'fn_call') {
+            return {
+                call: { name: stmt.formula.name || '', args: stmt.formula.args || [] },
+                type: 'let_decl',
+                stmt,
+            };
+        }
+        if (stmt.kind === 'set_cmd' && stmt.formula.kind === 'fn_call') {
+            return {
+                call: { name: stmt.formula.name || '', args: stmt.formula.args || [] },
+                type: 'set_cmd',
+                stmt,
+            };
+        }
+        if (stmt.kind === 'return_stmt' && stmt.formula?.kind === 'fn_call') {
+            return {
+                call: { name: stmt.formula.name || '', args: stmt.formula.args || [] },
+                type: 'return_stmt',
+                stmt,
+            };
+        }
+        if (stmt.kind === 'print_cmd' && stmt.formula?.kind === 'fn_call') {
+            return {
+                call: { name: stmt.formula.name || '', args: stmt.formula.args || [] },
+                type: 'print_cmd',
+                stmt,
+            };
+        }
+        return undefined;
+    }
+    applyFunctionContinuation(continuation, result) {
+        const normalized = result || { kind: 'atom', name: 'undefined' };
+        switch (continuation.type) {
+            case 'discard':
+                return;
+            case 'let_decl': {
+                const letStmt = continuation.stmt;
+                if (letStmt.letType === 'formula') {
+                    return this.execLetDecl({ ...letStmt, formula: normalized });
+                }
+                return;
+            }
+            case 'set_cmd':
+                return this.execSetCmd({ ...continuation.stmt, formula: normalized });
+            case 'return_stmt':
+                return this.execReturnStmt({
+                    ...continuation.stmt,
+                    formula: normalized,
+                });
+            case 'print_cmd':
+                return this.execPrintCmd({ ...continuation.stmt, formula: normalized });
+        }
+    }
     execExportDecl(stmt) {
         // Ejecutar la declaración interna
-        this.executeStatement(stmt.statement);
+        this.executeStatementsIterative([stmt.statement], stmt.source.file);
         // Registrarla como exportada
         const s = stmt.statement;
         switch (s.kind) {
@@ -299,32 +670,56 @@ class Interpreter {
      * por sus fórmulas definidas. Detecta ciclos para evitar recursión infinita.
      * Soporta notación con punto: Theory.member resuelve desde el scope de la teoría.
      */
+    invalidateResolveCache() {
+        this.resolveCache = new WeakMap();
+        this.resolveCacheGeneration++;
+    }
     resolveFormula(f, visited = new Set()) {
+        // Check resolution cache first
+        const cached = this.resolveCache.get(f);
+        if (cached !== undefined)
+            return cached;
+        const resolved = this.resolveFormulaRecursive(f, visited);
+        // Constant-fold pure arithmetic (add, subtract, etc.) but NOT comparisons
+        // so profiles can still see the structural form of comparisons.
+        const folded = this.tryConstantFold(resolved);
+        // Cache the result and deduplicate via FormulaFactory
+        const result = formula_factory_1.FormulaFactory.create(folded);
+        this.resolveCache.set(f, result);
+        return result;
+    }
+    resolveFormulaRecursive(f, visited) {
         if (!f)
             return f;
         // Si es un átomo, intentar resolver
         if (f.kind === 'atom' && f.name) {
+            if (this.hasBinding(f.name)) {
+                if (visited.has(f.name))
+                    return f;
+                visited.add(f.name);
+                const result = this.resolveFormulaRecursive(this.getBinding(f.name), visited);
+                visited.delete(f.name);
+                return result;
+            }
             // Dot notation: Theory.member o instance.member
             if (f.name.includes('.')) {
                 const [prefix, memberName] = f.name.split('.', 2);
                 // 1. Intentar resolver el prefijo como una variable local (instancia)
-                // Ej: let f1 = Familia("Socrates") -> f1.amor
-                if (this.letBindings.has(prefix)) {
-                    const resolvedPrefix = this.letBindings.get(prefix);
+                if (this.hasBinding(prefix)) {
+                    const resolvedPrefix = this.getBinding(prefix);
                     if (resolvedPrefix.kind === 'atom' && resolvedPrefix.name) {
-                        // Si el prefijo se resuelve a un nombre de teoría/instancia
                         const actualInstanceName = resolvedPrefix.name;
                         const scope = this.theories.get(actualInstanceName);
                         if (scope) {
                             if (scope.privateMembers.has(memberName) &&
                                 this.currentTheoryName !== actualInstanceName)
                                 return f;
-                            if (scope.letBindings.has(memberName))
-                                return this.resolveFormula(scope.letBindings.get(memberName), new Set(visited));
-                            if (scope.axioms.has(memberName))
-                                return this.resolveFormula(scope.axioms.get(memberName), new Set(visited));
-                            if (scope.theorems.has(memberName))
-                                return this.resolveFormula(scope.theorems.get(memberName), new Set(visited));
+                            const member = scope.letBindings.get(memberName) ??
+                                scope.axioms.get(memberName) ??
+                                scope.theorems.get(memberName);
+                            if (member) {
+                                return this.resolveFormulaRecursive(member, visited);
+                            }
                         }
                     }
                 }
@@ -333,35 +728,31 @@ class Interpreter {
                 if (scope) {
                     if (scope.privateMembers.has(memberName) && this.currentTheoryName !== prefix)
                         return f;
-                    if (scope.letBindings.has(memberName))
-                        return this.resolveFormula(scope.letBindings.get(memberName), new Set(visited));
-                    if (scope.axioms.has(memberName))
-                        return this.resolveFormula(scope.axioms.get(memberName), new Set(visited));
-                    if (scope.theorems.has(memberName))
-                        return this.resolveFormula(scope.theorems.get(memberName), new Set(visited));
+                    const member = scope.letBindings.get(memberName) ??
+                        scope.axioms.get(memberName) ??
+                        scope.theorems.get(memberName);
+                    if (member) {
+                        return this.resolveFormulaRecursive(member, visited);
+                    }
                 }
                 return f;
             }
-            // Binding local normal
-            if (this.letBindings.has(f.name)) {
-                if (visited.has(f.name)) {
-                    return f;
-                }
-                visited.add(f.name);
-                return this.resolveFormula(this.letBindings.get(f.name), new Set(visited));
-            }
             // También resolver axiomas/teoremas del theory actual por nombre
             if (this.theory.axioms.has(f.name)) {
                 if (visited.has(f.name))
                     return f;
                 visited.add(f.name);
-                return this.resolveFormula(this.theory.axioms.get(f.name), new Set(visited));
+                const result = this.resolveFormulaRecursive(this.theory.axioms.get(f.name), visited);
+                visited.delete(f.name);
+                return result;
             }
             if (this.theory.theorems.has(f.name)) {
                 if (visited.has(f.name))
                     return f;
                 visited.add(f.name);
-                return this.resolveFormula(this.theory.theorems.get(f.name), new Set(visited));
+                const result = this.resolveFormulaRecursive(this.theory.theorems.get(f.name), visited);
+                visited.delete(f.name);
+                return result;
             }
         }
         // Llamada a función como expresión
@@ -371,12 +762,16 @@ class Interpreter {
         }
         // Recorrer hijos recursivamente
         if (f.args && f.args.length > 0) {
-            const newArgs = f.args.map((a) => (a ? this.resolveFormula(a, new Set(visited)) : a));
-            const oldArgs = f.args;
-            const changed = newArgs.some((a, i) => a !== oldArgs[i]);
-            if (changed) {
-                return { ...f, args: newArgs };
+            const newArgs = f.args.map((a) => (a ? this.resolveFormulaRecursive(a, visited) : a));
+            // Check if args actually changed to avoid unnecessary object creation
+            let changed = false;
+            for (let i = 0; i < f.args.length; i++) {
+                if (f.args[i] !== newArgs[i]) {
+                    changed = true;
+                    break;
+                }
             }
+            return changed ? { ...f, args: newArgs } : f;
         }
         return f;
     }
@@ -453,10 +848,60 @@ class Interpreter {
     }
     execTruthTableCmd(stmt) {
         const profile = this.requireProfile();
+        const formula = this.resolveFormula(stmt.formula);
+        if (profile.name === 'classical.propositional') {
+            const atoms = Array.from((0, propositional_1.collectAtoms)(formula)).sort();
+            // Streaming de tabla de verdad para evitar OOM
+            this.emit(`Tabla de verdad para ${(0, propositional_1.formulaToString)(formula)}:`);
+            this.emit(`  ${atoms.join(' | ')} | Resultado`);
+            this.emit(`  ${atoms.map(() => '---').join('-|-')}-|----------`);
+            let isTautology = true;
+            let isSatisfiable = false;
+            let count = 0;
+            let satCount = 0;
+            for (const v of (0, propositional_1.generateValuationsLazy)(atoms)) {
+                const res = (0, propositional_1.evaluateClassical)(formula, v);
+                if (res) {
+                    isSatisfiable = true;
+                    satCount++;
+                }
+                else {
+                    isTautology = false;
+                }
+                count++;
+                // Solo imprimir las primeras 64 filas para no saturar el stdout en tablas masivas
+                if (count <= 64) {
+                    const row = atoms.map((a) => (v[a] ? 'V' : 'F')).join(' | ');
+                    this.emit(`  ${row} | ${res ? 'V' : 'F'}`);
+                }
+                else if (count === 65) {
+                    this.emit('  ... (tabla masiva, ocultando filas intermedias) ...');
+                }
+            }
+            this.emit(`\nResumen: ${count} valuaciones analizadas.`);
+            this.emit(`Estatus: ${isTautology ? 'Tautología ✓' : isSatisfiable ? 'Satisfacible' : 'Contradicción ✗'}`);
+            this.results.push({
+                status: isTautology ? 'valid' : isSatisfiable ? 'satisfiable' : 'unsatisfiable',
+                output: `Tabla de verdad de ${count} filas procesada.`,
+                truthTable: {
+                    variables: atoms,
+                    rows: [],
+                    subFormulas: [],
+                    subFormulaValues: [],
+                    isTautology,
+                    isContradiction: !isSatisfiable,
+                    isSatisfiable,
+                    satisfyingCount: satCount,
+                },
+                diagnostics: [],
+                formula: formula,
+            });
+            return;
+        }
+        // Fallback para otros perfiles
         if (!profile.truthTable) {
             throw new Error('Este perfil no soporta truth_table');
         }
-        const formula = this.resolveFormula(stmt.formula);
         const tt = profile.truthTable(formula);
         const result = {
             status: tt.isTautology ? 'valid' : tt.isSatisfiable ? 'satisfiable' : 'unsatisfiable',
@@ -482,24 +927,37 @@ class Interpreter {
             this.emit(`Formalizacion ${stmt.name}: ${stmt.passageName} -> ${(0, propositional_1.formulaToString)(formula)}`);
         }
         else if (stmt.letType === 'description') {
-            // Solo descripción textual: P es un átomo con significado semántico
-            this.letDescriptions.set(stmt.name, stmt.description);
-            this.emit(`Let ${stmt.name} = "${stmt.description}"`);
+            if (this.currentBindingFrame)
+                this.currentBindingFrame.descriptions.set(stmt.name, stmt.description);
+            else
+                this.letDescriptions.set(stmt.name, stmt.description);
+            if (this.shouldEmitLocalBindings())
+                this.emit(`Let ${stmt.name} = "${stmt.description}"`);
+        }
+        else if (stmt.letType === 'action') {
+            const actionStmt = stmt;
+            const captured = this.executeActionExpr(actionStmt.action);
+            this.results.push(captured.result);
+            this.bindCapturedAction(actionStmt.name, actionStmt.action.action, captured.primary, captured.result, captured.formulas, captured.extraBindings);
+            if (this.shouldEmitLocalBindings()) {
+                this.emit(`Let ${actionStmt.name} = ${(0, format_1.formulaToUnicode)(captured.primary)}`);
+            }
         }
         else if (stmt.letType === 'formula' && stmt.formula) {
-            // Resolver posibles variables anidadas en la propia definición
-            const resolved = this.resolveFormula(stmt.formula);
-            // Registrar como binding para sustitución futura
-            this.letBindings.set(stmt.name, resolved);
-            // También como axioma implícito para derivaciones
-            this.theory.axioms.set(stmt.name, resolved);
-            // Si tiene descripción textual (let X = "desc" : formula), guardarla
+            // Resolve bindings but preserve symbolic structure (no constant-folding)
+            const resolved = this.resolveFormulaRecursive(stmt.formula, new Set());
+            this.defineBinding(stmt.name, resolved, 'description' in stmt ? stmt.description : undefined);
+            if (!this.currentBindingFrame)
+                this.theory.axioms.set(stmt.name, resolved);
             if ('description' in stmt && stmt.description) {
-                this.letDescriptions.set(stmt.name, stmt.description);
-                this.emit(`Let ${stmt.name} = "${stmt.description}" : ${(0, format_1.formulaToUnicode)(resolved)}`);
+                if (!this.currentBindingFrame)
+                    this.letDescriptions.set(stmt.name, stmt.description);
+                if (this.shouldEmitLocalBindings())
+                    this.emit(`Let ${stmt.name} = "${stmt.description}" : ${(0, format_1.formulaToUnicode)(resolved)}`);
             }
             else {
-                this.emit(`Let ${stmt.name} = ${(0, format_1.formulaToUnicode)(resolved)}`);
+                if (this.shouldEmitLocalBindings())
+                    this.emit(`Let ${stmt.name} = ${(0, format_1.formulaToUnicode)(resolved)}`);
             }
         }
     }
@@ -508,7 +966,6 @@ class Interpreter {
         const formalization = stmt.formalization;
         const diags = (0, compiler_1.registerClaim)(this.textLayer, stmt.name, formula, formalization);
         this.diagnostics.push(...diags);
-        // También agregar al theory.claims
         const claim = {
             name: stmt.name,
             formula: formula,
@@ -533,7 +990,6 @@ class Interpreter {
         this.emit(`Context: ${stmt.claimName} = "${stmt.text}"`);
     }
     execRenderCmd(stmt) {
-        // Compilar claims y renderizar
         const diags = (0, compiler_1.compileClaimsToTheory)(this.textLayer, this.theory);
         this.diagnostics.push(...diags);
         if (stmt.target === 'claims' || stmt.target === 'all') {
@@ -541,19 +997,15 @@ class Interpreter {
             for (const [name, claim] of this.theory.claims) {
                 const fStr = claim.formula ? (0, format_1.formulaToUnicode)(claim.formula) : '(sin fórmula)';
                 this.emit(`  Claim "${name}": ${fStr}`);
-                if (claim.support) {
+                if (claim.support)
                     this.emit(`    Soporte: ${claim.support}`);
-                }
-                if (claim.confidence !== undefined) {
+                if (claim.confidence !== undefined)
                     this.emit(`    Confianza: ${claim.confidence}`);
-                }
-                if (claim.context) {
+                if (claim.context)
                     this.emit(`    Contexto: ${claim.context}`);
-                }
             }
-            if (this.theory.claims.size === 0) {
+            if (this.theory.claims.size === 0)
                 this.emit('  (sin claims registrados)');
-            }
         }
         else if (stmt.target === 'theory') {
             this.emit(`── Render: theory (${stmt.format}) ──`);
@@ -569,7 +1021,6 @@ class Interpreter {
             this.emit(`  Claims: ${this.theory.claims.size}`);
         }
         else {
-            // Render un claim o axioma específico por nombre
             const axiom = this.theory.axioms.get(stmt.target);
             if (axiom) {
                 this.emit(`  ${stmt.target} = ${(0, format_1.formulaToUnicode)(axiom)}`);
@@ -592,7 +1043,6 @@ class Interpreter {
         const pStr = premises.map((p) => (0, format_1.formulaToUnicode)(p)).join(', ');
         const cStr = (0, format_1.formulaToUnicode)(conclusion);
         if (fallacies.length === 0) {
-            // Check if the inference is valid
             const conj = premises.length === 0
                 ? conclusion
                 : premises.length === 1
@@ -608,13 +1058,12 @@ class Interpreter {
                 this.emit(`⚠ [analyze] {${pStr}} → ${cStr}`);
                 this.emit('  Inferencia NO VÁLIDA — pero no corresponde a un patrón de falacia conocido');
             }
-            const result2 = {
+            this.results.push({
                 status: result.status,
                 output: result.output,
                 diagnostics: [],
                 formula: conclusion,
-            };
-            this.results.push(result2);
+            });
         }
         else {
             this.emit(`⚠ [analyze] {${pStr}} → ${cStr}`);
@@ -624,7 +1073,7 @@ class Interpreter {
                 if (f.pattern)
                     this.emit(`    Patrón: ${f.pattern}`);
             }
-            const result = {
+            this.results.push({
                 status: 'invalid',
                 output: `Falacias detectadas: ${fallacies.map((f) => f.name).join(', ')}`,
                 diagnostics: fallacies.map((f) => ({
@@ -632,17 +1081,14 @@ class Interpreter {
                     message: `Falacia: ${f.name} — ${f.description}`,
                 })),
                 formula: conclusion,
-            };
-            this.results.push(result);
+            });
         }
     }
     execProofBlock(stmt) {
         const profile = this.requireProfile();
-        // Guardar axiomas, letBindings y descriptions antes del bloque
         const savedAxioms = new Map(this.theory.axioms);
         const savedLetBindings = new Map(this.letBindings);
         const savedLetDescriptions = new Map(this.letDescriptions);
-        // Registrar las asunciones como axiomas temporales (con resolución de variables)
         this.emit('── Proof Block ──');
         for (const assumption of stmt.assumptions) {
             const resolved = this.resolveFormula(assumption.formula);
@@ -651,64 +1097,38 @@ class Interpreter {
         }
         const resolvedGoal = this.resolveFormula(stmt.goal);
         this.emit(`  show ${(0, format_1.formulaToUnicode)(resolvedGoal)}`);
-        // Ejecutar body statements
-        for (const bodyStmt of stmt.body) {
-            try {
-                this.executeStatement(bodyStmt);
-            }
-            catch (e) {
-                const message = e instanceof Error ? e.message : String(e);
-                this.diagnostics.push({
-                    severity: 'error',
-                    message,
-                    file: stmt.source.file,
-                    line: bodyStmt.source.line,
-                    column: bodyStmt.source.column,
-                });
-            }
-        }
-        // Verificar que el goal es derivable de las asunciones
+        this.executeStatementsIterative(stmt.body, stmt.source.file);
         const premiseNames = stmt.assumptions.map((a) => a.name);
         const result = profile.derive(resolvedGoal, premiseNames, this.theory);
         this.results.push(result);
         if (result.status === 'valid' || result.status === 'provable') {
             this.emit(`  ✓ QED — ${(0, format_1.formulaToUnicode)(resolvedGoal)} demostrado`);
-            // Registrar como teorema
             const theoremName = `proof_${this.theory.theorems.size + 1}`;
-            // La implicación assumptions -> goal es un teorema
             let implication = resolvedGoal;
             for (let i = stmt.assumptions.length - 1; i >= 0; i--) {
-                implication = {
-                    kind: 'implies',
-                    args: [stmt.assumptions[i].formula, implication],
-                };
+                implication = { kind: 'implies', args: [stmt.assumptions[i].formula, implication] };
             }
             this.theory.theorems.set(theoremName, implication);
         }
         else {
             this.emit(`  ✗ QED fallido — no se pudo demostrar ${(0, format_1.formulaToUnicode)(resolvedGoal)}`);
         }
-        // Restaurar axiomas, letBindings y descriptions (quitar las asunciones temporales)
         this.theory.axioms = savedAxioms;
         this.letBindings = savedLetBindings;
         this.letDescriptions = savedLetDescriptions;
+        this.invalidateResolveCache();
         this.emit('── End Proof Block ──');
     }
     execTheoryDecl(stmt) {
-        const theoryName = stmt.name;
-        // Si tiene parámetros, es una plantilla (Clase)
         if (stmt.params && stmt.params.length > 0) {
-            this.theoryTemplates.set(theoryName, { node: stmt, parent: stmt.parent });
-            this.emit(`Teoría (plantilla) ${theoryName}(${stmt.params.join(', ')}) declarada`);
+            this.theoryTemplates.set(stmt.name, { node: stmt, parent: stmt.parent });
+            this.emit(`Teoría (plantilla) ${stmt.name}(${stmt.params.join(', ')}) declarada`);
             return;
         }
-        // Si no tiene parámetros, ejecutar como singleton/objeto inmediato
         this.instantiateTheory(stmt);
     }
-    /** Crea una instancia de una teoría y la registra en this.theories */
     instantiateTheory(node, instanceName, args = []) {
         const theoryName = instanceName || node.name;
-        // Crear scope vacío
         const scope = {
             name: theoryName,
             parent: node.parent,
@@ -718,14 +1138,10 @@ class Interpreter {
             theorems: new Map(),
             privateMembers: new Set(),
         };
-        // HERENCIA: Si extends Parent, copiar bindings/axiomas/teoremas del padre
-        // El padre puede ser otra plantilla o un singleton ya instanciado
         if (node.parent) {
             const parentScope = this.theories.get(node.parent);
-            if (!parentScope) {
-                throw new Error(`Teoría padre '${node.parent}' no encontrada. Debe declararse antes de '${theoryName}'.`);
-            }
-            // Copiar todo del padre (no los miembros privados del padre al hijo)
+            if (!parentScope)
+                throw new Error(`Teoría padre '${node.parent}' no encontrada.`);
             for (const [k, v] of parentScope.letBindings)
                 if (!parentScope.privateMembers.has(k))
                     scope.letBindings.set(k, v);
@@ -739,13 +1155,11 @@ class Interpreter {
                 if (!parentScope.privateMembers.has(k))
                     scope.theorems.set(k, v);
         }
-        // Guardar estado global antes de entrar al scope de la teoría
         const savedLetBindings = new Map(this.letBindings);
         const savedLetDescriptions = new Map(this.letDescriptions);
         const savedAxioms = new Map(this.theory.axioms);
         const savedTheorems = new Map(this.theory.theorems);
         const savedTheoryName = this.currentTheoryName;
-        // Inyectar argumentos en el scope local de la teoría
         if (node.params && args.length > 0) {
             for (let i = 0; i < node.params.length; i++) {
                 if (i < args.length) {
@@ -755,7 +1169,6 @@ class Interpreter {
                 }
             }
         }
-        // Inyectar bindings heredados al scope local para que los statements internos los vean
         for (const [k, v] of scope.letBindings)
             this.letBindings.set(k, v);
         for (const [k, v] of scope.letDescriptions)
@@ -766,7 +1179,6 @@ class Interpreter {
             this.theory.theorems.set(k, v);
         this.currentTheoryName = theoryName;
         this.emit(`── Instanciando Theory ${theoryName} ──`);
-        // Ejecutar los miembros del body
         for (const member of node.members) {
             const memberStmt = member.statement;
             const memberName = 'name' in memberStmt ? memberStmt.name : null;
@@ -786,7 +1198,6 @@ class Interpreter {
                 });
             }
         }
-        // Capturar lo producido
         for (const [k, v] of this.letBindings)
             if (!savedLetBindings.has(k))
                 scope.letBindings.set(k, v);
@@ -799,292 +1210,383 @@ class Interpreter {
         for (const [k, v] of this.theory.theorems)
             if (!savedTheorems.has(k))
                 scope.theorems.set(k, v);
-        // Restaurar estado global
         this.letBindings = savedLetBindings;
         this.letDescriptions = savedLetDescriptions;
         this.theory.axioms = savedAxioms;
         this.theory.theorems = savedTheorems;
         this.currentTheoryName = savedTheoryName;
-        // Registrar la instancia
+        this.invalidateResolveCache();
         this.theories.set(theoryName, scope);
         this.emit(`── End Theory Instance ${theoryName} ──`);
         return theoryName;
     }
-    // =============================================
-    // Control flow & funciones (v1.5.8)
-    // =============================================
     execPrintCmd(stmt) {
-        if (stmt.value !== null) {
-            // String literal
+        if (stmt.value !== null)
             this.emit(stmt.value);
-        }
         else if (stmt.formula) {
-            const resolved = this.resolveFormula(stmt.formula);
+            // Resolve bindings but skip constant-folding so print shows symbolic form
+            const resolved = this.resolveFormulaRecursive(stmt.formula, new Set());
             this.emit((0, format_1.formulaToUnicode)(resolved));
         }
     }
     execSetCmd(stmt) {
-        const resolved = this.resolveFormula(stmt.formula);
-        this.letBindings.set(stmt.name, resolved);
-        // También actualizar en la teoría global para que derive/prove lo vean
-        this.theory.axioms.set(stmt.name, resolved);
-        this.emit(`Set ${stmt.name} = ${(0, format_1.formulaToUnicode)(resolved)}`);
+        const resolved = this.evaluateFormulaValue(stmt.formula);
+        this.setBinding(stmt.name, resolved);
+        if (!this.currentBindingFrame)
+            this.theory.axioms.set(stmt.name, resolved);
+        if (this.shouldEmitLocalBindings())
+            this.emit(`Set ${stmt.name} = ${(0, format_1.formulaToUnicode)(resolved)}`);
     }
     execIfStmt(stmt) {
-        const profile = this.requireProfile();
-        for (const branch of stmt.branches) {
-            const resolved = this.resolveFormula(branch.formula);
-            let matched;
-            if (branch.condition === 'valid' || branch.condition === 'invalid') {
-                const result = profile.checkValid(resolved);
-                matched =
-                    branch.condition === 'valid' ? result.status === 'valid' : result.status !== 'valid';
-            }
-            else {
-                // satisfiable / unsatisfiable
-                const result = profile.checkSatisfiable(resolved);
-                matched =
-                    branch.condition === 'satisfiable'
-                        ? result.status === 'satisfiable' || result.status === 'valid'
-                        : result.status === 'unsatisfiable';
-            }
-            if (matched) {
-                for (const bodyStmt of branch.body) {
-                    if (this.returnSignal)
-                        return;
-                    this.executeStatement(bodyStmt);
-                }
-                return; // solo ejecuta la primera rama que matchea
-            }
-        }
-        // else branch
-        if (stmt.elseBranch) {
-            for (const bodyStmt of stmt.elseBranch) {
-                if (this.returnSignal)
-                    return;
-                this.executeStatement(bodyStmt);
-            }
-        }
+        const selectedBody = this.selectIfBody(stmt);
+        if (selectedBody)
+            this.executeStatementsIterative(selectedBody, stmt.source.file);
     }
     execForStmt(stmt) {
-        const savedBinding = this.letBindings.get(stmt.variable);
-        for (const item of stmt.items) {
-            if (this.returnSignal)
-                break;
-            const resolved = this.resolveFormula(item);
-            this.letBindings.set(stmt.variable, resolved);
-            for (const bodyStmt of stmt.body) {
-                if (this.returnSignal)
-                    break;
-                this.executeStatement(bodyStmt);
-            }
-        }
-        // Restaurar binding previo
-        if (savedBinding !== undefined) {
-            this.letBindings.set(stmt.variable, savedBinding);
-        }
-        else {
-            this.letBindings.delete(stmt.variable);
-        }
+        this.executeStatementsIterative([stmt], stmt.source.file);
     }
     execWhileStmt(stmt) {
-        const profile = this.requireProfile();
-        const maxIter = stmt.maxIterations || 1000;
-        let iter = 0;
-        while (iter < maxIter) {
-            if (this.returnSignal)
-                break;
-            iter++;
-            const resolved = this.resolveFormula(stmt.formula);
-            let matched;
-            if (stmt.condition === 'valid' || stmt.condition === 'invalid') {
-                const result = profile.checkValid(resolved);
-                matched =
-                    stmt.condition === 'valid' ? result.status === 'valid' : result.status !== 'valid';
-            }
-            else {
-                const result = profile.checkSatisfiable(resolved);
-                matched =
-                    stmt.condition === 'satisfiable'
-                        ? result.status === 'satisfiable' || result.status === 'valid'
-                        : result.status === 'unsatisfiable';
-            }
-            if (!matched)
-                break;
-            for (const bodyStmt of stmt.body) {
-                if (this.returnSignal)
-                    break;
-                this.executeStatement(bodyStmt);
-            }
-        }
-        if (iter >= maxIter) {
-            this.diagnostics.push({
-                severity: 'warning',
-                message: `while: se alcanzó el límite de ${maxIter} iteraciones`,
-                file: stmt.source.file,
-                line: stmt.source.line,
-                column: stmt.source.column,
-            });
-        }
+        this.executeStatementsIterative([stmt], stmt.source.file);
     }
     execFnDecl(stmt) {
         const name = this.currentTheoryName ? `${this.currentTheoryName}.${stmt.name}` : stmt.name;
         this.functions.set(name, stmt);
-        if (this.currentTheoryName) {
+        if (this.currentTheoryName)
             this.emit(`Función de instancia ${name}(${stmt.params.join(', ')}) declarada`);
-        }
-        else {
+        else
             this.emit(`Función ${name}(${stmt.params.join(', ')}) declarada`);
-        }
     }
     execReturnStmt(stmt) {
-        if (stmt.formula) {
-            this.returnValue = this.resolveFormula(stmt.formula);
-        }
-        else {
+        if (stmt.formula)
+            this.returnValue = this.evaluateFormulaValue(stmt.formula);
+        else
             this.returnValue = undefined;
-        }
         this.returnSignal = true;
     }
     executeFnCall(stmt) {
-        // 0. Funciones Nativas (Built-ins) para Metaprogramación
-        if (['typeof', 'is_valid', 'is_satisfiable', 'get_atoms', 'input'].includes(stmt.name)) {
-            return this.executeBuiltin(stmt.name, stmt.args);
+        const initial = this.startFunctionFrame(stmt, undefined);
+        if ('result' in initial)
+            return initial.result;
+        const callStack = [initial.frame];
+        let finalResult = undefined;
+        while (callStack.length > 0) {
+            const frame = callStack[callStack.length - 1];
+            if (this.returnSignal) {
+                const result = this.finishFunctionFrame(frame);
+                callStack.pop();
+                if (frame.continuation)
+                    this.applyFunctionContinuation(frame.continuation, result);
+                else
+                    finalResult = result;
+                continue;
+            }
+            const nextStmt = this.nextRuntimeStatement(frame.runtimeStack);
+            if (!nextStmt) {
+                const result = this.finishFunctionFrame(frame);
+                callStack.pop();
+                if (frame.continuation)
+                    this.applyFunctionContinuation(frame.continuation, result);
+                else
+                    finalResult = result;
+                continue;
+            }
+            const nestedCall = this.getDirectFunctionCall(nextStmt);
+            if (nestedCall) {
+                if (nestedCall.type === 'return_stmt') {
+                    const replaced = this.replaceFunctionFrame(frame, nestedCall.call);
+                    if ('result' in replaced) {
+                        this.returnValue = replaced.result || { kind: 'atom', name: 'undefined' };
+                        this.returnSignal = true;
+                    }
+                    else {
+                        callStack[callStack.length - 1] = replaced.frame;
+                    }
+                    continue;
+                }
+                const started = this.startFunctionFrame(nestedCall.call, {
+                    type: nestedCall.type,
+                    stmt: nestedCall.stmt,
+                });
+                if ('result' in started)
+                    this.applyFunctionContinuation(started.resultContinuation, started.result);
+                else
+                    callStack.push(started.frame);
+                continue;
+            }
+            this.dispatchRuntimeStatement(nextStmt, frame.runtimeStack);
+        }
+        return finalResult;
+    }
+    startFunctionFrame(stmt, continuation, inheritedReturnState) {
+        this.callDepth++;
+        if (this.callDepth > MAX_CALL_DEPTH) {
+            this.callDepth--;
+            throw new Error(`Límite de recursión excedido (${MAX_CALL_DEPTH}).`);
+        }
+        this.runtimeCallCount++;
+        if (this.runtimeCallCount > this.getRuntimeCallLimit()) {
+            this.callDepth--;
+            throw new Error(`Límite de llamadas ST excedido (${this.getRuntimeCallLimit()}).`);
+        }
+        if ([
+            'typeof',
+            'is_valid',
+            'is_satisfiable',
+            'get_atoms',
+            'atoms_of',
+            'len',
+            'at',
+            'formula_eq',
+            'input',
+        ].includes(stmt.name)) {
+            const result = this.executeBuiltin(stmt.name, stmt.args);
+            this.callDepth--;
+            return { result, resultContinuation: continuation || { type: 'discard' } };
         }
-        // 0.5 Si es un método (obj.metodo), resolver el objeto primero
         if (stmt.name.includes('.')) {
             const [prefix, methodName] = stmt.name.split('.', 2);
             let actualInstanceName = prefix;
-            // Intentar resolver prefijo si es una variable local
-            if (this.letBindings.has(prefix)) {
-                const resolved = this.letBindings.get(prefix);
-                if (resolved.kind === 'atom' && resolved.name) {
+            if (this.hasBinding(prefix)) {
+                const resolved = this.getBinding(prefix);
+                if (resolved.kind === 'atom' && resolved.name)
                     actualInstanceName = resolved.name;
-                }
             }
             const scope = this.theories.get(actualInstanceName);
             if (scope) {
-                // En ST actual, las funciones no se guardan en TheoryScope sino que se ejecutan
-                // en el contexto del intérprete. Para soportar métodos de instancia,
-                // necesitamos que las funciones estén vinculadas al scope o prefijadas.
-                // Como solución rápida y potente: buscamos la función prefijada en el mapa global.
                 const internalFnName = `${actualInstanceName}.${methodName}`;
                 const fn = this.functions.get(internalFnName);
-                if (fn) {
-                    // Ejecutar función con el scope de la instancia inyectado
-                    return this.executeFunctionInScope(fn, stmt.args, scope);
-                }
+                if (fn)
+                    return {
+                        frame: this.createFunctionFrame(internalFnName, fn, stmt.args, continuation, scope, inheritedReturnState),
+                    };
             }
         }
-        // 1. Intentar instanciación de teoría (Clase)
         const template = this.theoryTemplates.get(stmt.name);
         if (template) {
-            // Nombre de instancia único si no estamos en un let (o usar un contador)
             const instanceId = `inst_${stmt.name}_${this.theories.size}`;
             this.instantiateTheory(template.node, instanceId, stmt.args);
-            return { kind: 'atom', name: instanceId };
+            this.callDepth--;
+            return {
+                result: { kind: 'atom', name: instanceId },
+                resultContinuation: continuation || { type: 'discard' },
+            };
         }
-        // 2. Intentar llamada a función normal
         const fn = this.functions.get(stmt.name);
         if (!fn) {
+            this.callDepth--;
             throw new Error(`Función o Teoría '${stmt.name}' no declarada`);
         }
-        if (stmt.args.length !== fn.params.length) {
-            throw new Error(`Función '${stmt.name}' espera ${fn.params.length} argumento(s), recibió ${stmt.args.length}`);
-        }
-        // Guardar bindings actuales de los parámetros
-        const savedBindings = new Map();
-        for (const param of fn.params) {
-            savedBindings.set(param, this.letBindings.get(param));
-        }
-        // Vincular argumentos a parámetros
+        return {
+            frame: this.createFunctionFrame(stmt.name, fn, stmt.args, continuation, undefined, inheritedReturnState),
+        };
+    }
+    createFunctionFrame(name, fn, args, continuation, scope, inheritedReturnState) {
+        if (args.length !== fn.params.length) {
+            this.callDepth--;
+            throw new Error(`Argumentos incorrectos.`);
+        }
+        let scopeSnapshot;
+        if (scope) {
+            scopeSnapshot = {
+                letBindings: new Map(this.letBindings),
+                axioms: new Map(this.theory.axioms),
+                theorems: new Map(this.theory.theorems),
+                theoryName: this.currentTheoryName,
+            };
+            for (const [key, value] of scope.letBindings)
+                this.letBindings.set(key, value);
+            for (const [key, value] of scope.axioms)
+                this.theory.axioms.set(key, value);
+            for (const [key, value] of scope.theorems)
+                this.theory.theorems.set(key, value);
+            this.currentTheoryName = scope.name;
+        }
+        const bindingFrame = this.createBindingFrame();
+        this.currentBindingFrame = bindingFrame;
         for (let i = 0; i < fn.params.length; i++) {
-            const resolved = this.resolveFormula(stmt.args[i]);
-            this.letBindings.set(fn.params[i], resolved);
+            this.currentBindingFrame.bindings.set(fn.params[i], this.evaluateFormulaValue(args[i]));
         }
-        // Ejecutar cuerpo de la función
-        const savedReturnSignal = this.returnSignal;
-        const savedReturnValue = this.returnValue;
+        const savedReturnSignal = inheritedReturnState?.signal ?? this.returnSignal;
+        const savedReturnValue = inheritedReturnState?.value ?? this.returnValue;
         this.returnSignal = false;
         this.returnValue = undefined;
-        for (const bodyStmt of fn.body) {
-            if (this.returnSignal)
-                break;
-            this.executeStatement(bodyStmt);
-        }
-        // Capturar valor de retorno
+        return {
+            name,
+            runtimeStack: [{ kind: 'statements', statements: fn.body, index: 0 }],
+            bindingFrame,
+            savedReturnSignal,
+            savedReturnValue,
+            scopeSnapshot,
+            continuation,
+        };
+    }
+    finishFunctionFrame(frame) {
         const result = this.returnValue;
-        this.returnSignal = savedReturnSignal;
-        this.returnValue = savedReturnValue;
-        // Restaurar bindings
-        for (const param of fn.params) {
-            const prev = savedBindings.get(param);
-            if (prev !== undefined) {
-                this.letBindings.set(param, prev);
+        this.returnSignal = frame.savedReturnSignal;
+        this.returnValue = frame.savedReturnValue;
+        this.discardFunctionFrameState(frame);
+        this.callDepth--;
+        return result;
+    }
+    discardFunctionFrameState(frame) {
+        this.currentBindingFrame = frame.bindingFrame.parent;
+        if (frame.scopeSnapshot) {
+            this.letBindings = frame.scopeSnapshot.letBindings;
+            this.theory.axioms = frame.scopeSnapshot.axioms;
+            this.theory.theorems = frame.scopeSnapshot.theorems;
+            this.currentTheoryName = frame.scopeSnapshot.theoryName;
+            this.invalidateResolveCache();
+        }
+    }
+    replaceFunctionFrame(frame, stmt) {
+        const inheritedReturnState = {
+            signal: frame.savedReturnSignal,
+            value: frame.savedReturnValue,
+        };
+        const inheritedContinuation = frame.continuation;
+        const evaluatedArgs = stmt.args.map((arg) => this.evaluateFormulaValue(arg));
+        this.discardFunctionFrameState(frame);
+        this.callDepth--;
+        const replaced = this.startFunctionFrame({ name: stmt.name, args: evaluatedArgs }, inheritedContinuation, inheritedReturnState);
+        if ('frame' in replaced)
+            return replaced;
+        return { result: replaced.result };
+    }
+    nextRuntimeStatement(runtimeStack) {
+        while (runtimeStack.length > 0) {
+            const frame = runtimeStack[runtimeStack.length - 1];
+            if (frame.kind === 'statements') {
+                if (frame.index >= frame.statements.length) {
+                    runtimeStack.pop();
+                    continue;
+                }
+                return frame.statements[frame.index++];
             }
-            else {
-                this.letBindings.delete(param);
+            if (frame.kind === 'for') {
+                if (this.returnSignal || frame.index >= frame.stmt.items.length) {
+                    this.restoreBindingSnapshot(frame.stmt.variable, frame.savedBinding);
+                    runtimeStack.pop();
+                    continue;
+                }
+                const resolved = this.evaluateFormulaValue(frame.stmt.items[frame.index]);
+                this.setBinding(frame.stmt.variable, resolved);
+                frame.index++;
+                runtimeStack.push({ kind: 'statements', statements: frame.stmt.body, index: 0 });
+                continue;
             }
+            if (this.returnSignal) {
+                runtimeStack.pop();
+                continue;
+            }
+            const profile = this.requireProfile();
+            const maxIter = frame.stmt.maxIterations || 1000;
+            if (frame.iterations >= maxIter) {
+                this.diagnostics.push({
+                    severity: 'warning',
+                    message: `while: se alcanzó el límite de ${maxIter} iteraciones`,
+                    file: frame.stmt.source.file,
+                    line: frame.stmt.source.line,
+                    column: frame.stmt.source.column,
+                });
+                runtimeStack.pop();
+                continue;
+            }
+            const resolved = this.evaluateFormulaValue(frame.stmt.formula);
+            const matched = this.matchesRuntimeCondition(profile, frame.stmt.condition, resolved);
+            if (!matched) {
+                runtimeStack.pop();
+                continue;
+            }
+            frame.iterations++;
+            runtimeStack.push({ kind: 'statements', statements: frame.stmt.body, index: 0 });
         }
-        return result;
+        return undefined;
     }
-    /** Ejecuta una función inyectando bindings de un scope (para métodos de instancia) */
     executeFunctionInScope(fn, args, scope) {
-        if (args.length !== fn.params.length) {
-            throw new Error(`Método '${fn.name}' espera ${fn.params.length} argumento(s), recibió ${args.length}`);
+        this.callDepth++;
+        if (this.callDepth > MAX_CALL_DEPTH) {
+            this.callDepth--;
+            throw new Error(`Límite de recursión excedido.`);
         }
-        // 1. Guardar estado global
-        const savedBindings = new Map(this.letBindings);
-        const savedAxioms = new Map(this.theory.axioms);
-        const savedTheorems = new Map(this.theory.theorems);
-        const savedTheoryName = this.currentTheoryName;
-        // 2. Inyectar scope de la instancia
-        for (const [k, v] of scope.letBindings)
-            this.letBindings.set(k, v);
-        for (const [k, v] of scope.axioms)
-            this.theory.axioms.set(k, v);
-        for (const [k, v] of scope.theorems)
-            this.theory.theorems.set(k, v);
-        this.currentTheoryName = scope.name;
-        // 3. Inyectar argumentos de la llamada
-        for (let i = 0; i < fn.params.length; i++) {
-            this.letBindings.set(fn.params[i], this.resolveFormula(args[i]));
+        try {
+            const savedBindings = new Map(this.letBindings);
+            const savedAxioms = new Map(this.theory.axioms);
+            const savedTheorems = new Map(this.theory.theorems);
+            const savedTheoryName = this.currentTheoryName;
+            for (const [k, v] of scope.letBindings)
+                this.letBindings.set(k, v);
+            for (const [k, v] of scope.axioms)
+                this.theory.axioms.set(k, v);
+            for (const [k, v] of scope.theorems)
+                this.theory.theorems.set(k, v);
+            this.currentTheoryName = scope.name;
+            for (let i = 0; i < fn.params.length; i++)
+                this.letBindings.set(fn.params[i], this.resolveFormula(args[i]));
+            const savedReturnSignal = this.returnSignal;
+            const savedReturnValue = this.returnValue;
+            this.returnSignal = false;
+            this.returnValue = undefined;
+            for (const bodyStmt of fn.body) {
+                if (this.returnSignal)
+                    break;
+                this.executeStatement(bodyStmt);
+            }
+            const result = this.returnValue;
+            this.returnSignal = savedReturnSignal;
+            this.returnValue = savedReturnValue;
+            this.letBindings = savedBindings;
+            this.theory.axioms = savedAxioms;
+            this.theory.theorems = savedTheorems;
+            this.currentTheoryName = savedTheoryName;
+            return result;
+        }
+        finally {
+            this.callDepth--;
         }
-        // 4. Ejecutar cuerpo
-        const savedReturnSignal = this.returnSignal;
-        const savedReturnValue = this.returnValue;
-        this.returnSignal = false;
-        this.returnValue = undefined;
-        for (const bodyStmt of fn.body) {
-            if (this.returnSignal)
-                break;
-            this.executeStatement(bodyStmt);
+    }
+    tryConstantFold(f) {
+        if (!f || !f.args)
+            return f;
+        const ARITH_OPS = {
+            add: (a, b) => a + b,
+            subtract: (a, b) => a - b,
+            multiply: (a, b) => a * b,
+            divide: (a, b) => a / b,
+            modulo: (a, b) => a % b,
+        };
+        // Note: comparison operators (less, greater, etc.) are NOT folded here.
+        // They must retain their structural form so profiles can evaluate them properly.
+        const newArgs = f.args.map((a) => this.tryConstantFold(a));
+        if (newArgs.length === 2 &&
+            newArgs[0].kind === 'number' &&
+            newArgs[1].kind === 'number' &&
+            ARITH_OPS[f.kind]) {
+            // Don't fold division/modulo by zero — preserve structure for checkWellFormed
+            if ((f.kind === 'divide' || f.kind === 'modulo') && (newArgs[1].value ?? 0) === 0) {
+                return { ...f, args: newArgs };
+            }
+            const op = ARITH_OPS[f.kind];
+            const res = op(newArgs[0].value ?? 0, newArgs[1].value ?? 0);
+            return { kind: 'number', value: res, source: f.source };
         }
-        const result = this.returnValue;
-        // 5. Restaurar estado global
-        this.returnSignal = savedReturnSignal;
-        this.returnValue = savedReturnValue;
-        this.letBindings = savedBindings;
-        this.theory.axioms = savedAxioms;
-        this.theory.theorems = savedTheorems;
-        this.currentTheoryName = savedTheoryName;
-        return result;
+        return { ...f, args: newArgs };
     }
     executeBuiltin(name, args) {
-        if (args.length !== 1) {
-            throw new Error(`Built-in '${name}' espera exactamente 1 argumento, recibió ${args.length}`);
-        }
-        const arg = this.resolveFormula(args[0]);
+        const arg = args[0] ? this.resolveFormula(args[0]) : undefined;
         if (name === 'typeof') {
             let typeStr = 'Formula';
-            if (arg.kind === 'number')
+            if (arg?.kind === 'number')
                 typeStr = 'Number';
-            if (arg.kind === 'atom' && arg.name?.startsWith('"'))
+            if (arg?.kind === 'list')
+                typeStr = 'List';
+            if (arg?.kind === 'atom' && arg.name?.startsWith('"'))
                 typeStr = 'String';
-            return { kind: 'atom', name: `"${typeStr}"`, source: arg.source };
+            return { kind: 'atom', name: `"${typeStr}"`, source: arg?.source };
         }
         if (name === 'is_valid' || name === 'is_satisfiable') {
             const profile = this.requireProfile();
+            if (!arg)
+                return { kind: 'atom', name: '"Error"' };
             try {
                 const result = name === 'is_valid' ? profile.checkValid(arg) : profile.checkSatisfiable(arg);
                 const isTrue = result.status === 'valid' || result.status === 'satisfiable';
@@ -1095,22 +1597,67 @@ class Interpreter {
             }
         }
         if (name === 'get_atoms') {
+            if (!arg)
+                return { kind: 'atom', name: '"{ }"' };
             const atoms = this.collectAtoms(arg);
             return { kind: 'atom', name: `"{ ${atoms.join(', ')} }"`, source: arg.source };
         }
+        if (name === 'atoms_of') {
+            const source = arg?.source;
+            const items = (arg ? this.collectValueAtoms(arg) : []).map((atomName) => ({
+                kind: 'atom',
+                name: atomName,
+                source,
+            }));
+            return { kind: 'list', args: items, source };
+        }
+        if (name === 'len') {
+            if (arg?.kind === 'list') {
+                return { kind: 'number', value: arg.args?.length ?? 0, source: arg.source };
+            }
+            if (arg?.kind === 'atom' && arg.name?.startsWith('"')) {
+                return {
+                    kind: 'number',
+                    value: arg.name.replace(/(^"|"$)/g, '').length,
+                    source: arg.source,
+                };
+            }
+            return { kind: 'number', value: 0, source: arg?.source };
+        }
+        if (name === 'at') {
+            const listArg = arg;
+            const indexArg = args[1] ? this.resolveFormula(args[1]) : undefined;
+            if (listArg?.kind === 'list' && indexArg?.kind === 'number') {
+                const index = Math.floor(indexArg.value ?? -1);
+                return listArg.args?.[index] || { kind: 'atom', name: 'undefined', source: listArg.source };
+            }
+            return { kind: 'atom', name: 'undefined', source: listArg?.source || indexArg?.source };
+        }
+        if (name === 'formula_eq') {
+            const left = arg;
+            const right = args[1] ? this.resolveFormula(args[1]) : undefined;
+            const equal = !!left && !!right && (0, propositional_1.formulaToString)(left) === (0, propositional_1.formulaToString)(right);
+            return {
+                kind: 'number',
+                value: equal ? 1 : 0,
+                source: left?.source || right?.source,
+            };
+        }
         if (name === 'input') {
+            if (!arg)
+                return { kind: 'atom', name: '""' };
             const prompt = arg.kind === 'atom' && arg.name?.startsWith('"')
                 ? arg.name.replace(/(^"|"$)/g, '')
                 : (0, propositional_1.formulaToString)(arg);
             let inputStr;
             try {
                 process.stdout.write(prompt + ' ');
-                /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-argument */
+                // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment
                 const fs = require('fs');
                 const buf = Buffer.alloc(256);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
                 const bytesRead = fs.readSync(process.stdin.fd, buf, 0, 256, null);
                 inputStr = buf.toString('utf8', 0, bytesRead).trim();
-                /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-argument */
             }
             catch {
                 inputStr = 'interactive_not_supported';
@@ -1119,70 +1666,238 @@ class Interpreter {
         }
         return undefined;
     }
+    executeActionExpr(action) {
+        const profile = this.requireProfile();
+        switch (action.action) {
+            case 'check_valid': {
+                const formula = this.resolveFormula(action.formula);
+                return {
+                    result: profile.checkValid(formula),
+                    primary: formula,
+                    formulas: [formula],
+                    extraBindings: [],
+                };
+            }
+            case 'check_satisfiable': {
+                const formula = this.resolveFormula(action.formula);
+                return {
+                    result: profile.checkSatisfiable(formula),
+                    primary: formula,
+                    formulas: [formula],
+                    extraBindings: [],
+                };
+            }
+            case 'check_equivalent': {
+                if (!profile.checkEquivalent) {
+                    throw new Error('Este perfil no soporta check equivalent');
+                }
+                const left = this.resolveFormula(action.left);
+                const right = this.resolveFormula(action.right);
+                const comparison = {
+                    kind: 'biconditional',
+                    args: [left, right],
+                    source: action.source,
+                };
+                return {
+                    result: profile.checkEquivalent(left, right),
+                    primary: comparison,
+                    formulas: [left, right],
+                    extraBindings: [
+                        ['left', left],
+                        ['right', right],
+                        [
+                            'equivalent',
+                            {
+                                kind: 'number',
+                                value: (0, propositional_1.formulaToString)(left) === (0, propositional_1.formulaToString)(right) ? 1 : 0,
+                                source: action.source,
+                            },
+                        ],
+                    ],
+                };
+            }
+            case 'derive': {
+                const goal = this.resolveFormula(action.goal);
+                const premises = action.premises || [];
+                const result = profile.derive(goal, premises, this.theory);
+                const premiseFormulas = premises
+                    .map((premise) => this.theory.axioms.get(premise) || this.theory.theorems.get(premise))
+                    .filter((value) => !!value)
+                    .map((formula) => this.resolveFormula(formula));
+                return {
+                    result,
+                    primary: result.formula || goal,
+                    formulas: [goal, ...premiseFormulas],
+                    extraBindings: [
+                        ['goal', goal],
+                        ['premises', this.createListFormula(premiseFormulas, action.source)],
+                        ['premise_names', this.createStringListFormula(premises, action.source)],
+                    ],
+                };
+            }
+            case 'prove': {
+                const goal = this.resolveFormula(action.goal);
+                const premises = action.premises || [];
+                const result = profile.prove(goal, this.theory);
+                const premiseFormulas = premises
+                    .map((premise) => this.theory.axioms.get(premise) || this.theory.theorems.get(premise))
+                    .filter((value) => !!value)
+                    .map((formula) => this.resolveFormula(formula));
+                return {
+                    result,
+                    primary: result.formula || goal,
+                    formulas: [goal, ...premiseFormulas],
+                    extraBindings: [
+                        ['goal', goal],
+                        ['premises', this.createListFormula(premiseFormulas, action.source)],
+                        ['premise_names', this.createStringListFormula(premises, action.source)],
+                    ],
+                };
+            }
+            case 'countermodel': {
+                const formula = this.resolveFormula(action.formula);
+                const result = profile.countermodel(formula);
+                return {
+                    result,
+                    primary: result.formula || formula,
+                    formulas: [formula],
+                    extraBindings: [
+                        [
+                            'has_countermodel',
+                            { kind: 'number', value: result.model ? 1 : 0, source: action.source },
+                        ],
+                    ],
+                };
+            }
+            case 'truth_table': {
+                if (!profile.truthTable) {
+                    throw new Error('Este perfil no soporta truth_table');
+                }
+                const formula = this.resolveFormula(action.formula);
+                const tt = profile.truthTable(formula);
+                const result = {
+                    status: tt.isTautology ? 'valid' : tt.isSatisfiable ? 'satisfiable' : 'unsatisfiable',
+                    output: this.formatTruthTable(formula, tt),
+                    truthTable: tt,
+                    diagnostics: [],
+                    formula,
+                };
+                return {
+                    result,
+                    primary: formula,
+                    formulas: [formula],
+                    extraBindings: [
+                        ['variables', this.createAtomListFormula(tt.variables, action.source)],
+                        ['rows_count', { kind: 'number', value: tt.rows.length, source: action.source }],
+                        [
+                            'satisfying_count',
+                            { kind: 'number', value: tt.satisfyingCount ?? 0, source: action.source },
+                        ],
+                    ],
+                };
+            }
+            case 'explain': {
+                const formula = this.resolveFormula(action.formula);
+                return {
+                    result: profile.explain(formula),
+                    primary: formula,
+                    formulas: [formula],
+                    extraBindings: [],
+                };
+            }
+        }
+    }
+    bindCapturedAction(baseName, actionName, primary, result, formulas, extraBindings) {
+        this.defineBinding(baseName, primary);
+        this.defineBinding(`${baseName}.formula`, primary);
+        this.defineBinding(`${baseName}.status`, this.createStringFormula(result.status, primary.source));
+        this.defineBinding(`${baseName}.output`, this.createStringFormula(result.output || '', primary.source));
+        this.defineBinding(`${baseName}.ok`, {
+            kind: 'number',
+            value: this.isSuccessfulStatus(result.status) ? 1 : 0,
+            source: primary.source,
+        });
+        this.defineBinding(`${baseName}.command`, this.createStringFormula(actionName, primary.source));
+        this.defineBinding(`${baseName}.formulas`, this.createListFormula(formulas, primary.source));
+        this.defineBinding(`${baseName}.diagnostics`, this.createStringListFormula(result.diagnostics.map((diag) => diag.message), primary.source));
+        for (const [suffix, value] of extraBindings) {
+            this.defineBinding(`${baseName}.${suffix}`, value);
+        }
+    }
+    createStringFormula(value, source) {
+        return {
+            kind: 'atom',
+            name: `"${value.replace(/"/g, '\\"')}"`,
+            source,
+        };
+    }
+    createListFormula(items, source) {
+        return { kind: 'list', args: items, source };
+    }
+    createAtomListFormula(items, source) {
+        return this.createListFormula(items.map((item) => ({ kind: 'atom', name: item, source })), source);
+    }
+    createStringListFormula(items, source) {
+        return this.createListFormula(items.map((item) => this.createStringFormula(item, source)), source);
+    }
+    isSuccessfulStatus(status) {
+        return status === 'valid' || status === 'satisfiable' || status === 'provable';
+    }
+    collectValueAtoms(formula) {
+        const seen = new Set();
+        const walk = (value) => {
+            if (value.kind === 'atom' && value.name && !value.name.startsWith('"')) {
+                seen.add(value.name);
+                return;
+            }
+            for (const arg of value.args || []) {
+                walk(arg);
+            }
+        };
+        walk(formula);
+        return Array.from(seen);
+    }
     execImportDecl(stmt) {
         let filePath = stmt.path;
-        // Agregar extensión .st si no la tiene
         if (!filePath.endsWith('.st'))
             filePath += '.st';
-        // Evitar imports circulares
-        if (this.importedFiles.has(filePath)) {
-            this.emit(`Import: ${filePath} (ya importado, saltar)`);
+        if (this.importedFiles.has(filePath))
             return;
-        }
         this.importedFiles.add(filePath);
-        // Intentar leer el archivo (solo funciona en Node.js / CLI)
         let source;
         try {
-            /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call */
+            // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment
             const fs = require('fs');
+            // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment
             const path = require('path');
-            // Resolver relativo al archivo actual si no es absoluto
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
             const resolved = path.isAbsolute(filePath)
                 ? filePath
-                : path.resolve(path.dirname(stmt.source.file || '.'), filePath);
+                : // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+                    path.resolve(path.dirname(stmt.source.file || '.'), filePath);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
             source = fs.readFileSync(resolved, 'utf-8');
-            /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call */
         }
         catch {
-            throw new Error(`No se pudo importar '${filePath}': archivo no encontrado`);
+            throw new Error(`No se pudo importar '${filePath}'`);
         }
         const parser = new parser_1.Parser(filePath);
         const program = parser.parse(source);
         this.diagnostics.push(...parser.diagnostics);
-        if (parser.diagnostics.some((d) => d.severity === 'error')) {
-            throw new Error(`Errores de parseo en '${filePath}'`);
-        }
-        // Guardar estado de exportación del importador
         const prevIsImporting = this.isImporting;
-        const prevExportedBindings = new Map(this.exportedBindings);
-        const prevExportedAxioms = new Map(this.exportedAxioms);
-        const prevExportedTheorems = new Map(this.exportedTheorems);
-        const prevExportedFunctions = new Map(this.exportedFunctions);
-        const prevExportedTheories = new Map(this.exportedTheories);
-        // Guardar scope local actual del importador para no contaminarlo durante la carga
         const prevLetBindings = new Map(this.letBindings);
         const prevAxioms = new Map(this.theory.axioms);
         const prevTheorems = new Map(this.theory.theorems);
         const prevFunctions = new Map(this.functions);
         const prevTheories = new Map(this.theories);
-        // Limpiar para capturar solo lo que exporta el archivo importado
         this.isImporting = true;
-        this.exportedBindings.clear();
-        this.exportedAxioms.clear();
-        this.exportedTheorems.clear();
-        this.exportedFunctions.clear();
-        this.exportedTheories.clear();
-        // No queremos que el archivo importado vea el scope del importador (encapsulamiento total)
         this.letBindings.clear();
         this.theory.axioms.clear();
         this.theory.theorems.clear();
         this.functions.clear();
         this.theories.clear();
-        // Ejecutar statements del archivo importado
-        for (const importedStmt of program.statements) {
+        for (const importedStmt of program.statements)
             this.executeStatement(importedStmt);
-        }
-        // Capturar lo exportado
         const newExports = {
             bindings: new Map(this.exportedBindings),
             axioms: new Map(this.exportedAxioms),
@@ -1190,19 +1905,12 @@ class Interpreter {
             functions: new Map(this.exportedFunctions),
             theories: new Map(this.exportedTheories),
         };
-        // Restaurar estado del importador (incluyendo su scope original)
         this.isImporting = prevIsImporting;
-        this.exportedBindings = prevExportedBindings;
-        this.exportedAxioms = prevExportedAxioms;
-        this.exportedTheorems = prevExportedTheorems;
-        this.exportedFunctions = prevExportedFunctions;
-        this.exportedTheories = prevExportedTheories;
         this.letBindings = prevLetBindings;
         this.theory.axioms = prevAxioms;
         this.theory.theorems = prevTheorems;
         this.functions = prevFunctions;
         this.theories = prevTheories;
-        // Fusionar solo lo exportado al scope actual
         for (const [k, v] of newExports.bindings)
             this.letBindings.set(k, v);
         for (const [k, v] of newExports.axioms)
@@ -1213,7 +1921,6 @@ class Interpreter {
             this.functions.set(k, v);
         for (const [k, v] of newExports.theories)
             this.theories.set(k, v);
-        this.emit(`Import: ${filePath} cargado (${newExports.bindings.size + newExports.axioms.size + newExports.theorems.size + newExports.functions.size + newExports.theories.size} elementos importados)`);
     }
     execExplainCmd(stmt) {
         const profile = this.requireProfile();
@@ -1223,160 +1930,39 @@ class Interpreter {
         if (result.output)
             this.emit(result.output);
     }
-    // --- Output helpers ---
     emit(msg) {
         this.stdoutLines.push(msg);
     }
     getVerbosity() {
-        const v = this.letBindings.get('verbose');
-        if (v && v.kind === 'atom' && v.name) {
-            const n = v.name.toLowerCase();
-            // Remove quotes if present
-            return n.replace(/(^"|"$)/g, '');
-        }
+        const v = this.getBinding('verbose');
+        if (v && v.kind === 'atom' && v.name)
+            return v.name.toLowerCase().replace(/(^"|"$)/g, '');
         return 'off';
     }
     emitResult(cmd, result) {
-        const statusIcon = this.statusIcon(result.status);
-        this.emit(`${statusIcon} [${cmd}] ${result.output || result.status}`);
+        this.emit(`${this.statusIcon(result.status)} [${cmd}] ${result.output || result.status}`);
         const verbosity = this.getVerbosity();
-        if (result.educationalNote && verbosity === 'on') {
-            this.emit(`  Nota pedagógica: ${result.educationalNote}`);
-        }
-        if (result.paradoxWarning) {
+        if (result.paradoxWarning)
             this.emit(`  ⚠ PARADOJA: ${result.paradoxWarning}`);
-        }
-        // Clasificación de la fórmula (si tenemos verbosidad on o si está precalculado)
         if (result.formula && (verbosity === 'on' || result.formulaClassification)) {
             const cls = (0, formula_classifier_1.classifyFormula)(result.formula);
             const name = result.formulaClassification || cls.formulaClassification;
-            if (name) {
+            if (name)
                 this.emit(`  Identificación: ${name}`);
-            }
         }
-        if (result.reasoningType) {
-            this.emit(`  Patrón de razonamiento: ${result.reasoningType}`);
-        }
-        if (result.reasoningSchema) {
-            this.emit(`  Esquema: ${result.reasoningSchema}`);
-        }
-        if (result.normalForms && verbosity === 'on') {
-            this.emit(`  Formas Normales:`);
-            if (result.normalForms.nnf)
-                this.emit(`    NNF: ${result.normalForms.nnf}`);
-            if (result.normalForms.cnf)
-                this.emit(`    CNF: ${result.normalForms.cnf}`);
-            if (result.normalForms.dnf)
-                this.emit(`    DNF: ${result.normalForms.dnf}`);
-            if (result.normalForms.pnf)
-                this.emit(`    PNF: ${result.normalForms.pnf}`);
-            if (result.normalForms.skolem)
-                this.emit(`    Skolem: ${result.normalForms.skolem}`);
-        }
-        if (result.formula && (verbosity === 'on' || cmd === 'explain')) {
-            /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
-            const { compareAcrossSystems } = require('./cross-system-compare');
-            const { registry } = require('../profiles/interface');
-            const comp = result.crossSystemComparison || compareAcrossSystems(result.formula, registry);
-            /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
-            if (Object.keys(comp).length > 0) {
-                this.emit(`  Comparación entre sistemas:`);
-                for (const [sys, val] of Object.entries(comp)) {
-                    this.emit(`    ${sys.padEnd(30)} ${val}`);
-                }
-            }
-        }
-        const outputFormatRaw = this.letBindings.get('output');
-        const isLatex = outputFormatRaw?.kind === 'atom' &&
-            outputFormatRaw.name?.replace(/['"]/g, '').toLowerCase() === 'latex';
-        const proof = result.proof;
-        if (proof &&
-            proof.steps.length > 0 &&
-            (verbosity === 'on' || verbosity === 'proof' || cmd === 'derive' || cmd === 'prove')) {
-            if (isLatex) {
-                /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
-                const { proofToLaTeX } = require('./format');
-                this.emit('  Prueba (LaTeX):');
-                this.emit(proofToLaTeX(proof));
-                /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
-            }
-            else {
-                this.emit('  Prueba:');
-                for (const step of proof.steps) {
-                    const premisesStr = step.premises.length > 0 ? ` [de ${step.premises.join(', ')}]` : '';
-                    this.emit(`    ${step.stepNumber}. ${(0, format_1.formulaToUnicode)(step.formula)}  — ${step.justification}${premisesStr}`);
-                }
+        if (result.model && (verbosity === 'on' || cmd === 'countermodel')) {
+            if (result.model.valuation) {
+                this.emit('  Modelo:');
+                for (const [k, v] of Object.entries(result.model.valuation))
+                    this.emit(`    ${k} = ${v}`);
             }
         }
-        const model = result.model;
-        if (model &&
-            (verbosity === 'on' ||
-                verbosity === 'model' ||
-                cmd === 'countermodel' ||
-                cmd === 'check_valid' ||
-                cmd === 'check_satisfiable')) {
-            // Display Kripke model with worlds if available
-            if (model.worlds && model.worlds.length > 0) {
-                this.emit('  Contramodelo Kripke:');
-                this.emit(`    Mundos: {${model.worlds.map((w) => w.name).join(', ')}}`);
-                this.emit('    Accesibilidad:');
-                for (const w of model.worlds) {
-                    if (w.accessible.length > 0) {
-                        this.emit(`      ${w.name} R ${w.accessible.join(', ')}`);
-                    }
-                }
-                this.emit('    Valuación:');
-                for (const w of model.worlds) {
-                    const trueAtoms = Object.entries(w.valuation)
-                        .filter(([, val]) => val)
-                        .map(([k]) => k);
-                    const falseAtoms = Object.entries(w.valuation)
-                        .filter(([, val]) => !val)
-                        .map(([k]) => k);
-                    const parts = [];
-                    if (trueAtoms.length > 0)
-                        parts.push(trueAtoms.join(', '));
-                    if (falseAtoms.length > 0)
-                        parts.push(`¬${falseAtoms.join(', ¬')}`);
-                    this.emit(`      V(${w.name}) = {${parts.join(', ')}}`);
-                }
-            }
-            else if (model.valuation) {
-                // Flat propositional model
-                this.emit('  Modelo / Valuación:');
-                for (const [k, v] of Object.entries(model.valuation)) {
-                    const desc = this.letDescriptions.get(k);
-                    const descStr = desc ? ` ("${desc}")` : '';
-                    this.emit(`    ${k}${descStr} = ${String(v)}`);
-                }
-            }
-        }
-        if (result.tableauTrace &&
-            result.tableauTrace.length > 0 &&
-            (verbosity === 'on' ||
-                verbosity === 'proof' ||
-                cmd === 'check valid' ||
-                cmd === 'check satisfiable' ||
-                cmd === 'check equivalent')) {
+        if (result.tableauTrace && result.tableauTrace.length > 0 && verbosity === 'on') {
             this.emit('  Traza del tableau:');
-            for (let i = 0; i < result.tableauTrace.length; i++) {
-                const step = result.tableauTrace[i];
-                this.emit(`    ${i + 1}. ${step.toString ? step.toString() : String(step)}`);
-            }
-        }
-        // Mostrar leyenda de variables con descripción si hay alguna relevante
-        if (this.letDescriptions.size > 0 && result.formula) {
-            const atoms = this.collectAtoms(result.formula);
-            const relevantDescs = atoms.filter((a) => this.letDescriptions.has(a));
-            if (relevantDescs.length > 0) {
-                this.emit('  Donde:');
-                for (const a of relevantDescs) {
-                    this.emit(`    ${a} = "${this.letDescriptions.get(a)}"`);
-                }
-            }
+            for (let i = 0; i < result.tableauTrace.length; i++)
+                this.emit(`    ${i + 1}. ${String(result.tableauTrace[i])}`);
         }
     }
-    /** Recolecta nombres de átomos únicos de una fórmula */
     collectAtoms(f, seen = new Set()) {
         if (!f)
             return [];
@@ -1385,108 +1971,30 @@ class Interpreter {
             return [f.name];
         }
         const result = [];
-        if (f.args) {
-            for (const arg of f.args) {
+        if (f.args)
+            for (const arg of f.args)
                 result.push(...this.collectAtoms(arg, seen));
-            }
-        }
         return result;
     }
     statusIcon(status) {
         switch (status) {
             case 'valid':
+            case 'provable':
                 return '✓';
             case 'invalid':
+            case 'refutable':
                 return '✗';
             case 'satisfiable':
                 return '◎';
             case 'unsatisfiable':
                 return '⊘';
-            case 'provable':
-                return '✓';
-            case 'refutable':
-                return '✗';
-            case 'unknown':
-                return '?';
-            case 'error':
-                return '⚠';
             default:
                 return '•';
         }
     }
-    formatTruthTable(formula, tt) {
-        const verbosity = this.getVerbosity();
-        const isVerbose = verbosity === 'on' || verbosity === 'model';
-        const lines = [];
-        // Detect Belnap (4-valued) table: results are strings like 'T','F','B','N'
-        const isBelnap = tt.rows.length > 0 &&
-            typeof tt.rows[0].result === 'string' &&
-            ['T', 'F', 'B', 'N'].includes(String(tt.rows[0].result));
-        if (isBelnap) {
-            lines.push(`Tabla de verdad Belnap (4 valores) para: ${(0, propositional_1.formulaToString)(formula)}`);
-            lines.push('');
-        }
-        // Header
-        const colLabels = [...tt.variables];
-        if (isVerbose && tt.subFormulas) {
-            tt.subFormulas.forEach((sf) => colLabels.push(sf.label));
-        }
-        colLabels.push((0, propositional_1.formulaToString)(formula));
-        const colWidths = colLabels.map((h) => Math.max(h.length, 5));
-        lines.push(colLabels.map((h, i) => h.padEnd(colWidths[i])).join(' | '));
-        lines.push(colWidths.map((w) => '-'.repeat(w)).join('-+-'));
-        // Rows
-        const designated = new Set(['T', 'B']);
-        for (let rowIndex = 0; rowIndex < tt.rows.length; rowIndex++) {
-            const row = tt.rows[rowIndex];
-            const vals = tt.variables.map((v) => {
-                const val = row.valuation[v];
-                if (typeof val === 'string')
-                    return val;
-                return val ? 'T' : 'F';
-            });
-            if (isVerbose && tt.subFormulas && tt.subFormulaValues) {
-                const subVals = tt.subFormulaValues[rowIndex];
-                tt.subFormulas.forEach((sf) => {
-                    let v = subVals[sf.label];
-                    if (typeof v === 'boolean')
-                        v = v ? 'T' : 'F';
-                    vals.push(String(v));
-                });
-            }
-            let finalVal = row.result;
-            if (typeof finalVal === 'boolean')
-                finalVal = finalVal ? 'T' : 'F';
-            vals.push(String(finalVal));
-            const isCountermodel = (tt.isTautology === false && !row.result) || (tt.isSatisfiable && row.result);
-            const rowStr = vals.map((v, i) => v.padEnd(colWidths[i])).join(' | ');
-            // Belnap designation marker
-            if (isBelnap && designated.has(String(finalVal))) {
-                lines.push(`${rowStr}   ⊛ Designado`);
-            }
-            else if (isVerbose && isCountermodel) {
-                lines.push(`${rowStr}   ←`);
-            }
-            else {
-                lines.push(rowStr);
-            }
-        }
-        lines.push('');
-        if (tt.satisfyingCount !== undefined && tt.totalCount !== undefined) {
-            lines.push(`${tt.satisfyingCount}/${tt.totalCount} valuaciones verdaderas`);
-        }
-        if (isBelnap) {
-            lines.push('Valores designados (portadores de verdad): {T, B}');
-        }
-        if (tt.isTautology)
-            lines.push('→ Tautologia ✓');
-        else if (tt.isContradiction)
-            lines.push('→ Contradiccion ✗');
-        else
-            lines.push('→ Contingente (satisfacible)');
-        return lines.join('\n');
+    formatTruthTable(formula, _tt) {
+        return `Tabla de verdad para ${(0, propositional_1.formulaToString)(formula)}`;
     }
-    // Getters para el estado (usados por REPL)
     getTheory() {
         return this.theory;
     }
@@ -1496,9 +2004,6 @@ class Interpreter {
     getTextLayer() {
         return this.textLayer;
     }
-    getLetDescriptions() {
-        return this.letDescriptions;
-    }
     getLetBindings() {
         return this.letBindings;
     }