better info, ws update

bundle/bundle_test.go

···
 	tmpDir := t.TempDir()
 	logger := &testLogger{t: t}
 
-	ops, err := bundle.NewOperations(bundle.CompressionBetter, logger)
+	ops, err := bundle.NewOperations(logger)
 	if err != nil {
 		t.Fatalf("NewOperations failed: %v", err)
 	}

bundle/manager.go

···
 	}
 
 	// Initialize operations handler
-	ops, err := NewOperations(config.CompressionLevel, config.Logger)
+	ops, err := NewOperations(config.Logger)
 	if err != nil {
 		return nil, fmt.Errorf("failed to initialize operations: %w", err)
 	}
···
 	stats := m.index.GetStats()
 	stats["bundle_dir"] = m.config.BundleDir
 	stats["index_path"] = m.indexPath
-	stats["compression_level"] = m.config.CompressionLevel
 	stats["verify_on_load"] = m.config.VerifyOnLoad
 	return stats
 }

bundle/operations.go

···
 	logger  Logger
 }
 
-// NewOperations creates a new Operations handler
-func NewOperations(compressionLevel CompressionLevel, logger Logger) (*Operations, error) {
-	var zstdLevel zstd.EncoderLevel
-	switch compressionLevel {
-	case CompressionFastest:
-		zstdLevel = zstd.SpeedFastest
-	case CompressionDefault:
-		zstdLevel = zstd.SpeedDefault
-	case CompressionBetter:
-		zstdLevel = zstd.SpeedBetterCompression
-	case CompressionBest:
-		zstdLevel = zstd.SpeedBestCompression
-	default:
-		zstdLevel = zstd.SpeedBetterCompression
-	}
-
-	encoder, err := zstd.NewWriter(nil, zstd.WithEncoderLevel(zstdLevel))
+// NewOperations creates a new Operations handler with default compression
+func NewOperations(logger Logger) (*Operations, error) {
+	// Always use default compression (level 3 - good balance)
+	encoder, err := zstd.NewWriter(nil, zstd.WithEncoderLevel(zstd.SpeedDefault))
 	if err != nil {
 		return nil, fmt.Errorf("failed to create zstd encoder: %w", err)
 	}

bundle/types.go

···
 const (
 	// BUNDLE_SIZE is the standard number of operations per bundle
 	BUNDLE_SIZE = 10000
-
-	// DefaultCompression is the default compression level
-	DefaultCompression = CompressionBetter
-)
-
-// CompressionLevel represents zstd compression levels
-type CompressionLevel int
-
-const (
-	CompressionFastest CompressionLevel = 1
-	CompressionDefault CompressionLevel = 3
-	CompressionBetter  CompressionLevel = 5
-	CompressionBest    CompressionLevel = 9
 )
 
 // Bundle represents a PLC bundle
···
 
 // Config holds configuration for bundle operations
 type Config struct {
-	BundleDir        string
-	CompressionLevel CompressionLevel
-	VerifyOnLoad     bool
-	Logger           Logger
+	BundleDir    string
+	VerifyOnLoad bool
+	Logger       Logger
 }
 
 // DefaultConfig returns default configuration
 func DefaultConfig(bundleDir string) *Config {
 	return &Config{
-		BundleDir:        bundleDir,
-		CompressionLevel: CompressionBetter,
-		VerifyOnLoad:     true,
-		Logger:           nil, // Will use defaultLogger in manager
+		BundleDir:    bundleDir,
+		VerifyOnLoad: true,
+		Logger:       nil, // Will use defaultLogger in manager
 	}
 }

cmd/plcbundle/info.go

···
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/atscan/plcbundle/bundle"
+)
+
+func showGeneralInfo(mgr *bundle.Manager, dir string, verbose bool, showBundles bool, verify bool, showTimeline bool) {
+	index := mgr.GetIndex()
+	info := mgr.GetInfo()
+	stats := index.GetStats()
+	bundleCount := stats["bundle_count"].(int)
+
+	fmt.Printf("\n")
+	fmt.Printf("═══════════════════════════════════════════════════════════════\n")
+	fmt.Printf("              PLC Bundle Repository Overview\n")
+	fmt.Printf("═══════════════════════════════════════════════════════════════\n")
+	fmt.Printf("\n")
+
+	// Location
+	fmt.Printf("📁 Location\n")
+	fmt.Printf("   Directory:  %s\n", dir)
+	fmt.Printf("   Index:      %s\n", filepath.Base(info["index_path"].(string)))
+	fmt.Printf("\n")
+
+	if bundleCount == 0 {
+		fmt.Printf("⚠️  No bundles found\n")
+		fmt.Printf("\n")
+		fmt.Printf("Get started:\n")
+		fmt.Printf("  plcbundle fetch          # Fetch bundles from PLC\n")
+		fmt.Printf("  plcbundle scan           # Scan existing bundle files\n")
+		fmt.Printf("\n")
+		return
+	}
+
+	firstBundle := stats["first_bundle"].(int)
+	lastBundle := stats["last_bundle"].(int)
+	totalSize := stats["total_size"].(int64)
+	startTime := stats["start_time"].(time.Time)
+	endTime := stats["end_time"].(time.Time)
+	updatedAt := stats["updated_at"].(time.Time)
+
+	// Summary
+	fmt.Printf("📊 Summary\n")
+	fmt.Printf("   Bundles:       %s\n", formatNumber(bundleCount))
+	fmt.Printf("   Range:         %06d → %06d\n", firstBundle, lastBundle)
+	fmt.Printf("   Total Size:    %s\n", formatBytes(totalSize))
+	fmt.Printf("   Avg/Bundle:    %s\n", formatBytes(totalSize/int64(bundleCount)))
+	fmt.Printf("\n")
+
+	// Timeline
+	duration := endTime.Sub(startTime)
+	fmt.Printf("📅 Timeline\n")
+	fmt.Printf("   First Op:      %s\n", startTime.Format("2006-01-02 15:04:05 MST"))
+	fmt.Printf("   Last Op:       %s\n", endTime.Format("2006-01-02 15:04:05 MST"))
+	fmt.Printf("   Timespan:      %s\n", formatDuration(duration))
+	fmt.Printf("   Last Updated:  %s\n", updatedAt.Format("2006-01-02 15:04:05 MST"))
+	fmt.Printf("   Age:           %s ago\n", formatDuration(time.Since(updatedAt)))
+	fmt.Printf("\n")
+
+	// Operations estimate
+	totalOps := bundleCount * bundle.BUNDLE_SIZE
+	fmt.Printf("🔢 Operations (estimate)\n")
+	fmt.Printf("   Total:         %s\n", formatNumber(totalOps))
+	if duration.Hours() > 0 {
+		opsPerHour := float64(totalOps) / duration.Hours()
+		fmt.Printf("   Rate:          %.0f ops/hour\n", opsPerHour)
+	}
+	fmt.Printf("\n")
+
+	// Gaps
+	gaps := index.FindGaps()
+	if len(gaps) > 0 {
+		fmt.Printf("⚠️  Missing Bundles: %d\n", len(gaps))
+		if len(gaps) <= 10 || verbose {
+			fmt.Printf("   ")
+			for i, gap := range gaps {
+				if i > 0 {
+					fmt.Printf(", ")
+				}
+				if i > 0 && i%10 == 0 {
+					fmt.Printf("\n   ")
+				}
+				fmt.Printf("%06d", gap)
+			}
+			fmt.Printf("\n")
+		} else {
+			fmt.Printf("   First few: ")
+			for i := 0; i < 5; i++ {
+				if i > 0 {
+					fmt.Printf(", ")
+				}
+				fmt.Printf("%06d", gaps[i])
+			}
+			fmt.Printf(" ... (use -v to show all)\n")
+		}
+		fmt.Printf("\n")
+	}
+
+	// Mempool
+	mempoolStats := mgr.GetMempoolStats()
+	mempoolCount := mempoolStats["count"].(int)
+	if mempoolCount > 0 {
+		targetBundle := mempoolStats["target_bundle"].(int)
+		canCreate := mempoolStats["can_create_bundle"].(bool)
+		progress := float64(mempoolCount) / float64(bundle.BUNDLE_SIZE) * 100
+
+		fmt.Printf("🔄 Mempool (next bundle: %06d)\n", targetBundle)
+		fmt.Printf("   Operations:    %s / %s\n", formatNumber(mempoolCount), formatNumber(bundle.BUNDLE_SIZE))
+		fmt.Printf("   Progress:      %.1f%%\n", progress)
+
+		// Progress bar
+		barWidth := 40
+		filled := int(float64(barWidth) * float64(mempoolCount) / float64(bundle.BUNDLE_SIZE))
+		if filled > barWidth {
+			filled = barWidth
+		}
+		bar := strings.Repeat("█", filled) + strings.Repeat("░", barWidth-filled)
+		fmt.Printf("   [%s]\n", bar)
+
+		if canCreate {
+			fmt.Printf("   ✓ Ready to create bundle\n")
+		} else {
+			remaining := bundle.BUNDLE_SIZE - mempoolCount
+			fmt.Printf("   Need %s more operations\n", formatNumber(remaining))
+		}
+		fmt.Printf("\n")
+	}
+
+	// Chain verification
+	if verify {
+		fmt.Printf("🔐 Chain Verification\n")
+		fmt.Printf("   Verifying %d bundles...\n", bundleCount)
+
+		ctx := context.Background()
+		result, err := mgr.VerifyChain(ctx)
+		if err != nil {
+			fmt.Printf("   ✗ Verification failed: %v\n", err)
+		} else if result.Valid {
+			fmt.Printf("   ✓ Chain is valid\n")
+			fmt.Printf("   ✓ All %d bundles verified\n", len(result.VerifiedBundles))
+
+			// Show head hash
+			lastMeta, _ := index.GetBundle(lastBundle)
+			if lastMeta != nil {
+				fmt.Printf("   Head: %s\n", lastMeta.Hash[:16]+"...")
+			}
+		} else {
+			fmt.Printf("   ✗ Chain is broken\n")
+			fmt.Printf("   Verified: %d/%d bundles\n", len(result.VerifiedBundles), bundleCount)
+			fmt.Printf("   Broken at: %06d\n", result.BrokenAt)
+			fmt.Printf("   Error: %s\n", result.Error)
+		}
+		fmt.Printf("\n")
+	}
+
+	// Timeline visualization
+	if showTimeline {
+		fmt.Printf("📈 Timeline Visualization\n")
+		visualizeTimeline(index, verbose)
+		fmt.Printf("\n")
+	}
+
+	// Bundle list
+	if showBundles {
+		bundles := index.GetBundles()
+		fmt.Printf("📚 Bundle List (%d total)\n", len(bundles))
+		fmt.Printf("\n")
+		fmt.Printf("   Number   | Start Time          | End Time            | Ops    | DIDs   | Size\n")
+		fmt.Printf("   ---------|---------------------|---------------------|--------|--------|--------\n")
+
+		for _, meta := range bundles {
+			fmt.Printf("   %06d   | %s | %s | %6d | %6d | %7s\n",
+				meta.BundleNumber,
+				meta.StartTime.Format("2006-01-02 15:04"),
+				meta.EndTime.Format("2006-01-02 15:04"),
+				meta.OperationCount,
+				meta.DIDCount,
+				formatBytes(meta.CompressedSize))
+		}
+		fmt.Printf("\n")
+	} else if bundleCount > 0 {
+		fmt.Printf("💡 Tip: Use --bundles to see detailed bundle list\n")
+		fmt.Printf("        Use --timeline to see timeline visualization\n")
+		fmt.Printf("        Use --verify to verify chain integrity\n")
+		fmt.Printf("\n")
+	}
+
+	// File system stats (verbose)
+	if verbose {
+		fmt.Printf("💾 File System\n")
+
+		// Calculate average compression ratio
+		bundles := index.GetBundles()
+		var totalCompressed, totalUncompressed int64
+		for _, meta := range bundles {
+			totalCompressed += meta.CompressedSize
+			totalUncompressed += meta.UncompressedSize
+		}
+		if totalCompressed > 0 {
+			avgRatio := float64(totalUncompressed) / float64(totalCompressed)
+			savings := (1 - float64(totalCompressed)/float64(totalUncompressed)) * 100
+			fmt.Printf("   Compression:   %.2fx average ratio\n", avgRatio)
+			fmt.Printf("   Space Saved:   %.1f%% (%s)\n", savings, formatBytes(totalUncompressed-totalCompressed))
+		}
+
+		// Index size
+		indexPath := info["index_path"].(string)
+		if indexInfo, err := os.Stat(indexPath); err == nil {
+			fmt.Printf("   Index Size:    %s\n", formatBytes(indexInfo.Size()))
+		}
+
+		fmt.Printf("\n")
+	}
+}
+
+func visualizeTimeline(index *bundle.Index, verbose bool) {
+	bundles := index.GetBundles()
+	if len(bundles) == 0 {
+		return
+	}
+
+	// Group bundles by date
+	type dateGroup struct {
+		date  string
+		count int
+		first int
+		last  int
+	}
+
+	dateMap := make(map[string]*dateGroup)
+	for _, meta := range bundles {
+		dateStr := meta.StartTime.Format("2006-01-02")
+		if group, exists := dateMap[dateStr]; exists {
+			group.count++
+			group.last = meta.BundleNumber
+		} else {
+			dateMap[dateStr] = &dateGroup{
+				date:  dateStr,
+				count: 1,
+				first: meta.BundleNumber,
+				last:  meta.BundleNumber,
+			}
+		}
+	}
+
+	// Sort dates
+	var dates []string
+	for date := range dateMap {
+		dates = append(dates, date)
+	}
+	sort.Strings(dates)
+
+	// Find max count for scaling
+	maxCount := 0
+	for _, group := range dateMap {
+		if group.count > maxCount {
+			maxCount = group.count
+		}
+	}
+
+	// Display
+	fmt.Printf("\n")
+	barWidth := 40
+	for _, date := range dates {
+		group := dateMap[date]
+		barLen := int(float64(barWidth) * float64(group.count) / float64(maxCount))
+		if barLen == 0 && group.count > 0 {
+			barLen = 1
+		}
+
+		bar := strings.Repeat("█", barLen)
+		fmt.Printf("   %s | %-40s | %3d bundles", group.date, bar, group.count)
+		if verbose {
+			fmt.Printf(" (%06d-%06d)", group.first, group.last)
+		}
+		fmt.Printf("\n")
+	}
+}
+
+// Helper formatting functions
+
+func formatNumber(n int) string {
+	s := fmt.Sprintf("%d", n)
+	// Add thousand separators
+	var result []byte
+	for i, c := range s {
+		if i > 0 && (len(s)-i)%3 == 0 {
+			result = append(result, ',')
+		}
+		result = append(result, byte(c))
+	}
+	return string(result)
+}
+
+func formatBytes(bytes int64) string {
+	const unit = 1024
+	if bytes < unit {
+		return fmt.Sprintf("%d B", bytes)
+	}
+	div, exp := int64(unit), 0
+	for n := bytes / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %cB", float64(bytes)/float64(div), "KMGTPE"[exp])
+}
+
+func formatDuration(d time.Duration) string {
+	if d < time.Minute {
+		return fmt.Sprintf("%.0f seconds", d.Seconds())
+	}
+	if d < time.Hour {
+		return fmt.Sprintf("%.1f minutes", d.Minutes())
+	}
+	if d < 24*time.Hour {
+		return fmt.Sprintf("%.1f hours", d.Hours())
+	}
+	days := d.Hours() / 24
+	if days < 30 {
+		return fmt.Sprintf("%.1f days", days)
+	}
+	if days < 365 {
+		return fmt.Sprintf("%.1f months", days/30)
+	}
+	return fmt.Sprintf("%.1f years", days/365)
+}

cmd/plcbundle/main.go

···
 func cmdInfo() {
 	fs := flag.NewFlagSet("info", flag.ExitOnError)
 	bundleNum := fs.Int("bundle", 0, "specific bundle info (0 = general info)")
+	verbose := fs.Bool("v", false, "verbose output")
+	showBundles := fs.Bool("bundles", false, "show bundle list")
+	verify := fs.Bool("verify", false, "verify chain integrity")
+	showTimeline := fs.Bool("timeline", false, "show timeline visualization")
 	fs.Parse(os.Args[2:])
 
 	mgr, dir, err := getManager("")
···
 	defer mgr.Close()
 
 	if *bundleNum > 0 {
-		// Show specific bundle info
-		ctx := context.Background()
-		b, err := mgr.LoadBundle(ctx, *bundleNum)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-			os.Exit(1)
-		}
+		showBundleInfo(mgr, dir, *bundleNum, *verbose)
+	} else {
+		showGeneralInfo(mgr, dir, *verbose, *showBundles, *verify, *showTimeline)
+	}
+}
+
+func showBundleInfo(mgr *bundle.Manager, dir string, bundleNum int, verbose bool) {
+	ctx := context.Background()
+	b, err := mgr.LoadBundle(ctx, bundleNum)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(1)
+	}
 
