@stevenvo780/st-lang 2.6.1 → 2.7.1

package/dist/runtime/interpreter.js

@@ -7,13 +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 MAX_CALL_DEPTH = 500;
+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;
@@ -43,6 +47,12 @@ class Interpreter {
     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)();
@@ -50,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',
@@ -93,12 +113,133 @@ 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 = [];
-        const parser = new parser_1.Parser(file);
+        this.runtimeStepCount = 0;
+        this.runtimeCallCount = 0;
+        // Pre-scan for profile declarations to enable profile-aware lexing.
+        // Only restrict keywords when there's exactly one profile in the source.
+        // Multi-profile files use all keywords for safety.
+        const profileMatches = source.match(/(?:^|\n)\s*(?:logic|logica)\s+([\w.]+)/g);
+        let detectedProfile;
+        if (profileMatches && profileMatches.length === 1) {
+            const m = profileMatches[0].match(/(?:logic|logica)\s+([\w.]+)/);
+            detectedProfile = m ? m[1] : undefined;
+        }
+        const parser = new parser_1.Parser(file, detectedProfile);
         const program = parser.parse(source);
         this.diagnostics.push(...parser.diagnostics);
         if (parser.diagnostics.some((d) => d.severity === 'error')) {
@@ -113,21 +254,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'),
@@ -148,6 +275,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: '',
@@ -157,18 +286,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
@@ -264,9 +382,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) {
@@ -302,21 +679,43 @@ 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);
-        return this.tryConstantFold(resolved);
+        // 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 = new Set()) {
+    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)
-                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) {
                         const actualInstanceName = resolvedPrefix.name;
                         const scope = this.theories.get(actualInstanceName);
@@ -324,12 +723,12 @@ class Interpreter {
                             if (scope.privateMembers.has(memberName) &&
                                 this.currentTheoryName !== actualInstanceName)
                                 return f;
-                            if (scope.letBindings.has(memberName))
-                                return this.resolveFormulaRecursive(scope.letBindings.get(memberName), new Set(visited));
-                            if (scope.axioms.has(memberName))
-                                return this.resolveFormulaRecursive(scope.axioms.get(memberName), new Set(visited));
-                            if (scope.theorems.has(memberName))
-                                return this.resolveFormulaRecursive(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);
+                            }
                         }
                     }
                 }
@@ -338,37 +737,31 @@ class Interpreter {
                 if (scope) {
                     if (scope.privateMembers.has(memberName) && this.currentTheoryName !== prefix)
                         return f;
-                    if (scope.letBindings.has(memberName))
-                        return this.resolveFormulaRecursive(scope.letBindings.get(memberName), new Set(visited));
-                    if (scope.axioms.has(memberName))
-                        return this.resolveFormulaRecursive(scope.axioms.get(memberName), new Set(visited));
-                    if (scope.theorems.has(memberName))
-                        return this.resolveFormulaRecursive(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;
-                const newVisited = new Set(visited);
-                newVisited.add(f.name);
-                return this.resolveFormulaRecursive(this.letBindings.get(f.name), newVisited);
-            }
             // También resolver axiomas/teoremas del theory actual por nombre
             if (this.theory.axioms.has(f.name)) {
                 if (visited.has(f.name))
                     return f;
-                const newVisited = new Set(visited);
-                newVisited.add(f.name);
-                return this.resolveFormulaRecursive(this.theory.axioms.get(f.name), newVisited);
+                visited.add(f.name);
+                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;
-                const newVisited = new Set(visited);
-                newVisited.add(f.name);
-                return this.resolveFormulaRecursive(this.theory.theorems.get(f.name), newVisited);
+                visited.add(f.name);
+                const result = this.resolveFormulaRecursive(this.theory.theorems.get(f.name), visited);
+                visited.delete(f.name);
+                return result;
             }
         }
         // Llamada a función como expresión
@@ -378,8 +771,16 @@ class Interpreter {
         }
         // Recorrer hijos recursivamente
         if (f.args && f.args.length > 0) {
-            const newArgs = f.args.map((a) => a ? this.resolveFormulaRecursive(a, new Set(visited)) : a);
-            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;
     }
@@ -456,10 +857,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',
@@ -485,19 +936,37 @@ class Interpreter {
             this.emit(`Formalizacion ${stmt.name}: ${stmt.passageName} -> ${(0, propositional_1.formulaToString)(formula)}`);
         }
         else if (stmt.letType === 'description') {
-            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) {
-            const resolved = this.resolveFormula(stmt.formula);
-            this.letBindings.set(stmt.name, resolved);
-            this.theory.axioms.set(stmt.name, resolved);
+            // 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)}`);
             }
         }
     }
