@polintpro/proposit-core 0.5.1 → 0.5.3

package/dist/lib/core/argument-engine.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { isClaimBound, isPremiseBound, } from "../schemata/index.js";
 import { DEFAULT_CHECKSUM_CONFIG } from "../consts.js";
 import { getOrCreate, sortedUnique } from "../utils/collections.js";
 import { ChangeCollector } from "./change-collector.js";
@@ -7,7 +8,6 @@ import { kleeneAnd, kleeneNot } from "./evaluation/kleene.js";
 import { makeErrorIssue, makeValidationResult, } from "./evaluation/validation.js";
 import { PremiseEngine } from "./premise-engine.js";
 import { VariableManager } from "./variable-manager.js";
-import { SourceManager } from "./source-manager.js";
 /**
  * Manages a propositional logic argument composed of premises, variable
  * assignments, and logical roles (supporting premises and a conclusion).
@@ -19,9 +19,9 @@ export class ArgumentEngine {
     argument;
     premises;
     variables;
-    sourceManager;
-    assertionLibrary;
+    claimLibrary;
     sourceLibrary;
+    claimSourceLibrary;
     conclusionPremiseId;
     checksumConfig;
     positionConfig;
@@ -33,15 +33,15 @@ export class ArgumentEngine {
         argument: true,
         variables: true,
         roles: true,
-        sources: true,
         premiseIds: new Set(),
         allPremises: true,
     };
     cachedReactiveSnapshot;
-    constructor(argument, assertionLibrary, sourceLibrary, options) {
+    constructor(argument, claimLibrary, sourceLibrary, claimSourceLibrary, options) {
         this.argument = { ...argument };
-        this.assertionLibrary = assertionLibrary;
+        this.claimLibrary = claimLibrary;
         this.sourceLibrary = sourceLibrary;
+        this.claimSourceLibrary = claimSourceLibrary;
         this.premises = new Map();
         this.checksumConfig = options?.checksumConfig;
         this.positionConfig = options?.positionConfig;
@@ -49,10 +49,54 @@ export class ArgumentEngine {
             checksumConfig: this.checksumConfig,
             positionConfig: this.positionConfig,
         });
-        this.sourceManager = new SourceManager();
         this.expressionIndex = new Map();
         this.conclusionPremiseId = undefined;
     }
+    createCircularityCheck() {
+        return (variableId, targetPremiseId) => {
+            return this.wouldCreateCycle(variableId, targetPremiseId, new Set());
+        };
+    }
+    wouldCreateCycle(variableId, targetPremiseId, visited) {
+        const variable = this.variables.getVariable(variableId);
+        if (!variable)
+            return false;
+        if (!isPremiseBound(variable))
+            return false;
+        const bound = variable;
+        if (bound.boundPremiseId === targetPremiseId)
+            return true;
+        if (visited.size >= this.premises.size) {
+            throw new Error(`Circularity check depth limit exceeded (visited ${visited.size} premises).`);
+        }
+        if (visited.has(bound.boundPremiseId))
+            return false;
+        visited.add(bound.boundPremiseId);
+        const boundPremise = this.premises.get(bound.boundPremiseId);
+        if (!boundPremise)
+            return false;
+        for (const expr of boundPremise.getExpressions()) {
+            if (expr.type === "variable") {
+                if (this.wouldCreateCycle(expr.variableId, targetPremiseId, visited)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    wireCircularityCheck(pm) {
+        pm.setCircularityCheck(this.createCircularityCheck());
+    }
+    wireEmptyBoundPremiseCheck(pm) {
+        pm.setEmptyBoundPremiseCheck((variableId) => {
+            const v = this.variables.getVariable(variableId);
+            if (!v ||
+                !isPremiseBound(v))
+                return false;
+            const boundPremise = this.premises.get(v.boundPremiseId);
+            return !boundPremise?.getRootExpressionId();
+        });
+    }
     subscribe = (listener) => {
         this.listeners.add(listener);
         return () => {
@@ -74,7 +118,6 @@ export class ArgumentEngine {
             !dirty.argument &&
             !dirty.variables &&
             !dirty.roles &&
-            !dirty.sources &&
             dirty.premiseIds.size === 0 &&
             !dirty.allPremises) {
             return prev;
@@ -113,36 +156,17 @@ export class ArgumentEngine {
                 }
             }
         }
-        let varAssocRecord;
-        let exprAssocRecord;
-        if (dirty.sources || !prev) {
-            varAssocRecord = {};
-            for (const a of this.sourceManager.getAllVariableSourceAssociations()) {
-                varAssocRecord[a.id] = a;
-            }
-            exprAssocRecord = {};
-            for (const a of this.sourceManager.getAllExpressionSourceAssociations()) {
-                exprAssocRecord[a.id] = a;
-            }
-        }
-        else {
-            varAssocRecord = prev.variableSourceAssociations;
-            exprAssocRecord = prev.expressionSourceAssociations;
-        }
         const snapshot = {
             argument,
             variables,
             premises,
             roles,
-            variableSourceAssociations: varAssocRecord,
-            expressionSourceAssociations: exprAssocRecord,
         };
         this.cachedReactiveSnapshot = snapshot;
         this.reactiveDirty = {
             argument: false,
             variables: false,
             roles: false,
-            sources: false,
             premiseIds: new Set(),
             allPremises: false,
         };
@@ -202,10 +226,6 @@ export class ArgumentEngine {
                 this.reactiveDirty.premiseIds.add(p.id);
             }
         }
-        if (changes.variableSourceAssociations ||
-            changes.expressionSourceAssociations) {
-            this.reactiveDirty.sources = true;
-        }
     }
     getArgument() {
         return { ...this.argument, checksum: this.checksum() };
@@ -249,12 +269,13 @@ export class ArgumentEngine {
             argument: this.argument,
             variables: this.variables,
             expressionIndex: this.expressionIndex,
-            sourceManager: this.sourceManager,
         }, {
             checksumConfig: this.checksumConfig,
             positionConfig: this.positionConfig,
         });
         this.premises.set(id, pm);
+        this.wireCircularityCheck(pm);
+        this.wireEmptyBoundPremiseCheck(pm);
         pm.setOnMutate(() => {
             this.reactiveDirty.premiseIds.add(id);
             this.notifySubscribers();
@@ -280,13 +301,9 @@ export class ArgumentEngine {
             return { result: undefined, changes: {} };
         const data = pm.toPremiseData();
         const collector = new ChangeCollector();
-        // Clean up expression index and source associations for removed premise's expressions
+        // Clean up expression index for removed premise's expressions
         for (const expr of pm.getExpressions()) {
             this.expressionIndex.delete(expr.id);
-            const sourceResult = this.sourceManager.removeAssociationsForExpression(expr.id);
-            for (const assoc of sourceResult.removedExpressionAssociations) {
-                collector.removedExpressionSourceAssociation(assoc);
-            }
         }
         this.premises.delete(premiseId);
         collector.removedPremise(data);
@@ -294,6 +311,21 @@ export class ArgumentEngine {
             this.conclusionPremiseId = undefined;
             collector.setRoles(this.getRoleState());
         }
+        // Cascade: remove variables bound to the deleted premise
+        const boundVars = this.getVariablesBoundToPremise(premiseId);
+        for (const v of boundVars) {
+            const removeResult = this.removeVariable(v.id);
+            if (removeResult.changes.variables) {
+                for (const rv of removeResult.changes.variables.removed) {
+                    collector.removedVariable(rv);
+                }
+            }
+            if (removeResult.changes.expressions) {
+                for (const re of removeResult.changes.expressions.removed) {
+                    collector.removedExpression(re);
+                }
+            }
+        }
         this.markDirty();
         const changes = collector.toChangeset();
         this.markReactiveDirty(changes);
@@ -318,17 +350,53 @@ export class ArgumentEngine {
             .filter((pm) => pm !== undefined);
     }
     addVariable(variable) {
+        // Only claim-bound variables may be added via addVariable.
+        // Premise-bound variables must use bindVariableToPremise.
+        if (!isClaimBound(variable)) {
+            throw new Error("addVariable only accepts claim-bound variables. Use bindVariableToPremise for premise-bound variables.");
+        }
         if (variable.argumentId !== this.argument.id) {
             throw new Error(`Variable argumentId "${variable.argumentId}" does not match engine argument ID "${this.argument.id}".`);
         }
         if (variable.argumentVersion !== this.argument.version) {
             throw new Error(`Variable argumentVersion "${variable.argumentVersion}" does not match engine argument version "${this.argument.version}".`);
         }
-        // Validate assertion reference
-        if (!this.assertionLibrary.get(variable.assertionId, variable.assertionVersion)) {
-            throw new Error(`Assertion "${variable.assertionId}" version ${variable.assertionVersion} does not exist in the assertion library.`);
+        // Validate claim reference
+        if (!this.claimLibrary.get(variable.claimId, variable.claimVersion)) {
+            throw new Error(`Claim "${variable.claimId}" version ${variable.claimVersion} does not exist in the claim library.`);
         }
-        const withChecksum = this.attachVariableChecksum({ ...variable });
+        const withChecksum = this.attachVariableChecksum({
+            ...variable,
+        });
+        this.variables.addVariable(withChecksum);
+        const collector = new ChangeCollector();
+        collector.addedVariable(withChecksum);
+        this.markDirty();
+        this.markAllPremisesDirty();
+        const changes = collector.toChangeset();
+        this.markReactiveDirty(changes);
+        this.notifySubscribers();
+        return {
+            result: withChecksum,
+            changes,
+        };
+    }
+    bindVariableToPremise(variable) {
+        if (variable.argumentId !== this.argument.id) {
+            throw new Error(`Variable argumentId "${variable.argumentId}" does not match engine argument ID "${this.argument.id}".`);
+        }
+        if (variable.argumentVersion !== this.argument.version) {
+            throw new Error(`Variable argumentVersion "${variable.argumentVersion}" does not match engine argument version "${this.argument.version}".`);
+        }
+        if (variable.boundArgumentId !== this.argument.id) {
+            throw new Error(`Cross-argument bindings are not supported. boundArgumentId "${variable.boundArgumentId}" does not match engine argument ID "${this.argument.id}".`);
+        }
+        if (!this.premises.has(variable.boundPremiseId)) {
+            throw new Error(`Bound premise "${variable.boundPremiseId}" does not exist in this argument.`);
+        }
+        const withChecksum = this.attachVariableChecksum({
+            ...variable,
+        });
         this.variables.addVariable(withChecksum);
         const collector = new ChangeCollector();
         collector.addedVariable(withChecksum);
@@ -343,16 +411,50 @@ export class ArgumentEngine {
         };
     }
     updateVariable(variableId, updates) {
-        // Validate: assertionId and assertionVersion must be provided together
-        const hasAssertionId = updates.assertionId !== undefined;
-        const hasAssertionVersion = updates.assertionVersion !== undefined;
-        if (hasAssertionId !== hasAssertionVersion) {
-            throw new Error("assertionId and assertionVersion must be provided together.");
-        }
-        // Validate assertion reference if provided
-        if (hasAssertionId && hasAssertionVersion) {
-            if (!this.assertionLibrary.get(updates.assertionId, updates.assertionVersion)) {
-                throw new Error(`Assertion "${updates.assertionId}" version ${updates.assertionVersion} does not exist in the assertion library.`);
+        const existing = this.variables.getVariable(variableId);
+        if (!existing) {
+            return { result: undefined, changes: {} };
+        }
+        const existingVar = existing;
+        const updatesObj = updates;
+        // Reject binding-type conversion
+        if (isClaimBound(existingVar)) {
+            const premiseBoundFields = [
+                "boundPremiseId",
+                "boundArgumentId",
+                "boundArgumentVersion",
+            ];
+            for (const f of premiseBoundFields) {
+                if (updatesObj[f] !== undefined) {
+                    throw new Error(`Cannot set "${f}" on a claim-bound variable. Delete and re-create to change binding type.`);
+                }
+            }
+            // Validate: claimId and claimVersion must be provided together
+            const hasClaimId = updatesObj.claimId !== undefined;
+            const hasClaimVersion = updatesObj.claimVersion !== undefined;
+            if (hasClaimId !== hasClaimVersion) {
+                throw new Error("claimId and claimVersion must be provided together.");
+            }
+            // Validate claim reference if provided
+            if (hasClaimId && hasClaimVersion) {
+                if (!this.claimLibrary.get(updatesObj.claimId, updatesObj.claimVersion)) {
+                    throw new Error(`Claim "${String(updatesObj.claimId)}" version ${String(updatesObj.claimVersion)} does not exist in the claim library.`);
+                }
+            }
+        }
+        else if (isPremiseBound(existingVar)) {
+            const claimBoundFields = ["claimId", "claimVersion"];
+            for (const f of claimBoundFields) {
+                if (updatesObj[f] !== undefined) {
+                    throw new Error(`Cannot set "${f}" on a premise-bound variable. Delete and re-create to change binding type.`);
+                }
+            }
+            // Validate boundPremiseId if provided
+            if (updatesObj.boundPremiseId !== undefined) {
+                const newPremiseId = updatesObj.boundPremiseId;
+                if (!this.premises.has(newPremiseId)) {
+                    throw new Error(`Bound premise "${newPremiseId}" does not exist in this argument.`);
+                }
             }
         }
         const updated = this.variables.updateVariable(variableId, updates);
@@ -386,8 +488,6 @@ export class ArgumentEngine {
         }
         const collector = new ChangeCollector();
         // Cascade: delete referencing expressions in every premise
-        // (PremiseEngine.removeExpression already cascades expression-source
-        //  associations via the Task 12 logic)
         for (const pm of this.listPremises()) {
             const { changes } = pm.deleteExpressionsUsingVariable(variableId);
             if (changes.expressions) {
@@ -395,16 +495,6 @@ export class ArgumentEngine {
                     collector.removedExpression(e);
                 }
             }
-            if (changes.expressionSourceAssociations) {
-                for (const a of changes.expressionSourceAssociations.removed) {
-                    collector.removedExpressionSourceAssociation(a);
-                }
-            }
-        }
-        // Cascade: remove variable-source associations
-        const varAssocResult = this.sourceManager.removeAssociationsForVariable(variableId);
-        for (const assoc of varAssocResult.removedVariableAssociations) {
-            collector.removedVariableSourceAssociation(assoc);
         }
         this.variables.removeVariable(variableId);
         collector.removedVariable(variable);
@@ -437,6 +527,12 @@ export class ArgumentEngine {
         }
         return map;
     }
+    getVariablesBoundToPremise(premiseId) {
+        return this.variables.toArray().filter((v) => {
+            const base = v;
+            return isPremiseBound(base) && base.boundPremiseId === premiseId;
+        });
+    }
     getExpression(expressionId) {
         const premiseId = this.expressionIndex.get(expressionId);
         if (premiseId === undefined)
@@ -534,129 +630,6 @@ export class ArgumentEngine {
     listSupportingPremises() {
         return this.listPremises().filter((pm) => pm.isInference() && pm.getId() !== this.conclusionPremiseId);
     }
-    // -------------------------------------------------------------------------
-    // Source association management
-    // -------------------------------------------------------------------------
-    addVariableSourceAssociation(sourceId, sourceVersion, variableId) {
-        if (!this.sourceLibrary.get(sourceId, sourceVersion)) {
-            throw new Error(`Source "${sourceId}" version ${sourceVersion} does not exist in the source library.`);
-        }
-        if (!this.variables.hasVariable(variableId)) {
-            throw new Error(`Variable "${variableId}" does not exist.`);
-        }
-        const assoc = {
-            id: randomUUID(),
-            sourceId,
-            sourceVersion,
-            variableId,
-            argumentId: this.argument.id,
-            argumentVersion: this.argument.version,
-            checksum: "",
-        };
-        const fields = this.checksumConfig?.variableSourceAssociationFields ??
-            DEFAULT_CHECKSUM_CONFIG.variableSourceAssociationFields;
-        const assocWithChecksum = {
-            ...assoc,
-            checksum: entityChecksum(assoc, fields),
-        };
-        this.sourceManager.addVariableSourceAssociation(assocWithChecksum);
-        const collector = new ChangeCollector();
-        collector.addedVariableSourceAssociation(assocWithChecksum);
-        this.markDirty();
-        const changes = collector.toChangeset();
-        this.markReactiveDirty(changes);
-        this.notifySubscribers();
-        return { result: assocWithChecksum, changes };
-    }
-    removeVariableSourceAssociation(associationId) {
-        const allVarAssocs = this.sourceManager.getAllVariableSourceAssociations();
-        if (!allVarAssocs.some((a) => a.id === associationId)) {
-            return { result: undefined, changes: {} };
-        }
-        const removalResult = this.sourceManager.removeVariableSourceAssociation(associationId);
-        const collector = new ChangeCollector();
-        for (const assoc of removalResult.removedVariableAssociations) {
-            collector.removedVariableSourceAssociation(assoc);
-        }
-        this.markDirty();
-        const changes = collector.toChangeset();
-        this.markReactiveDirty(changes);
-        this.notifySubscribers();
-        return {
-            result: removalResult.removedVariableAssociations[0],
-            changes,
-        };
-    }
-    addExpressionSourceAssociation(sourceId, sourceVersion, expressionId, premiseId) {
-        if (!this.sourceLibrary.get(sourceId, sourceVersion)) {
-            throw new Error(`Source "${sourceId}" version ${sourceVersion} does not exist in the source library.`);
-        }
-        const pm = this.premises.get(premiseId);
-        if (!pm) {
-            throw new Error(`Premise "${premiseId}" does not exist.`);
-        }
-        if (!pm.getExpression(expressionId)) {
-            throw new Error(`Expression "${expressionId}" does not exist in premise "${premiseId}".`);
-        }
-        const assoc = {
-            id: randomUUID(),
-            sourceId,
-            sourceVersion,
-            expressionId,
-            premiseId,
-            argumentId: this.argument.id,
-            argumentVersion: this.argument.version,
-            checksum: "",
-        };
-        const fields = this.checksumConfig?.expressionSourceAssociationFields ??
-            DEFAULT_CHECKSUM_CONFIG.expressionSourceAssociationFields;
-        const assocWithChecksum = {
-            ...assoc,
-            checksum: entityChecksum(assoc, fields),
-        };
-        this.sourceManager.addExpressionSourceAssociation(assocWithChecksum);
-        const collector = new ChangeCollector();
-        collector.addedExpressionSourceAssociation(assocWithChecksum);
-        this.markDirty();
-        const changes = collector.toChangeset();
-        this.markReactiveDirty(changes);
-        this.notifySubscribers();
-        return { result: assocWithChecksum, changes };
-    }
-    removeExpressionSourceAssociation(associationId) {
-        const allExprAssocs = this.sourceManager.getAllExpressionSourceAssociations();
-        if (!allExprAssocs.some((a) => a.id === associationId)) {
-            return { result: undefined, changes: {} };
-        }
-        const removalResult = this.sourceManager.removeExpressionSourceAssociation(associationId);
-        const collector = new ChangeCollector();
-        for (const assoc of removalResult.removedExpressionAssociations) {
-            collector.removedExpressionSourceAssociation(assoc);
-        }
-        this.markDirty();
-        const changes = collector.toChangeset();
-        this.markReactiveDirty(changes);
-        this.notifySubscribers();
-        return {
-            result: removalResult.removedExpressionAssociations[0],
-            changes,
-        };
-    }
-    getAssociationsForSource(sourceId) {
-        return this.sourceManager.getAssociationsForSource(sourceId);
-    }
-    getAssociationsForVariable(variableId) {
-        return this.sourceManager.getAssociationsForVariable(variableId);
-    }
-    getAssociationsForExpression(expressionId) {
-        return this.sourceManager.getAssociationsForExpression(expressionId);
-    }
-    getAllVariableSourceAssociations() {
-        return this.sourceManager.getAllVariableSourceAssociations();
-    }
-    getAllExpressionSourceAssociations() {
-        return this.sourceManager.getAllExpressionSourceAssociations();
-    }
     snapshot() {
         return {
             argument: { ...this.argument },
@@ -669,30 +642,34 @@ export class ArgumentEngine {
                 checksumConfig: this.checksumConfig,
                 positionConfig: this.positionConfig,
             },
-            sources: this.sourceManager.snapshot(),
         };
     }
     /** Creates a new ArgumentEngine from a previously captured snapshot. */
