fix(rpn): change variadic NewRPN/NewOperations to single optional MetricReader (task ok)

20 files changed, 223 insertions, 223 deletions

diff --git a/cmd/gt/main.go b/cmd/gt/main.go
index 85292fb..3203c34 100644
--- a/cmd/gt/main.go
+++ b/cmd/gt/main.go
@@ -170,7 +170,7 @@ func runREPL() error {
 // making it suitable for one-off calculations.
 func runRPN(input string) (string, error) {
 	vars := rpn.NewVariables()
-	rpnCalc := rpn.NewRPN(vars)
+	rpnCalc := rpn.NewRPN(vars, nil)
 
 	// Strip "rpn " or "calc " prefix if present
 	input = strings.TrimSpace(input)
diff --git a/internal/repl/concurrent_test.go b/internal/repl/concurrent_test.go
index 501b363..62bf7dc 100644
--- a/internal/repl/concurrent_test.go
+++ b/internal/repl/concurrent_test.go
@@ -15,7 +15,7 @@ func TestConcurrentExecutor(t *testing.T) {
 		go func(id int) {
 			defer wg.Done()
 			vars := rpn.NewVariables()
-			rpnCalc := rpn.NewRPN(vars)
+			rpnCalc := rpn.NewRPN(vars, nil)
 			rpl := &REPL{
 				ttyChecker:    &TTYChecker{},
 				historyMgr:    NewHistoryManager(".gt_history"),
@@ -37,7 +37,7 @@ func TestConcurrentRPN(t *testing.T) {
 		go func(id int) {
 			defer wg.Done()
 			vars := rpn.NewVariables()
-			rpnCalc := rpn.NewRPN(vars)
+			rpnCalc := rpn.NewRPN(vars, nil)
 			_, _ = rpnCalc.ParseAndEvaluate("3 4 +")
 		}(i)
 	}
@@ -52,7 +52,7 @@ func TestConcurrentRatModeToggle(t *testing.T) {
 		go func(id int) {
 			defer wg.Done()
 			vars := rpn.NewVariables()
-			rpnCalc := rpn.NewRPN(vars)
+			rpnCalc := rpn.NewRPN(vars, nil)
 			rpl := &REPL{
 				ttyChecker:    &TTYChecker{},
 				historyMgr:    NewHistoryManager(".gt_history"),
@@ -74,7 +74,7 @@ func TestConcurrentExecutorAndRPN(t *testing.T) {
 		go func(id int) {
 			defer wg.Done()
 			vars := rpn.NewVariables()
-			rpnCalc := rpn.NewRPN(vars)
+			rpnCalc := rpn.NewRPN(vars, nil)
 			rpl := &REPL{
 				ttyChecker:    &TTYChecker{},
 				historyMgr:    NewHistoryManager(".gt_history"),
@@ -87,7 +87,7 @@ func TestConcurrentExecutorAndRPN(t *testing.T) {
 		go func(id int) {
 			defer wg.Done()
 			vars := rpn.NewVariables()
-			rpnCalc := rpn.NewRPN(vars)
+			rpnCalc := rpn.NewRPN(vars, nil)
 			_, _ = rpnCalc.ParseAndEvaluate("3 4 +")
 		}(i)
 	}
diff --git a/internal/repl/repl.go b/internal/repl/repl.go
index 2ecd9ea..451b6c3 100644
--- a/internal/repl/repl.go
+++ b/internal/repl/repl.go
@@ -179,7 +179,7 @@ func NewREPL(executor func(string), completer func() []string, logWriter io.Writ
 		fmt.Printf("Warning: Could not load saved variables: %v\n", err)
 	}
 
-	rpnCalc := rpn.NewRPN(vars)
+	rpnCalc := rpn.NewRPN(vars, nil)
 	rpnState := NewRPNState(vars, rpnCalc)
 
 	repl := &REPL{
diff --git a/internal/repl/repl_test.go b/internal/repl/repl_test.go
index f8e22a2..a7fd2f8 100644
--- a/internal/repl/repl_test.go
+++ b/internal/repl/repl_test.go
@@ -18,7 +18,7 @@ func createTestREPL() *REPL {
 		historyMgr:    NewHistoryManager(".gt_history"),
 		signalHandler: NewSignalHandler(),
 		commandChain:  NewCommandChain(),
-		rpnState:      &RPNState{vars: vars, rpnCalc: rpn.NewRPN(vars)},
+		rpnState:      &RPNState{vars: vars, rpnCalc: rpn.NewRPN(vars, nil)},
 	}
 }
 
@@ -186,7 +186,7 @@ func TestRunRPN(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			vars := rpn.NewVariables()
-			rpnCalc := rpn.NewRPN(vars)
+			rpnCalc := rpn.NewRPN(vars, nil)
 
 			input := strings.TrimSpace(tt.input)
 			if strings.HasPrefix(input, "rpn ") {
@@ -408,7 +408,7 @@ func TestExecutorWithCalcPrefixMixed(t *testing.T) {
 // TestExecutorWithRatModeOn tests that rat on works with fresh REPL
 func TestExecutorWithRatModeOn(t *testing.T) {
 	vars := rpn.NewVariables()
-	rpnCalc := rpn.NewRPN(vars)
+	rpnCalc := rpn.NewRPN(vars, nil)
 	rpl := &REPL{
 		ttyChecker:    &TTYChecker{},
 		historyMgr:    NewHistoryManager(".gt_history"),
@@ -425,7 +425,7 @@ func TestExecutorWithRatModeOn(t *testing.T) {
 // TestExecutorWithRatModeOff tests that rat off works with fresh REPL
 func TestExecutorWithRatModeOff(t *testing.T) {
 	vars := rpn.NewVariables()
-	rpnCalc := rpn.NewRPN(vars)
+	rpnCalc := rpn.NewRPN(vars, nil)
 	rpl := &REPL{
 		ttyChecker:    &TTYChecker{},
 		historyMgr:    NewHistoryManager(".gt_history"),
@@ -442,7 +442,7 @@ func TestExecutorWithRatModeOff(t *testing.T) {
 // TestExecutorWithRatModeToggle tests that rat toggle works with fresh REPL
 func TestExecutorWithRatModeToggle(t *testing.T) {
 	vars := rpn.NewVariables()
-	rpnCalc := rpn.NewRPN(vars)
+	rpnCalc := rpn.NewRPN(vars, nil)
 	rpl := &REPL{
 		ttyChecker:    &TTYChecker{},
 		historyMgr:    NewHistoryManager(".gt_history"),
@@ -487,7 +487,7 @@ func TestIsBuiltinCommandWithSubcommandHelp(t *testing.T) {
 // TestExecutorWithAssignmentRight tests := and =: operators
 func TestExecutorWithAssignmentRight(t *testing.T) {
 	vars := rpn.NewVariables()
-	rpnCalc := rpn.NewRPN(vars)
+	rpnCalc := rpn.NewRPN(vars, nil)
 	rpl := &REPL{
 		ttyChecker:    &TTYChecker{},
 		historyMgr:    NewHistoryManager(".gt_history"),
@@ -520,7 +520,7 @@ func TestExecutorWithAssignmentRight(t *testing.T) {
 // TestExecutorWithAssignmentAfterCalculation tests assignment after a calculation
 func TestExecutorWithAssignmentAfterCalculation(t *testing.T) {
 	vars := rpn.NewVariables()
-	rpnCalc := rpn.NewRPN(vars)
+	rpnCalc := rpn.NewRPN(vars, nil)
 	rpl := &REPL{
 		ttyChecker:    &TTYChecker{},
 		historyMgr:    NewHistoryManager(".gt_history"),
@@ -543,7 +543,7 @@ func TestExecutorWithAssignmentAfterCalculation(t *testing.T) {
 // TestExecutorWithIncrementalAssignment tests that assignment works after a calculation with separate commands
 func TestExecutorWithIncrementalAssignment(t *testing.T) {
 	vars := rpn.NewVariables()
-	rpnCalc := rpn.NewRPN(vars)
+	rpnCalc := rpn.NewRPN(vars, nil)
 	rpl := &REPL{
 		ttyChecker:    &TTYChecker{},
 		historyMgr:    NewHistoryManager(".gt_history"),
@@ -570,7 +570,7 @@ func TestExecutorWithIncrementalAssignment(t *testing.T) {
 // TestExecutorWithSimpleIncrementalAssignment tests x =: after 2 in REPL
 func TestExecutorWithSimpleIncrementalAssignment(t *testing.T) {
 	vars := rpn.NewVariables()
-	rpnCalc := rpn.NewRPN(vars)
+	rpnCalc := rpn.NewRPN(vars, nil)
 	rpl := &REPL{
 		ttyChecker:    &TTYChecker{},
 		historyMgr:    NewHistoryManager(".gt_history"),
@@ -596,7 +596,7 @@ func TestExecutorWithSimpleIncrementalAssignment(t *testing.T) {
 // TestExecutorWithExactUserScenario tests the exact user scenario: 2 then x =:
 func TestExecutorWithExactUserScenario(t *testing.T) {
 	vars := rpn.NewVariables()
-	rpnCalc := rpn.NewRPN(vars)
+	rpnCalc := rpn.NewRPN(vars, nil)
 	rpl := &REPL{
 		ttyChecker:    &TTYChecker{},
 		historyMgr:    NewHistoryManager(".gt_history"),
@@ -628,7 +628,7 @@ func TestExecutorWithExactUserScenario(t *testing.T) {
 // TestExecutorWithExactUserScenarioWithOutput tests that x =: assigns and shows result
 func TestExecutorWithExactUserScenarioWithOutput(t *testing.T) {
 	vars := rpn.NewVariables()
-	rpnCalc := rpn.NewRPN(vars)
+	rpnCalc := rpn.NewRPN(vars, nil)
 	rpl := &REPL{
 		ttyChecker:    &TTYChecker{},
 		historyMgr:    NewHistoryManager(".gt_history"),
@@ -660,7 +660,7 @@ func TestExecutorWithExactUserScenarioWithOutput(t *testing.T) {
 // TestExecutorWithExactUserScenarioDirect simulates REPL input flow
 func TestExecutorWithExactUserScenarioDirect(t *testing.T) {
 	vars := rpn.NewVariables()
-	rpnCalc := rpn.NewRPN(vars)
+	rpnCalc := rpn.NewRPN(vars, nil)
 	rpl := &REPL{
 		ttyChecker:    &TTYChecker{},
 		historyMgr:    NewHistoryManager(".gt_history"),
diff --git a/internal/repl/rpnstate_test.go b/internal/repl/rpnstate_test.go
index 1d54dea..80c7f65 100644
--- a/internal/repl/rpnstate_test.go
+++ b/internal/repl/rpnstate_test.go
@@ -14,7 +14,7 @@ import (
 
 func TestNewRPNState(t *testing.T) {
 	vars := rpn.NewVariables()
-	rpnCalc := rpn.NewRPN(vars)
+	rpnCalc := rpn.NewRPN(vars, nil)
 	state := NewRPNState(vars, rpnCalc)
 	if state == nil {
 		t.Fatal("NewRPNState() returned nil")
@@ -25,7 +25,7 @@ func TestRPNStateLoadVariablesEmpty(t *testing.T) {
 	// When varStoreFile is empty, LoadVariables should return nil
 	state := &RPNState{
 		vars:      rpn.NewVariables(),
-		rpnCalc:   rpn.NewRPN(rpn.NewVariables()),
+		rpnCalc:   rpn.NewRPN(rpn.NewVariables(), nil),
 		varStoreFile: "",
 	}
 	err := state.LoadVariables()
@@ -37,7 +37,7 @@ func TestRPNStateLoadVariablesEmpty(t *testing.T) {
 func TestRPNStateSaveVariablesEmpty(t *testing.T) {
 	state := &RPNState{
 		vars:        rpn.NewVariables(),
-		rpnCalc:     rpn.NewRPN(rpn.NewVariables()),
+		rpnCalc:     rpn.NewRPN(rpn.NewVariables(), nil),
 		varStoreFile: "",
 	}
 	err := state.SaveVariables()
@@ -70,7 +70,7 @@ func TestRPNStateSaveLoadRoundTrip(t *testing.T) {
 	vars.SetVariable("x", 42.0)
 	vars.SetVariable("y", 3.14)
 
-	rpnCalc := rpn.NewRPN(vars)
+	rpnCalc := rpn.NewRPN(vars, nil)
 	state := &RPNState{
 		vars:         vars,
 		rpnCalc:      rpnCalc,
@@ -91,7 +91,7 @@ func TestRPNStateSaveLoadRoundTrip(t *testing.T) {
 	newVars := rpn.NewVariables()
 	newState := &RPNState{
 		vars:         newVars,
-		rpnCalc:      rpn.NewRPN(newVars),
+		rpnCalc:      rpn.NewRPN(newVars, nil),
 		varStoreFile: varStorePath,
 	}
 
diff --git a/internal/rpn/assignment_test.go b/internal/rpn/assignment_test.go
index 82d4a12..f9f4a3e 100644
--- a/internal/rpn/assignment_test.go
+++ b/internal/rpn/assignment_test.go
@@ -11,7 +11,7 @@ import (
 // TestAssignmentStandard tests standard assignment 'x 5 ='
 func TestAssignmentStandard(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	result, err := rpn.ParseAndEvaluate("x 5 =")
 	if err != nil {
@@ -33,7 +33,7 @@ func TestAssignmentStandard(t *testing.T) {
 // TestAssignmentRight tests right assignment '5 x :='
 func TestAssignmentRight(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	result, err := rpn.ParseAndEvaluate("5 x :=")
 	if err != nil {
@@ -55,7 +55,7 @@ func TestAssignmentRight(t *testing.T) {
 // TestAssignmentLeft tests left assignment '5 x =:'
 func TestAssignmentLeft(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	result, err := rpn.ParseAndEvaluate("5 x =:")
 	if err != nil {
@@ -77,7 +77,7 @@ func TestAssignmentLeft(t *testing.T) {
 // TestAssignmentReassignment tests variable reassignment
 func TestAssignmentReassignment(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	_, err := rpn.ParseAndEvaluate("x 5 =")
 	if err != nil {
@@ -104,7 +104,7 @@ func TestAssignmentReassignment(t *testing.T) {
 // TestAssignmentInExpression tests assignment used in an expression
 func TestAssignmentInExpression(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	// 'x 5 = x 2 +' should assign x=5, then push x and 2, then add: 5 + 2 = 7
 	result, err := rpn.ParseAndEvaluate("x 5 = x 2 +")
@@ -119,7 +119,7 @@ func TestAssignmentInExpression(t *testing.T) {
 // TestAssignmentMultipleVariables tests multiple variable assignments
 func TestAssignmentMultipleVariables(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	_, _ = rpn.ParseAndEvaluate("x 5 =")
 	_, _ = rpn.ParseAndEvaluate("y 10 =")
@@ -146,7 +146,7 @@ func TestAssignmentMultipleVariables(t *testing.T) {
 // TestAssignmentArithmeticWithVariable tests arithmetic using assigned variable
 func TestAssignmentArithmeticWithVariable(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	_, _ = rpn.ParseAndEvaluate("x 5 =")
 
@@ -163,7 +163,7 @@ func TestAssignmentArithmeticWithVariable(t *testing.T) {
 // TestAssignmentNegativeValue tests assignment with negative value
 func TestAssignmentNegativeValue(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	_, err := rpn.ParseAndEvaluate("x -5 =")
 	if err != nil {
@@ -182,7 +182,7 @@ func TestAssignmentNegativeValue(t *testing.T) {
 // TestAssignmentDecimalValue tests assignment with decimal value
 func TestAssignmentDecimalValue(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	_, err := rpn.ParseAndEvaluate("x 3.14 =")
 	if err != nil {
@@ -201,7 +201,7 @@ func TestAssignmentDecimalValue(t *testing.T) {
 // TestAssignmentUnderscoreVariable tests assignment with underscore variable
 func TestAssignmentUnderscoreVariable(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	_, err := rpn.ParseAndEvaluate("my_var 42 =")
 	if err != nil {
@@ -220,7 +220,7 @@ func TestAssignmentUnderscoreVariable(t *testing.T) {
 // TestAssignmentWithCalculationResult tests assigning result of calculation
 func TestAssignmentWithCalculationResult(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	// 3 4 + x =: should push 3, 4, add (=7), then assign 7 to x
 	_, err := rpn.ParseAndEvaluate("3 4 + x =:")
@@ -240,7 +240,7 @@ func TestAssignmentWithCalculationResult(t *testing.T) {
 // TestAssignmentAllOperatorsInSequence tests all three assignment operators
 func TestAssignmentAllOperatorsInSequence(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	_, _ = rpn.ParseAndEvaluate("a 1 =")  // standard
 	_, _ = rpn.ParseAndEvaluate("2 b :=") // right
@@ -260,7 +260,7 @@ func TestAssignmentAllOperatorsInSequence(t *testing.T) {
 // TestAssignmentOperatorRegistry verifies all assignment operators are registered
 func TestAssignmentOperatorRegistry(t *testing.T) {
 	vars := NewVariables()
-	ops := NewOperations(vars)
+	ops := NewOperations(vars, nil)
 	reg := NewOperatorRegistry(ops)
 
 	// Verify assignment operators are registered as standard operators
@@ -278,7 +278,7 @@ func TestAssignmentOperatorRegistry(t *testing.T) {
 // TestAssignmentNotTriggeredByEqualEqual ensures that == is not misparsed as an assignment.
 func TestAssignmentNotTriggeredByEqualEqual(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	// "a == b" should NOT be treated as an assignment
 	_, err := rpn.ParseAndEvaluate("a == b")
@@ -297,7 +297,7 @@ func TestAssignmentNotTriggeredByEqualEqual(t *testing.T) {
 // TestAssignmentNotTriggeredByNotEqual ensures that != is not misparsed as an assignment.
 func TestAssignmentNotTriggeredByNotEqual(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	// "a != b" should NOT be treated as an assignment
 	_, err := rpn.ParseAndEvaluate("a != b")
@@ -311,7 +311,7 @@ func TestAssignmentNotTriggeredByNotEqual(t *testing.T) {
 // TestAssignmentAfterEqualEqual ensures "x 5 =" still works even when == exists in the expression.
 func TestAssignmentAfterEqualEqual(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	// A standalone assignment should work regardless of == elsewhere
 	result, err := rpn.ParseAndEvaluate("x 5 =")
@@ -342,7 +342,7 @@ func TestAssignRightOperator(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			r := NewRPN(NewVariables())
+			r := NewRPN(NewVariables(), nil)
 			result, err := r.ParseAndEvaluate(tt.expr)
 			if err != nil {
 				t.Fatalf("ParseAndEvaluate(%q) error = %v", tt.expr, err)
@@ -367,7 +367,7 @@ func TestAssignLeftOperator(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			r := NewRPN(NewVariables())
+			r := NewRPN(NewVariables(), nil)
 			result, err := r.ParseAndEvaluate(tt.expr)
 			if err != nil {
 				t.Fatalf("ParseAndEvaluate(%q) error = %v", tt.expr, err)
@@ -393,7 +393,7 @@ func TestStandardAssignOperator(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			r := NewRPN(NewVariables())
+			r := NewRPN(NewVariables(), nil)
 			result, err := r.ParseAndEvaluate(tt.expr)
 			if err != nil {
 				t.Fatalf("ParseAndEvaluate(%q) error = %v", tt.expr, err)
@@ -421,7 +421,7 @@ func TestVariableInExpression(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			r := NewRPN(NewVariables())
+			r := NewRPN(NewVariables(), nil)
 			_, err := r.ParseAndEvaluate(tt.setup)
 			if err != nil {
 				t.Fatalf("Setup failed for %q: %v", tt.setup, err)
@@ -439,7 +439,7 @@ func TestVariableInExpression(t *testing.T) {
 
 // TestChainedAssignments tests chaining multiple assignments in one expression.
 func TestChainedAssignments(t *testing.T) {
-	r := NewRPN(NewVariables())
+	r := NewRPN(NewVariables(), nil)
 	result, err := r.ParseAndEvaluate("a 10 := b 3 := c 2 :=")
 	if err != nil {
 		t.Fatalf("Chained assignment failed: %v", err)
@@ -472,7 +472,7 @@ func TestChainedAssignments(t *testing.T) {
 
 // TestVarsCommand tests the vars command.
 func TestVarsCommand(t *testing.T) {
-	r := NewRPN(NewVariables())
+	r := NewRPN(NewVariables(), nil)
 
 	// Empty vars
 	result, err := r.ParseAndEvaluate("vars")
@@ -501,7 +501,7 @@ func TestVarsCommand(t *testing.T) {
 
 // TestClearCommand tests the clear command.
 func TestClearCommand(t *testing.T) {
-	r := NewRPN(NewVariables())
+	r := NewRPN(NewVariables(), nil)
 	r.ParseAndEvaluate("x 5 :=")
 	r.ParseAndEvaluate("y 10 :=")
 
@@ -521,7 +521,7 @@ func TestClearCommand(t *testing.T) {
 
 // TestDeleteVariableOperator tests the d (delete) operator.
 func TestDeleteVariableOperator(t *testing.T) {
-	r := NewRPN(NewVariables())
+	r := NewRPN(NewVariables(), nil)
 
 	// Create variable
 	r.ParseAndEvaluate("x 5 :=")
@@ -544,7 +544,7 @@ func TestDeleteVariableOperator(t *testing.T) {
 
 // TestDeleteNonExistentVariableOperator tests deleting a variable that doesn't exist.
 func TestDeleteNonExistentVariableOperator(t *testing.T) {
-	r := NewRPN(NewVariables())
+	r := NewRPN(NewVariables(), nil)
 	_, err := r.ParseAndEvaluate(":nonexistent d")
 	if err == nil {
 		t.Error("Deleting non-existent variable should return error")
@@ -554,7 +554,7 @@ func TestDeleteNonExistentVariableOperator(t *testing.T) {
 // TestVariablePersistenceAcrossExpressions tests that variables persist across
 // multiple ParseAndEvaluate calls on the same RPN instance.
 func TestVariablePersistenceAcrossExpressions(t *testing.T) {
-	r := NewRPN(NewVariables())
+	r := NewRPN(NewVariables(), nil)
 
 	r.ParseAndEvaluate("a 10 :=")
 	r.ParseAndEvaluate("b 3 :=")
diff --git a/internal/rpn/boolean_test.go b/internal/rpn/boolean_test.go
index f0ced89..6eea269 100644
--- a/internal/rpn/boolean_test.go
+++ b/internal/rpn/boolean_test.go
@@ -98,7 +98,7 @@ func TestBooleanOperators(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			vars := NewVariables()
-			rpnCalc := NewRPN(vars)
+			rpnCalc := NewRPN(vars, nil)
 
 			result, err := rpnCalc.ParseAndEvaluate(tt.expression)
 
@@ -163,7 +163,7 @@ func TestBooleanToNumberCoercion(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			vars := NewVariables()
-			rpnCalc := NewRPN(vars)
+			rpnCalc := NewRPN(vars, nil)
 
 			result, err := rpnCalc.ParseAndEvaluate(tt.expression)
 
@@ -221,7 +221,7 @@ func TestMixedBooleanNumericArithmetic(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			vars := NewVariables()
-			rpnCalc := NewRPN(vars)
+			rpnCalc := NewRPN(vars, nil)
 
 			result, err := rpnCalc.ParseAndEvaluate(tt.expression)
 
@@ -268,7 +268,7 @@ func TestBooleanShowFormat(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			vars := NewVariables()
-			rpnCalc := NewRPN(vars)
+			rpnCalc := NewRPN(vars, nil)
 
 			result, err := rpnCalc.ParseAndEvaluate(tt.expression)
 
diff --git a/internal/rpn/compare_metric_test.go b/internal/rpn/compare_metric_test.go
index e1b5134..d32ac60 100644
--- a/internal/rpn/compare_metric_test.go
+++ b/internal/rpn/compare_metric_test.go
@@ -177,7 +177,7 @@ func TestMetricAwareComparisons(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			vars := NewVariables()
-			rpnCalc := NewRPN(vars)
+			rpnCalc := NewRPN(vars, nil)
 
 			if tt.prefixMode == IEC {
 				rpnCalc.SetPrefixMode(IEC)
@@ -282,7 +282,7 @@ func TestShorthandComparisonOperators(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			vars := NewVariables()
-			rpnCalc := NewRPN(vars)
+			rpnCalc := NewRPN(vars, nil)
 
 			result, err := rpnCalc.ParseAndEvaluate(tt.expression)
 
@@ -356,7 +356,7 @@ func TestIncompatibleCategoryComparison(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			vars := NewVariables()
-			rpnCalc := NewRPN(vars)
+			rpnCalc := NewRPN(vars, nil)
 
 			_, err := rpnCalc.ParseAndEvaluate(tt.expression)
 
@@ -414,7 +414,7 @@ func TestMetricComparisonEdgeCases(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			vars := NewVariables()
-			rpnCalc := NewRPN(vars)
+			rpnCalc := NewRPN(vars, nil)
 
 			if tt.prefixMode == IEC {
 				rpnCalc.SetPrefixMode(IEC)
diff --git a/internal/rpn/constants_test.go b/internal/rpn/constants_test.go
index 68b79d1..4eb2129 100644
--- a/internal/rpn/constants_test.go
+++ b/internal/rpn/constants_test.go
@@ -213,7 +213,7 @@ func TestConstants_ThreadSafety(t *testing.T) {
 
 func TestConstants_RetrieveInRPN(t *testing.T) {
 	v := NewVariables()
-	r := NewRPN(v)
+	r := NewRPN(v, nil)
 
 	// Test pi constant
 	result, err := r.ParseAndEvaluate("pi")
@@ -226,7 +226,7 @@ func TestConstants_RetrieveInRPN(t *testing.T) {
 
 	// Create a new RPN instance for each test to avoid stack state conflicts
 	v2 := NewVariables()
-	r2 := NewRPN(v2)
+	r2 := NewRPN(v2, nil)
 
 	// Test e constant
 	result, err = r2.ParseAndEvaluate("e")
@@ -239,7 +239,7 @@ func TestConstants_RetrieveInRPN(t *testing.T) {
 
 	// Create a new RPN instance for the next test
 	v3 := NewVariables()
-	r3 := NewRPN(v3)
+	r3 := NewRPN(v3, nil)
 
 	// Test pi in expression
 	result, err = r3.ParseAndEvaluate("pi 2 *")
@@ -252,7 +252,7 @@ func TestConstants_RetrieveInRPN(t *testing.T) {
 
 	// Create a new RPN instance for phi test
 	v4 := NewVariables()
-	r4 := NewRPN(v4)
+	r4 := NewRPN(v4, nil)
 
 	// Test phi constant
 	result, err = r4.ParseAndEvaluate("phi")
@@ -266,7 +266,7 @@ func TestConstants_RetrieveInRPN(t *testing.T) {
 
 func TestConstants_RetrieveWithGreekLetters(t *testing.T) {
 	v := NewVariables()
-	r := NewRPN(v)
+	r := NewRPN(v, nil)
 
 	// Test pi with Greek letter
 	result, err := r.ParseAndEvaluate("π")
@@ -279,7 +279,7 @@ func TestConstants_RetrieveWithGreekLetters(t *testing.T) {
 
 	// Create a new RPN instance for phi test
 	v2 := NewVariables()
-	r2 := NewRPN(v2)
+	r2 := NewRPN(v2, nil)
 
 	// Test phi with Greek letter
 	result, err = r2.ParseAndEvaluate("φ")
@@ -293,7 +293,7 @@ func TestConstants_RetrieveWithGreekLetters(t *testing.T) {
 
 func TestConstants_ConflictWithVariables(t *testing.T) {
 	v := NewVariables()
-	r := NewRPN(v)
+	r := NewRPN(v, nil)
 
 	// First set a variable named pi
 	result, err := r.ParseAndEvaluate("pi = 3.0")
@@ -316,7 +316,7 @@ func TestConstants_ConflictWithVariables(t *testing.T) {
 
 func TestConstantsCommand(t *testing.T) {
 	v := NewVariables()
-	r := NewRPN(v)
+	r := NewRPN(v, nil)
 	result, err := r.ParseAndEvaluate("constants")
 	if err != nil {
 		t.Fatalf("ParseAndEvaluate(\"constants\") returned error: %v", err)
@@ -328,7 +328,7 @@ func TestConstantsCommand(t *testing.T) {
 
 func TestClearConstantsCommand(t *testing.T) {
 	v := NewVariables()
-	r := NewRPN(v)
+	r := NewRPN(v, nil)
 
 	// First add a custom constant
 	result, err := r.ParseAndEvaluate("custom 42 =")
@@ -409,7 +409,7 @@ func TestConstants_NewConstants(t *testing.T) {
 // TestConstants_ParseInRPN tests that new constants can be used in RPN expressions
 func TestConstants_ParseInRPN(t *testing.T) {
 	vars := NewVariables()
-	rpnCalc := NewRPN(vars)
+	rpnCalc := NewRPN(vars, nil)
 
 	tests := []struct {
 		expression string
@@ -532,7 +532,7 @@ func TestConstants_MoreInRPN(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			vars := NewVariables()
-			rpnCalc := NewRPN(vars)
+			rpnCalc := NewRPN(vars, nil)
 
 			result, err := rpnCalc.ParseAndEvaluate(tt.expression)
 			if err != nil {
@@ -567,7 +567,7 @@ func TestConstants_ListConstantsIncludesUserDefined(t *testing.T) {
 // TestConstants_NegativeInfInRPN tests negative infinity constant in RPN
 func TestConstants_NegativeInfInRPN(t *testing.T) {
 	vars := NewVariables()
-	rpnCalc := NewRPN(vars)
+	rpnCalc := NewRPN(vars, nil)
 
 	result, err := rpnCalc.ParseAndEvaluate("-inf")
 	if err != nil {
@@ -581,7 +581,7 @@ func TestConstants_NegativeInfInRPN(t *testing.T) {
 // TestConstants_InfExpression tests infinity in RPN expressions
 func TestConstants_InfExpression(t *testing.T) {
 	vars := NewVariables()
-	rpnCalc := NewRPN(vars)
+	rpnCalc := NewRPN(vars, nil)
 
 	// inf 1 + should still be inf
 	result, err := rpnCalc.ParseAndEvaluate("inf 1 +")
diff --git a/internal/rpn/custom_metric_test.go b/internal/rpn/custom_metric_test.go
index e555cee..47ece0f 100644
--- a/internal/rpn/custom_metric_test.go
+++ b/internal/rpn/custom_metric_test.go
@@ -20,7 +20,7 @@ func customCleanup(t *testing.T, rpn *RPN, name string) {
 // TestCustomDefineFactorZero tests defining a custom metric with factor=0
 func TestCustomDefineFactorZero(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 	defer customCleanup(t, rpn, "zero")
 
 	result, err := rpn.ParseAndEvaluate("custom define zero 0 Custom")
@@ -42,7 +42,7 @@ func TestCustomDefineFactorZero(t *testing.T) {
 // TestCustomDefineNegativeFactor tests defining a custom metric with negative factor
 func TestCustomDefineNegativeFactor(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 	defer customCleanup(t, rpn, "negtest")
 
 	result, err := rpn.ParseAndEvaluate("custom define negtest -5 Custom")
@@ -64,7 +64,7 @@ func TestCustomDefineNegativeFactor(t *testing.T) {
 // TestCustomDefineMalformedInput tests that malformed custom define input
 func TestCustomDefineMalformedInput(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	_, err := rpn.ParseAndEvaluate("custom define  1 Custom")
 	// Double-space collapses: fields = ["custom", "define", "1", "Custom"] (metric "" already exists as alias or empty check)
@@ -78,7 +78,7 @@ func TestCustomDefineMalformedInput(t *testing.T) {
 // that conflicts with an existing metric
 func TestCustomDefineConflictingAlias(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	// Try to define a metric with a name that matches an existing one
 	_, err := rpn.ParseAndEvaluate("custom define Mbps 1000 DataRate")
@@ -90,7 +90,7 @@ func TestCustomDefineConflictingAlias(t *testing.T) {
 // TestCustomMetricArithmetic tests using a custom metric in arithmetic operations
 func TestCustomMetricArithmetic(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 	defer customCleanup(t, rpn, "arithmetic_test")
 
 	_, err := rpn.ParseAndEvaluate("custom define arithmetic_test 42 Custom")
@@ -109,7 +109,7 @@ func TestCustomMetricArithmetic(t *testing.T) {
 // TestCustomMetricHyperOperations tests using a custom metric in hyper operations
 func TestCustomMetricHyperOperations(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 	defer customCleanup(t, rpn, "hyper_test")
 
 	_, err := rpn.ParseAndEvaluate("custom define hyper_test 100 Custom")
@@ -128,7 +128,7 @@ func TestCustomMetricHyperOperations(t *testing.T) {
 // TestCustomMetricSubtraction tests subtraction with custom metrics
 func TestCustomMetricSubtraction(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 	defer customCleanup(t, rpn, "sub_test")
 
 	_, err := rpn.ParseAndEvaluate("custom define sub_test 10 Custom")
@@ -146,7 +146,7 @@ func TestCustomMetricSubtraction(t *testing.T) {
 // TestCustomMetricMultiplication tests multiplication with custom metrics
 func TestCustomMetricMultiplication(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 	defer customCleanup(t, rpn, "mul_test")
 
 	_, err := rpn.ParseAndEvaluate("custom define mul_test 5 Custom")
@@ -164,7 +164,7 @@ func TestCustomMetricMultiplication(t *testing.T) {
 // TestCustomMetricDivision tests division with custom metrics
 func TestCustomMetricDivision(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 	defer customCleanup(t, rpn, "div_test")
 
 	_, err := rpn.ParseAndEvaluate("custom define div_test 10 Custom")
@@ -183,7 +183,7 @@ func TestCustomMetricDivision(t *testing.T) {
 // between different categories
 func TestCustomMetricConversionFail(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 	defer customCleanup(t, rpn, "conv_test")
 
 	_, err := rpn.ParseAndEvaluate("custom define conv_test 10 Custom")
@@ -202,7 +202,7 @@ func TestCustomMetricConversionFail(t *testing.T) {
 // can't be mixed in operations
 func TestCustomMetricCrossCategory(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 	defer customCleanup(t, rpn, "cat_test1")
 	defer customCleanup(t, rpn, "cat_test2")
 
@@ -219,7 +219,7 @@ func TestCustomMetricCrossCategory(t *testing.T) {
 // TestCustomMetricShow tests that custom metrics display correctly in Show
 func TestCustomMetricShow(t *testing.T) {
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 	defer customCleanup(t, rpn, "show_test")
 
 	_, err := rpn.ParseAndEvaluate("custom define show_test 100 Custom")
diff --git a/internal/rpn/metric_test.go b/internal/rpn/metric_test.go
index 69923cb..5a41f6f 100644
--- a/internal/rpn/metric_test.go
+++ b/internal/rpn/metric_test.go
@@ -832,7 +832,7 @@ func TestAtPrefixMetricParsing(t *testing.T) {
 func TestAtPrefixIntegration(t *testing.T) {
 	// Test that @GB parses correctly through the full RPN pipeline
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	// Parse a standalone @ metric
 	result, err := rpn.ParseAndEvaluate("@GB")
@@ -880,7 +880,7 @@ func TestMetricAwareArithmetic(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.expr, func(t *testing.T) {
 			vars := NewVariables()
-			rpn := NewRPN(vars)
+			rpn := NewRPN(vars, nil)
 			result, err := rpn.ParseAndEvaluate(tt.expr)
 			if tt.wantErr {
 				if err == nil {
@@ -985,7 +985,7 @@ func TestMetricOperationsUnit(t *testing.T) {
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			vars := NewVariables()
-			ops := NewOperations(vars)
+			ops := NewOperations(vars, nil)
 			s := NewStack()
 			tc.setup(s)
 
@@ -1040,7 +1040,7 @@ func TestConvertSameCategory(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.expr, func(t *testing.T) {
 			vars := NewVariables()
-			rpn := NewRPN(vars)
+			rpn := NewRPN(vars, nil)
 			result, err := rpn.ParseAndEvaluate(tt.expr)
 			if err != nil {
 				t.Fatalf("unexpected error: %v", err)
@@ -1064,7 +1064,7 @@ func TestConvertSameCategory(t *testing.T) {
 func TestConvertCoolAbsorbing(t *testing.T) {
 	reg := GetMetricRegistry()
 	vars := NewVariables()
-	rpn := NewRPN(vars)
+	rpn := NewRPN(vars, nil)
 
 	// Cool to metric: 100 @GB convert → 100 GB
 	// With Cool absorption, 100 is treated as