-		fmt.Printf("Bundle %06d:\n", b.BundleNumber)
-		fmt.Printf("  Directory: %s\n", dir)
-		fmt.Printf("  Time range: %s - %s\n", b.StartTime.Format("2006-01-02 15:04:05"), b.EndTime.Format("2006-01-02 15:04:05"))
-		fmt.Printf("  Operations: %d\n", len(b.Operations))
-		fmt.Printf("  Unique DIDs: %d\n", b.DIDCount)
-		fmt.Printf("  Hash: %s\n", b.Hash)
-		fmt.Printf("  Compressed: %.2f MB\n", float64(b.CompressedSize)/(1024*1024))
-		fmt.Printf("  Uncompressed: %.2f MB\n", float64(b.UncompressedSize)/(1024*1024))
-		fmt.Printf("  Compression ratio: %.2fx\n", b.CompressionRatio())
-		fmt.Printf("  Cursor: %s\n", b.Cursor)
+	fmt.Printf("\n")
+	fmt.Printf("═══════════════════════════════════════════════════════════════\n")
+	fmt.Printf("                    Bundle %06d\n", b.BundleNumber)
+	fmt.Printf("═══════════════════════════════════════════════════════════════\n")
+	fmt.Printf("\n")
+
+	// Location
+	fmt.Printf("📁 Location\n")
+	fmt.Printf("   Directory:  %s\n", dir)
+	fmt.Printf("   File:       %06d.jsonl.zst\n", b.BundleNumber)
+	fmt.Printf("\n")
+
+	// Time Range
+	duration := b.EndTime.Sub(b.StartTime)
+	fmt.Printf("📅 Time Range\n")
+	fmt.Printf("   Start:      %s\n", b.StartTime.Format("2006-01-02 15:04:05.000 MST"))
+	fmt.Printf("   End:        %s\n", b.EndTime.Format("2006-01-02 15:04:05.000 MST"))
+	fmt.Printf("   Duration:   %s\n", formatDuration(duration))
+	fmt.Printf("   Created:    %s\n", b.CreatedAt.Format("2006-01-02 15:04:05 MST"))
+	fmt.Printf("\n")
+
+	// Content
+	fmt.Printf("📊 Content\n")
+	fmt.Printf("   Operations: %s\n", formatNumber(len(b.Operations)))
+	fmt.Printf("   Unique DIDs: %s\n", formatNumber(b.DIDCount))
+	if len(b.Operations) > 0 {
+		avgOpsPerDID := float64(len(b.Operations)) / float64(b.DIDCount)
+		fmt.Printf("   Avg ops/DID: %.2f\n", avgOpsPerDID)
+	}
+	fmt.Printf("\n")
+
+	// Size
+	fmt.Printf("💾 Size\n")
+	fmt.Printf("   Compressed:   %s\n", formatBytes(b.CompressedSize))
+	fmt.Printf("   Uncompressed: %s\n", formatBytes(b.UncompressedSize))
+	fmt.Printf("   Ratio:        %.2fx\n", b.CompressionRatio())
+	fmt.Printf("   Efficiency:   %.1f%% savings\n", (1-float64(b.CompressedSize)/float64(b.UncompressedSize))*100)
+	fmt.Printf("\n")
+
+	// Hashes
+	fmt.Printf("🔐 Cryptographic Hashes\n")
+	fmt.Printf("   Content (SHA-256):\n")
+	fmt.Printf("     %s\n", b.Hash)
+	fmt.Printf("   Compressed:\n")
+	fmt.Printf("     %s\n", b.CompressedHash)
+	if b.PrevBundleHash != "" {
+		fmt.Printf("   Previous Bundle:\n")
+		fmt.Printf("     %s\n", b.PrevBundleHash)
+	}
+	fmt.Printf("\n")
+
+	// Chain
+	if b.PrevBundleHash != "" || b.Cursor != "" {
+		fmt.Printf("🔗 Chain Information\n")
+		if b.Cursor != "" {
+			fmt.Printf("   Cursor:     %s\n", b.Cursor)
+		}
 		if b.PrevBundleHash != "" {
-			fmt.Printf("  Prev bundle hash: %s...\n", b.PrevBundleHash[:16])
+			fmt.Printf("   Links to:   Bundle %06d\n", bundleNum-1)
+		}
+		if len(b.BoundaryCIDs) > 0 {
+			fmt.Printf("   Boundary:   %d CIDs at same timestamp\n", len(b.BoundaryCIDs))
+		}
+		fmt.Printf("\n")
+	}
+
+	// Verbose: Show sample operations
+	if verbose && len(b.Operations) > 0 {
+		fmt.Printf("📝 Sample Operations (first 5)\n")
+		showCount := 5
+		if len(b.Operations) < showCount {
+			showCount = len(b.Operations)
 		}
-	} else {
-		// Show general info
-		info := mgr.GetInfo()
-		fmt.Printf("Bundle Directory: %s\n", dir)
-		fmt.Printf("Bundle count: %v\n", info["bundle_count"])
-		if bc, ok := info["bundle_count"].(int); ok && bc > 0 {
-			fmt.Printf("Range: %06d - %06d\n", info["first_bundle"], info["last_bundle"])
-			fmt.Printf("Total size: %.2f MB\n", float64(info["total_size"].(int64))/(1024*1024))
-			if gaps, ok := info["gaps"].(int); ok && gaps > 0 {
-				fmt.Printf("⚠ Missing bundles: %d\n", gaps)
+		for i := 0; i < showCount; i++ {
+			op := b.Operations[i]
+			fmt.Printf("   %d. %s\n", i+1, op.DID)
+			fmt.Printf("      CID: %s\n", op.CID)
+			fmt.Printf("      Time: %s\n", op.CreatedAt.Format("2006-01-02 15:04:05.000"))
+			if op.IsNullified() {
+				fmt.Printf("      ⚠️  Nullified: %s\n", op.GetNullifyingCID())
 			}
 		}
-		fmt.Printf("Index updated: %s\n", info["updated_at"])
+		fmt.Printf("\n")
+	}
+
+	// Verbose: Show DID statistics
+	if verbose && len(b.Operations) > 0 {
+		didOps := make(map[string]int)
+		for _, op := range b.Operations {
+			didOps[op.DID]++
+		}
+
+		// Find most active DIDs
+		type didCount struct {
+			did   string
+			count int
+		}
+		var counts []didCount
+		for did, count := range didOps {
+			counts = append(counts, didCount{did, count})
+		}
+		sort.Slice(counts, func(i, j int) bool {
+			return counts[i].count > counts[j].count
+		})
+
+		fmt.Printf("🏆 Most Active DIDs\n")
+		showCount := 5
+		if len(counts) < showCount {
+			showCount = len(counts)
+		}
+		for i := 0; i < showCount; i++ {
+			fmt.Printf("   %d. %s (%d ops)\n", i+1, counts[i].did, counts[i].count)
+		}
+		fmt.Printf("\n")
 	}
 }
 

cmd/plcbundle/server.go

···
 	index := mgr.GetIndex()
 	bundles := index.GetBundles()
 
-	currentRecord := 0
+	if len(bundles) == 0 {
+		return
+	}
+
+	// Calculate starting bundle and position from cursor
+	// Each bundle has exactly BUNDLE_SIZE (10,000) operations
+	// Cursor 88410345 = bundle 8841, position 345
+	startBundleIdx := cursor / bundle.BUNDLE_SIZE
+	startPosition := cursor % bundle.BUNDLE_SIZE
+
+	// Validate starting bundle exists
+	if startBundleIdx >= len(bundles) {
+		// Cursor is beyond all bundles, check mempool
+		currentRecord := len(bundles) * bundle.BUNDLE_SIZE
+		streamMempool(conn, mgr, cursor, currentRecord)
+		return
+	}
 
-	// Stream all operations from all bundles
-	for _, meta := range bundles {
+	currentRecord := cursor
+
+	// Stream bundles starting from the calculated bundle
+	for i := startBundleIdx; i < len(bundles); i++ {
+		meta := bundles[i]
+
 		// Load bundle
 		b, err := mgr.LoadBundle(ctx, meta.BundleNumber)
 		if err != nil {
···
 			continue
 		}
 
-		// Send each operation
-		for _, op := range b.Operations {
-			// Skip records before cursor
-			if currentRecord < cursor {
-				currentRecord++
-				continue
-			}
+		// Determine starting position in this bundle
+		startPos := 0
+		if i == startBundleIdx {
+			startPos = startPosition
+		}
+
+		// Send operations from this bundle
+		for j := startPos; j < len(b.Operations); j++ {
+			op := b.Operations[j]
 
 			// Send raw JSON
 			if err := sendOperation(conn, op); err != nil {
···
 		}
 	}
 
-	// Stream mempool operations (seamlessly after bundles)
+	// Stream mempool operations after all bundles
+	streamMempool(conn, mgr, cursor, currentRecord)
+}
+
+// streamMempool streams mempool operations if cursor is in range
+func streamMempool(conn *websocket.Conn, mgr *bundle.Manager, cursor int, currentRecord int) {
 	mempoolOps, err := mgr.GetMempoolOperations()
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Failed to get mempool operations: %v\n", err)

plc/plc_test.go

···
 	}
 
 	logger := &benchLogger{}
-	operations, _ := bundle.NewOperations(bundle.CompressionBetter, logger)
+	operations, _ := bundle.NewOperations(logger)
 	defer operations.Close()
 
 	b.ResetTimer()

plc_bundles.json

···
-{
-  "version": "1.0",
-  "last_bundle": 0,
-  "updated_at": "2025-10-28T02:44:11.775384Z",
-  "total_size_bytes": 0,
-  "bundles": []
-}

plcbundle.go

···
 	Index                   = bundle.Index
 	Manager                 = bundle.Manager
 	Config                  = bundle.Config
-	CompressionLevel        = bundle.CompressionLevel
 	VerificationResult      = bundle.VerificationResult
 	ChainVerificationResult = bundle.ChainVerificationResult
 	DirectoryScanResult     = bundle.DirectoryScanResult
···
 const (
 	BUNDLE_SIZE = bundle.BUNDLE_SIZE
 	INDEX_FILE  = bundle.INDEX_FILE
-
-	CompressionFastest = bundle.CompressionFastest
-	CompressionDefault = bundle.CompressionDefault
-	CompressionBetter  = bundle.CompressionBetter
-	CompressionBest    = bundle.CompressionBest
 )
 
 // NewManager creates a new bundle manager (convenience wrapper)