Condense deep runtime stack trace rendering

Author: mgomes

ROADMAP.md

@@ -328,7 +328,7 @@ Goal: improve day-to-day developer productivity and interpreter robustness.
 
 - [ ] Profile evaluator hotspots and optimize dispatch paths.
 - [ ] Reduce allocations in common value transformations.
-- [ ] Improve error rendering for deeply nested call stacks.
+- [x] Improve error rendering for deeply nested call stacks.
 - [x] Add fuzz tests for parser and runtime edge cases.
 
 ### CI and Release Engineering

vibes/execution.go

@@ -108,6 +108,8 @@ func (e *assertionFailureError) Error() string {
 const (
 	runtimeErrorTypeBase      = "RuntimeError"
 	runtimeErrorTypeAssertion = "AssertionError"
+	runtimeErrorFrameHead     = 8
+	runtimeErrorFrameTail     = 8
 )
 
 var (
@@ -123,18 +125,32 @@ func (re *RuntimeError) Error() string {
 		b.WriteString("\n")
 		b.WriteString(re.CodeFrame)
 	}
-	for _, frame := range re.Frames {
-		// Show position if line number is valid (1-based)
+	renderFrame := func(frame StackFrame) {
 		if frame.Pos.Line > 0 && frame.Pos.Column > 0 {
 			fmt.Fprintf(&b, "\n  at %s (%d:%d)", frame.Function, frame.Pos.Line, frame.Pos.Column)
 		} else if frame.Pos.Line > 0 {
-			// Line valid but column missing
 			fmt.Fprintf(&b, "\n  at %s (line %d)", frame.Function, frame.Pos.Line)
 		} else {
-			// No position information available
 			fmt.Fprintf(&b, "\n  at %s", frame.Function)
 		}
 	}
+
+	if len(re.Frames) <= runtimeErrorFrameHead+runtimeErrorFrameTail {
+		for _, frame := range re.Frames {
+			renderFrame(frame)
+		}
+		return b.String()
+	}
+
+	for _, frame := range re.Frames[:runtimeErrorFrameHead] {
+		renderFrame(frame)
+	}
+	omitted := len(re.Frames) - (runtimeErrorFrameHead + runtimeErrorFrameTail)
+	fmt.Fprintf(&b, "\n  ... %d frames omitted ...", omitted)
+	for _, frame := range re.Frames[len(re.Frames)-runtimeErrorFrameTail:] {
+		renderFrame(frame)
+	}
+
 	return b.String()
 }
 

vibes/runtime_test.go

@@ -809,6 +809,45 @@ func TestRuntimeErrorStackTrace(t *testing.T) {
 	}
 }
 
+func TestRuntimeErrorCondensesDeepStackRendering(t *testing.T) {
+	engine := MustNewEngine(Config{RecursionLimit: 128})
+	script, err := engine.Compile(`
+    def recurse(n)
+      if n <= 0
+        1 / 0
+      end
+      recurse(n - 1)
+    end
+
+    def run()
+      recurse(40)
+    end
+    `)
+	if err != nil {
+		t.Fatalf("compile error: %v", err)
+	}
+
+	_, err = script.Call(context.Background(), "run", nil, CallOptions{})
+	if err == nil {
+		t.Fatalf("expected runtime error")
+	}
+
+	var rtErr *RuntimeError
+	if !errors.As(err, &rtErr) {
+		t.Fatalf("expected RuntimeError, got %T", err)
+	}
+	if len(rtErr.Frames) <= 16 {
+		t.Fatalf("expected deep frame set, got %d", len(rtErr.Frames))
+	}
+	rendered := rtErr.Error()
+	if !strings.Contains(rendered, "frames omitted") {
+		t.Fatalf("expected deep stack output to include omitted-frame marker: %s", rendered)
+	}
+	if !strings.Contains(rendered, "at recurse") {
+		t.Fatalf("expected deep stack output to include recurse frames: %s", rendered)
+	}
+}
+
 func TestIntTimes(t *testing.T) {
 	script := compileScript(t, `
     def collect(n)