-    static fromSnapshot(snapshot, assertionLibrary, sourceLibrary) {
-        const engine = new ArgumentEngine(snapshot.argument, assertionLibrary, sourceLibrary, snapshot.config);
-        // Restore variables
-        for (const v of snapshot.variables.variables) {
-            engine.addVariable(v);
-        }
-        // Restore source manager (before premises, so PremiseEngines get the correct reference)
-        if (snapshot.sources) {
-            engine.sourceManager = SourceManager.fromSnapshot(snapshot.sources);
-        }
-        // Restore premises using PremiseEngine.fromSnapshot
+    static fromSnapshot(snapshot, claimLibrary, sourceLibrary, claimSourceLibrary) {
+        const engine = new ArgumentEngine(snapshot.argument, claimLibrary, sourceLibrary, claimSourceLibrary, snapshot.config);
+        // Restore premises first (premise-bound variables reference them)
         for (const premiseSnap of snapshot.premises) {
-            const pe = PremiseEngine.fromSnapshot(premiseSnap, snapshot.argument, engine.variables, engine.expressionIndex, engine.sourceManager);
+            const pe = PremiseEngine.fromSnapshot(premiseSnap, snapshot.argument, engine.variables, engine.expressionIndex);
             engine.premises.set(pe.getId(), pe);
+            engine.wireCircularityCheck(pe);
+            engine.wireEmptyBoundPremiseCheck(pe);
             const premiseId = pe.getId();
             pe.setOnMutate(() => {
                 engine.reactiveDirty.premiseIds.add(premiseId);
                 engine.notifySubscribers();
             });
         }
+        // Restore claim-bound variables first, then premise-bound variables
+        for (const v of snapshot.variables.variables) {
+            if (isClaimBound(v)) {
+                engine.addVariable(v);
+            }
+        }
+        for (const v of snapshot.variables.variables) {
+            if (isPremiseBound(v)) {
+                engine.bindVariableToPremise(v);
+            }
+        }
         // Restore conclusion role (don't use setConclusionPremise to avoid auto-assign logic)
         engine.conclusionPremiseId = snapshot.conclusionPremiseId;
         return engine;
@@ -703,11 +680,26 @@ export class ArgumentEngine {
      * `premiseId` field and loaded in BFS order (roots first, then children
      * of already-added nodes) to satisfy parent-existence requirements.
      */
-    static fromData(argument, assertionLibrary, sourceLibrary, variables, premises, expressions, roles, config) {
-        const engine = new ArgumentEngine(argument, assertionLibrary, sourceLibrary, config);
-        // Register variables
+    static fromData(argument, claimLibrary, sourceLibrary, claimSourceLibrary, variables, premises, expressions, roles, config) {
+        const engine = new ArgumentEngine(argument, claimLibrary, sourceLibrary, claimSourceLibrary, config);
+        // Register claim-bound variables first (no dependencies)
+        for (const v of variables) {
+            if (isClaimBound(v)) {
+                engine.addVariable(v);
+            }
+        }
+        // Create premises (premise-bound variables reference them)
+        const premiseEngines = new Map();
+        for (const premise of premises) {
+            const { id: _id, argumentId: _argumentId, argumentVersion: _argumentVersion, checksum: _checksum, ...extras } = premise;
+            const { result: pe } = engine.createPremiseWithId(premise.id, extras);
+            premiseEngines.set(premise.id, pe);
+        }
+        // Register premise-bound variables (depend on premises)
         for (const v of variables) {
-            engine.addVariable(v);
+            if (isPremiseBound(v)) {
+                engine.bindVariableToPremise(v);
+            }
         }
         // Group expressions by premiseId
         const exprsByPremise = new Map();
@@ -721,12 +713,9 @@ export class ArgumentEngine {
             }
             group.push(expr);
         }
-        // Create premises and load their expressions in BFS order
-        for (const premise of premises) {
-            const { id: _id, argumentId: _argumentId, argumentVersion: _argumentVersion, checksum: _checksum, ...extras } = premise;
-            const { result: pe } = engine.createPremiseWithId(premise.id, extras);
-            // Add expressions in BFS order (roots first, then children)
-            const premiseExprs = exprsByPremise.get(premise.id) ?? [];
+        // Add expressions in BFS order (roots first, then children)
+        for (const [premiseId, pe] of premiseEngines) {
+            const premiseExprs = exprsByPremise.get(premiseId) ?? [];
             const pending = new Map(premiseExprs.map((e) => [e.id, e]));
             let progressed = true;
             while (pending.size > 0 && progressed) {
@@ -757,17 +746,16 @@ export class ArgumentEngine {
         this.checksumConfig = snapshot.config?.checksumConfig;
         this.positionConfig = snapshot.config?.positionConfig;
         this.variables = VariableManager.fromSnapshot(snapshot.variables);
-        this.sourceManager = snapshot.sources
-            ? SourceManager.fromSnapshot(snapshot.sources)
-            : new SourceManager();
         this.premises = new Map();
         this.expressionIndex = new Map();
         for (const premiseSnap of snapshot.premises) {
-            const pe = PremiseEngine.fromSnapshot(premiseSnap, this.argument, this.variables, this.expressionIndex, this.sourceManager);
+            const pe = PremiseEngine.fromSnapshot(premiseSnap, this.argument, this.variables, this.expressionIndex);
             this.premises.set(pe.getId(), pe);
         }
         this.conclusionPremiseId = snapshot.conclusionPremiseId;
         for (const pe of this.premises.values()) {
+            this.wireCircularityCheck(pe);
+            this.wireEmptyBoundPremiseCheck(pe);
             const premiseId = pe.getId();
             pe.setOnMutate(() => {
                 this.reactiveDirty.premiseIds.add(premiseId);
@@ -779,7 +767,6 @@ export class ArgumentEngine {
             argument: true,
             variables: true,
             roles: true,
-            sources: true,
             premiseIds: new Set(),
             allPremises: true,
         };
@@ -807,13 +794,6 @@ export class ArgumentEngine {
         for (const pe of this.listPremises()) {
             checksumMap[pe.getId()] = pe.checksum();
         }
-        // Association checksums
-        for (const a of this.sourceManager.getAllVariableSourceAssociations()) {
-            checksumMap[a.id] = a.checksum;
-        }
-        for (const a of this.sourceManager.getAllExpressionSourceAssociations()) {
-            checksumMap[a.id] = a.checksum;
-        }
         return computeHash(canonicalSerialize(checksumMap));
     }
     markDirty() {
@@ -929,30 +909,6 @@ export class ArgumentEngine {
             const premiseValidation = premise.validateEvaluability();
             issues.push(...premiseValidation.issues);
         }
-        // Source validation
-        for (const assoc of this.sourceManager.getAllVariableSourceAssociations()) {
-            if (!this.variables.hasVariable(assoc.variableId)) {
-                issues.push(makeErrorIssue({
-                    code: "SOURCE_VARIABLE_ASSOCIATION_INVALID_VARIABLE",
-                    message: `Variable-source association "${assoc.id}" references non-existent variable "${assoc.variableId}".`,
-                }));
-            }
-        }
-        for (const assoc of this.sourceManager.getAllExpressionSourceAssociations()) {
-            const premise = this.premises.get(assoc.premiseId);
-            if (!premise) {
-                issues.push(makeErrorIssue({
-                    code: "SOURCE_EXPRESSION_ASSOCIATION_INVALID_PREMISE",
-                    message: `Expression-source association "${assoc.id}" references non-existent premise "${assoc.premiseId}".`,
-                }));
-            }
-            else if (!premise.getExpression(assoc.expressionId)) {
-                issues.push(makeErrorIssue({
-                    code: "SOURCE_EXPRESSION_ASSOCIATION_INVALID_EXPRESSION",
-                    message: `Expression-source association "${assoc.id}" references non-existent expression "${assoc.expressionId}" in premise "${assoc.premiseId}".`,
-                }));
-            }
-        }
         return makeValidationResult(issues);
     }
     evaluate(assignment, options) {
@@ -987,15 +943,47 @@ export class ArgumentEngine {
             ...supportingPremises,
             ...constraintPremises,
         ];
-        const referencedVariableIds = [
+        const allVariableIds = [
             ...new Set(allRelevantPremises.flatMap((pm) => pm
                 .getExpressions()
                 .filter((expr) => expr.type === "variable")
                 .map((expr) => expr.variableId))),
         ].sort();
+        // Only claim-bound variables get truth-table columns;
+        // premise-bound variables are resolved lazily from their bound premise.
+        const referencedVariableIds = allVariableIds.filter((vid) => {
+            const v = this.variables.getVariable(vid);
+            return v != null && isClaimBound(v);
+        });
         try {
+            // Build a resolver that lazily evaluates premise-bound variables
+            // by evaluating their bound premise's expression tree under the
+            // same assignment. Results are cached per-variable per-evaluate call.
+            const resolverCache = new Map();
+            const resolver = (variableId) => {
+                if (resolverCache.has(variableId)) {
+                    return resolverCache.get(variableId);
+                }
+                const variable = this.variables.getVariable(variableId);
+                if (!variable || !isPremiseBound(variable)) {
+                    return assignment.variables[variableId] ?? null;
+                }
+                const boundPremiseId = variable.boundPremiseId;
+                const boundPremise = this.premises.get(boundPremiseId);
+                if (!boundPremise) {
+                    resolverCache.set(variableId, null);
+                    return null;
+                }
+                const premiseResult = boundPremise.evaluate(assignment, {
+                    resolver,
+                });
+                const value = premiseResult?.rootValue ?? null;
+                resolverCache.set(variableId, value);
+                return value;
+            };
             const evalOpts = {
                 strictUnknownKeys: options?.strictUnknownAssignmentKeys ?? false,
+                resolver,
             };
             const conclusionEvaluation = conclusion.evaluate(assignment, evalOpts);
             const supportingEvaluations = supportingPremises.map((pm) => pm.evaluate(assignment, evalOpts));
@@ -1075,7 +1063,7 @@ export class ArgumentEngine {
         const supportingIds = new Set(supportingPremises.map((pm) => pm.getId()));
         const constraintPremises = this.listPremises().filter((pm) => pm.getId() !== this.conclusionPremiseId &&
             !supportingIds.has(pm.getId()));
-        const checkedVariableIds = [
+        const allVariableIdsForCheck = [
             ...new Set([
                 conclusion,
                 ...supportingPremises,
@@ -1085,6 +1073,12 @@ export class ArgumentEngine {
                 .filter((expr) => expr.type === "variable")
                 .map((expr) => expr.variableId))),
         ].sort();
+        // Only claim-bound variables get truth-table columns;
+        // premise-bound variables are resolved lazily from their bound premise.
+        const checkedVariableIds = allVariableIdsForCheck.filter((vid) => {
+            const v = this.variables.getVariable(vid);
+            return v != null && isClaimBound(v);
+        });
         if (options?.maxVariables !== undefined &&
             checkedVariableIds.length > options.maxVariables) {
             return {