@@ -637,21 +1106,7 @@ class Interpreter {
         }
         const resolvedGoal = this.resolveFormula(stmt.goal);
         this.emit(`  show ${(0, format_1.formulaToUnicode)(resolvedGoal)}`);
-        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,
-                });
-            }
-        }
+        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);
@@ -670,6 +1125,7 @@ class Interpreter {
         this.theory.axioms = savedAxioms;
         this.letBindings = savedLetBindings;
         this.letDescriptions = savedLetDescriptions;
+        this.invalidateResolveCache();
         this.emit('── End Proof Block ──');
     }
     execTheoryDecl(stmt) {
@@ -768,6 +1224,7 @@ class Interpreter {
         this.theory.axioms = savedAxioms;
         this.theory.theorems = savedTheorems;
         this.currentTheoryName = savedTheoryName;
+        this.invalidateResolveCache();
         this.theories.set(theoryName, scope);
         this.emit(`── End Theory Instance ${theoryName} ──`);
         return theoryName;
@@ -776,107 +1233,29 @@ class Interpreter {
         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);
-        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 {
-                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;
-            }
-        }
-        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);
-            }
-        }
-        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;
@@ -888,77 +1267,249 @@ class Interpreter {
     }
     execReturnStmt(stmt) {
         if (stmt.formula)
-            this.returnValue = this.resolveFormula(stmt.formula);
+            this.returnValue = this.evaluateFormulaValue(stmt.formula);
         else
             this.returnValue = undefined;
         this.returnSignal = true;
     }
     executeFnCall(stmt) {
+        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}).`);
         }
-        try {
-            if (['typeof', 'is_valid', 'is_satisfiable', 'get_atoms', 'input'].includes(stmt.name)) {
-                return this.executeBuiltin(stmt.name, stmt.args);
+        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' } };
+        }
+        if (stmt.name.includes('.')) {
+            const [prefix, methodName] = stmt.name.split('.', 2);
+            let actualInstanceName = prefix;
+            if (this.hasBinding(prefix)) {
+                const resolved = this.getBinding(prefix);
+                if (resolved.kind === 'atom' && resolved.name)
+                    actualInstanceName = resolved.name;
             }
-            if (stmt.name.includes('.')) {
-                const [prefix, methodName] = stmt.name.split('.', 2);
-                let actualInstanceName = prefix;
-                if (this.letBindings.has(prefix)) {
-                    const resolved = this.letBindings.get(prefix);
-                    if (resolved.kind === 'atom' && resolved.name)
-                        actualInstanceName = resolved.name;
+            const scope = this.theories.get(actualInstanceName);
+            if (scope) {
+                const internalFnName = `${actualInstanceName}.${methodName}`;
+                const fn = this.functions.get(internalFnName);
+                if (fn)
+                    return {
+                        frame: this.createFunctionFrame(internalFnName, fn, stmt.args, continuation, scope, inheritedReturnState),
+                    };
+            }
+        }
+        const template = this.theoryTemplates.get(stmt.name);
+        if (template) {
+            const instanceId = `inst_${stmt.name}_${this.theories.size}`;
+            this.instantiateTheory(template.node, instanceId, stmt.args);
+            this.callDepth--;
+            return {
+                result: { kind: 'atom', name: instanceId },
+                resultContinuation: continuation || { type: 'discard' },
+            };
+        }
+        const fn = this.functions.get(stmt.name);
+        if (!fn) {
+            this.callDepth--;
+            throw new Error(`Función o Teoría '${stmt.name}' no declarada`);
+        }
+        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++) {
+            this.currentBindingFrame.bindings.set(fn.params[i], this.evaluateFormulaValue(args[i]));
+        }
+        const savedReturnSignal = inheritedReturnState?.signal ?? this.returnSignal;
+        const savedReturnValue = inheritedReturnState?.value ?? this.returnValue;
+        this.returnSignal = false;
+        this.returnValue = undefined;
+        return {
+            name,
+            runtimeStack: [{ kind: 'statements', statements: fn.body, index: 0 }],
+            bindingFrame,
+            savedReturnSignal,
+            savedReturnValue,
+            scopeSnapshot,
+            continuation,
+        };
+    }
+    finishFunctionFrame(frame) {
+        const result = this.returnValue;
+        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;
                 }
-                const scope = this.theories.get(actualInstanceName);
-                if (scope) {
-                    const internalFnName = `${actualInstanceName}.${methodName}`;
-                    const fn = this.functions.get(internalFnName);
-                    if (fn)
-                        return this.executeFunctionInScope(fn, stmt.args, scope);
+                return frame.statements[frame.index++];
+            }
+            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;
             }
-            const template = this.theoryTemplates.get(stmt.name);
-            if (template) {
-                const instanceId = `inst_${stmt.name}_${this.theories.size}`;
-                this.instantiateTheory(template.node, instanceId, stmt.args);
-                return { kind: 'atom', name: instanceId };
+            if (this.returnSignal) {
+                runtimeStack.pop();
+                continue;
             }
-            const fn = this.functions.get(stmt.name);
-            if (!fn)
-                throw new Error(`Función o Teoría '${stmt.name}' no declarada`);
-            if (stmt.args.length !== fn.params.length)
-                throw new Error(`Argumentos incorrectos.`);
-            const savedBindings = new Map();
-            for (const param of fn.params)
-                savedBindings.set(param, this.letBindings.get(param));
-            for (let i = 0; i < fn.params.length; i++)
-                this.letBindings.set(fn.params[i], this.resolveFormula(stmt.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 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 result = this.returnValue;
-            this.returnSignal = savedReturnSignal;
-            this.returnValue = savedReturnValue;
-            for (const param of fn.params) {
-                const prev = savedBindings.get(param);
-                if (prev !== undefined)
-                    this.letBindings.set(param, prev);
-                else
-                    this.letBindings.delete(param);
+            const resolved = this.evaluateFormulaValue(frame.stmt.formula);
+            const matched = this.matchesRuntimeCondition(profile, frame.stmt.condition, resolved);
+            if (!matched) {
+                runtimeStack.pop();
+                continue;
             }
-            return result;
-        }
-        finally {
-            this.callDepth--;
+            frame.iterations++;
+            runtimeStack.push({ kind: 'statements', statements: frame.stmt.body, index: 0 });
         }
+        return undefined;
     }
     executeFunctionInScope(fn, args, scope) {
         this.callDepth++;
@@ -1009,38 +1560,42 @@ class Interpreter {
             add: (a, b) => a + b,
             subtract: (a, b) => a - b,
             multiply: (a, b) => a * b,
-            divide: (a, b) => (b === 0 ? NaN : a / b),
-            modulo: (a, b) => (b === 0 ? NaN : a % b),
-        };
-        const CMP_OPS = {
-            less: (a, b) => (a < b ? 1 : 0),
-            greater: (a, b) => (a > b ? 1 : 0),
-            less_eq: (a, b) => (a <= b ? 1 : 0),
-            greater_eq: (a, b) => (a >= b ? 1 : 0),
+            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] || CMP_OPS[f.kind])) {
-            const op = ARITH_OPS[f.kind] || CMP_OPS[f.kind];
+            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 };
         }
         return { ...f, args: newArgs };
     }
     executeBuiltin(name, args) {
-        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';
@@ -1051,10 +1606,55 @@ 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);
@@ -1075,6 +1675,197 @@ 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;
         if (!filePath.endsWith('.st'))
@@ -1152,7 +1943,7 @@ class Interpreter {
         this.stdoutLines.push(msg);
     }
     getVerbosity() {
-        const v = this.letBindings.get('verbose');
+        const v = this.getBinding('verbose');
         if (v && v.kind === 'atom' && v.name)
             return v.name.toLowerCase().replace(/(^"|"$)/g, '');
         return 'off';
@@ -1197,8 +1988,10 @@ class Interpreter {
     statusIcon(status) {
         switch (status) {
             case 'valid':
+            case 'provable':
                 return '✓';
             case 'invalid':
+            case 'refutable':
                 return '✗';
             case 'satisfiable':
                 return '◎';