verbose update

bundle/bundle_test.go

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

bundle/manager.go

···
 	}
 
 	// Initialize operations handler
-	ops, err := storage.NewOperations(config.Logger)
+	ops, err := storage.NewOperations(config.Logger, config.Verbose)
 	if err != nil {
 		return nil, fmt.Errorf("failed to initialize operations: %w", err)
 	}
···
 	// Get hostname
 	hostname, _ := os.Hostname()
 
-	// ✅ Create BundleInfo
+	// Create BundleInfo
 	bundleInfo := &storage.BundleInfo{
 		BundleNumber: bundle.BundleNumber,
 		Origin:       origin,
···
 
 	m.logger.Printf("DEBUG: Calling operations.SaveBundle with bundle=%d", bundleInfo.BundleNumber)
 
-	// ✅ Save to disk with 3 parameters
+	// Save to disk with 3 parameters
 	uncompressedHash, compressedHash, uncompressedSize, compressedSize, err := m.operations.SaveBundle(path, bundle.Operations, bundleInfo)
 	if err != nil {
 		m.logger.Printf("DEBUG: SaveBundle FAILED: %v", err)
···
 		if err := plcclient.ValidateDIDFormat(input); err != nil {
 			return "", 0, err
 		}
-		return input, 0, nil // ✅ No resolution needed
+		return input, 0, nil // No resolution needed
 	}
 
 	// Support did:web too

bundle/metadata.go

···
 	}
 	defer file.Close()
 
-	// ✅ Use abstracted reader from storage package
+	// Use abstracted reader from storage package
 	reader, err := storage.NewStreamingReader(file)
 	if err != nil {
 		return 0, 0, time.Time{}, time.Time{}, fmt.Errorf("failed to create reader: %w", err)

bundle/scanner.go

···
 			for num := range jobs {
 				path := filepath.Join(m.config.BundleDir, fmt.Sprintf("%06d.jsonl.zst", num))
 
-				// ✅ NEW: Stream metadata WITHOUT loading all operations
+				// Stream metadata WITHOUT loading all operations
 				meta, err := m.CalculateMetadataStreaming(num, path)
 				if err != nil {
 					results <- bundleResult{index: num, err: err}

cmd/plcbundle/commands/common.go

···
 	config := bundle.DefaultConfig(absDir)
 	config.AutoInit = opts.AutoInit
 
-	// Set verbose from command if available
+	// Check BOTH global AND local verbose flags
 	if opts.Cmd != nil {
-		if verbose, err := opts.Cmd.Root().PersistentFlags().GetBool("verbose"); err == nil {
-			config.Verbose = verbose
-		}
+		globalVerbose, _ := opts.Cmd.Root().PersistentFlags().GetBool("verbose")
+		localVerbose, _ := opts.Cmd.Flags().GetBool("verbose")
+
+		// Use OR logic: verbose if EITHER flag is set
+		config.Verbose = globalVerbose || localVerbose
 	}
 
 	// Create PLC client if URL provided
···
 	// Set handle resolver URL from flag or option
 	handleResolverURL := opts.HandleResolverURL
 	if handleResolverURL == "" && opts.Cmd != nil {
-		handleResolverURL, _ = opts.Cmd.Root().PersistentFlags().GetString("handle-resolver") // ✅ Fixed flag name
+		handleResolverURL, _ = opts.Cmd.Root().PersistentFlags().GetString("handle-resolver")
 	}
 	// Only override default if explicitly provided
 	if handleResolverURL != "" {

cmd/plcbundle/commands/inspect.go

···
 	result.FileSize = info.Size()
 
 	// Check for frame index
-	ops := &storage.Operations{}
+	ops, _ := storage.NewOperations(nil, opts.verbose)
+
 	if _, err := ops.ExtractBundleMetadata(bundlePath); err == nil {
 		result.HasFrameIndex = true // Has embedded index
 	} else {
···
 		fmt.Fprintf(os.Stderr, "Reading embedded metadata...\n")
 		metaStart := time.Now()
 
-		ops := &storage.Operations{}
+		ops, _ := storage.NewOperations(nil, opts.verbose)
+
 		meta, err := ops.ExtractBundleMetadata(bundlePath)
 		if err != nil {
 			if opts.verbose {
···
 		fmt.Fprintf(os.Stderr, "Verifying cryptographic hashes...\n")
 		verifyStart := time.Now()
 
-		// ✅ Pass cmd parameter
+		// Pass cmd parameter
 		result.ContentHashValid, result.CompressedHashValid, result.MetadataValid =
 			verifyCrypto(cmd, bundlePath, result.Metadata, bundleNum, opts.verbose)
 
···
 // ============================================================================
 
 func analyzeBundle(path string, opts inspectOptions) (*bundleAnalysis, error) {
-	ops := &storage.Operations{}
+	ops, _ := storage.NewOperations(nil, opts.verbose)
 	operations, err := ops.LoadBundle(path)
 	if err != nil {
 		return nil, err
···
 }
 
 func verifyCrypto(cmd *cobra.Command, path string, meta *storage.BundleMetadata, bundleNum int, verbose bool) (contentValid, compressedValid, metadataValid bool) {
-	ops := &storage.Operations{}
+	ops, _ := storage.NewOperations(nil, verbose)
 
 	// Calculate actual hashes from file
 	compHash, compSize, contentHash, contentSize, err := ops.CalculateFileHashes(path)
···
 	compressedValid = true
 	metadataValid = true
 
-	// ✅ Verify against embedded metadata if available
+	// Verify against embedded metadata if available
 	if meta != nil {
 		// Check content hash (this is in the metadata)
 		if meta.ContentHash != "" && meta.ContentHash != contentHash {
···
 			metadataValid = true
 		}
 
-		// ✅ Note: We don't check compressed hash/size because they're not in metadata
+		// Note: We don't check compressed hash/size because they're not in metadata
 		// (The file IS the compressed data, so it's redundant)
 
 		if verbose {
···
 		}
 	}
 
-	// ✅ Also verify against repository index if bundle number is known
+	// Also verify against repository index if bundle number is known
 	if bundleNum > 0 {
 		mgr, _, err := getManager(&ManagerOptions{Cmd: cmd})
 		if err == nil {

cmd/plcbundle/commands/migrate.go

···
 	hashChanges := make([]int, 0, len(needsMigration))
 
 	for i, bundleNum := range needsMigration {
-		// ✅ Pass version to migrateBundle
+		// Pass version to migrateBundle
 		if err := migrateBundle(dir, bundleNum, index, version, opts.verbose); err != nil {
 			failed++
 			if firstError == nil {
···
 	progress.Finish()
 	elapsed := time.Since(start)
 
-	// ✅ Update index with new compressed hashes
+	// Update index with new compressed hashes
 	if len(hashChanges) > 0 {
 		fmt.Printf("\nUpdating bundle index...\n")
 		updateStart := time.Now()
···
 		fmt.Printf("  Index updated: %d entries\n", len(hashChanges))
 		fmt.Printf("  Speed:        %.1f bundles/sec\n\n", float64(success)/elapsed.Seconds())
 
-		fmt.Printf("✨ New bundle format features:\n")
-		fmt.Printf("   • Embedded metadata (JSON in skippable frame)\n")
-		fmt.Printf("   • Frame offsets for instant random access\n")
-		fmt.Printf("   • Multi-frame compression (100 ops/frame)\n")
-		fmt.Printf("   • Self-contained (no .idx files)\n")
-		fmt.Printf("   • Provenance tracking (version, origin, creator)\n")
-		fmt.Printf("   • Compatible with standard zstd tools\n")
 	} else {
 		fmt.Printf("⚠️  Migration completed with errors\n")
 		fmt.Printf("  Success:  %d bundles\n", success)
···
 	// 4. Get hostname (optional)
 	hostname, _ := os.Hostname()
 
-	// 5. ✅ Create BundleInfo for new format
+	// 5. Create BundleInfo for new format
 	bundleInfo := &storage.BundleInfo{
 		BundleNumber: meta.BundleNumber,
 		Origin:       index.Origin, // From index

cmd/plcbundle/commands/op.go

···
 
 			ctx := context.Background()
 
-			// ✅ Time the operation load
+			// Time the operation load
 			totalStart := time.Now()
 			op, err := mgr.LoadOperation(ctx, bundleNum, position)
 			totalDuration := time.Since(totalStart)
···
 				return err
 			}
 
-			// Output timing to stderr if verbose
 			if verbose {
 				globalPos := (bundleNum * 10000) + position
 
-				fmt.Fprintf(os.Stderr, "Operation Load Metrics\n")
-				fmt.Fprintf(os.Stderr, "══════════════════════\n\n")
-				fmt.Fprintf(os.Stderr, "  Location:       Bundle %06d, Position %04d\n", bundleNum, position)
-				fmt.Fprintf(os.Stderr, "  Global Position: %d\n", globalPos)
-				fmt.Fprintf(os.Stderr, "  Total Time:      %s\n", totalDuration)
-
-				// Calculate throughput
-				if len(op.RawJSON) > 0 {
-					mbPerSec := float64(len(op.RawJSON)) / totalDuration.Seconds() / (1024 * 1024)
-					fmt.Fprintf(os.Stderr, "  Data Size:       %d bytes\n", len(op.RawJSON))
-					fmt.Fprintf(os.Stderr, "  Throughput:      %.2f MB/s\n", mbPerSec)
-				}
-
+				// Log-style output (compact, single-line friendly)
+				fmt.Fprintf(os.Stderr, "[Load] Bundle %06d:%04d (pos=%d) in %s",
+					bundleNum, position, globalPos, totalDuration)
+				fmt.Fprintf(os.Stderr, " | %d bytes", len(op.RawJSON))
 				fmt.Fprintf(os.Stderr, "\n")
 			}
 
···
 
 			ctx := context.Background()
 
-			// ✅ Time the operation
+			// Time the operation
 			loadStart := time.Now()
 			op, err := mgr.LoadOperation(ctx, bundleNum, position)
 			loadDuration := time.Since(loadStart)
···
 				return err
 			}
 
-			// ✅ Time the parsing
+			// Time the parsing
 			parseStart := time.Now()
 			opData, parseErr := op.GetOperationData()
 			parseDuration := time.Since(parseStart)
···
 	fmt.Printf("──────\n")
 	fmt.Printf("  %s\n\n", status)
 
-	// ✅ Performance metrics (always shown if verbose)
+	// Performance metrics (always shown if verbose)
 	if verbose {
 		totalTime := loadDuration + parseDuration
 

internal/didindex/builder.go

···
 
 	type tempEntry struct {
 		identifier string
-		location   OpLocation // ← Single packed value
+		location   OpLocation
 	}
 
 	entries := make([]tempEntry, entryCount)
 	for i := 0; i < entryCount; i++ {
-		offset := i * 28 // ← 28 bytes
+		offset := i * 28
 		entries[i] = tempEntry{
 			identifier: string(data[offset : offset+24]),
 			location:   OpLocation(binary.LittleEndian.Uint32(data[offset+24 : offset+28])),

internal/didindex/manager.go

···
 		dim.logger.Printf("DEBUG: Shard %02x loaded, size: %d bytes", shardNum, len(shard.data))
 	}
 
-	// ✅ Safe to read - refcount prevents eviction
+	// Safe to read - refcount prevents eviction
 	locations := dim.searchShard(shard, identifier)
 
 	if dim.verbose {
···
 	// Read locations
 	locations := make([]OpLocation, count)
 	for i := 0; i < int(count); i++ {
-		if offset+4 > len(data) { // ← 4 bytes now
+		if offset+4 > len(data) {
 			return locations[:i]
 		}
 
···
 		packed := binary.LittleEndian.Uint32(data[offset : offset+4])
 		locations[i] = OpLocation(packed)
 
-		offset += 4 // ← 4 bytes
+		offset += 4
 	}
 
 	return locations
···
 	for i, id := range identifiers {
 		offsetTable[i] = uint32(currentOffset)
 		locations := builder.entries[id]
-		entrySize := DID_IDENTIFIER_LEN + 2 + (len(locations) * 4) // ← 4 bytes
+		entrySize := DID_IDENTIFIER_LEN + 2 + (len(locations) * 4)
 		currentOffset += entrySize
 	}
 
···
 		for _, loc := range locations {
 			// Write packed uint32 (global position + nullified bit)
 			binary.LittleEndian.PutUint32(buf[offset:offset+4], uint32(loc))
-			offset += 4 // ← 4 bytes per location
+			offset += 4
 		}
 	}
 

internal/mempool/mempool_test.go

···
 		m.Save()
 
 		// Add 10 more and save
-		// FIX: makeTestOperationsFrom(start, COUNT) - so we want (10, 10) not (10, 20)
-		ops2 := makeTestOperationsFrom(10, 10) // ← Changed from (10, 20)
+		ops2 := makeTestOperationsFrom(10, 10)
 		m.Add(ops2)
 		m.Save()
 

internal/plcclient/plc_test.go

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

internal/plcclient/resolver.go

···
 	// Base contexts - ALWAYS include multikey (matches PLC directory behavior)
 	contexts := []string{
 		"https://www.w3.org/ns/did/v1",
-		"https://w3id.org/security/multikey/v1", // ← Always include this
+		"https://w3id.org/security/multikey/v1",
 	}
 
 	hasSecp256k1 := false
···
 	doc := &DIDDocument{
 		Context:            contexts,
 		ID:                 state.DID,
-		AlsoKnownAs:        []string{},             // ← Empty slice
-		VerificationMethod: []VerificationMethod{}, // ← Empty slice
-		Service:            []Service{},            // ← Empty slice
+		AlsoKnownAs:        []string{},
+		VerificationMethod: []VerificationMethod{},
+		Service:            []Service{},
 	}
 
 	// Copy alsoKnownAs if present

internal/storage/storage.go

···
 	StartTime      time.Time `json:"start_time"`      // First operation timestamp
 	EndTime        time.Time `json:"end_time"`        // Last operation timestamp
 
-	// === Frame Structure (for random access) ===
-	FrameCount   int     `json:"frame_count"`   // Number of zstd frames (usually 100)
-	FrameSize    int     `json:"frame_size"`    // Operations per frame (100)
-	FrameOffsets []int64 `json:"frame_offsets"` // Byte offsets of each frame
+	// === Creation Provenance ===
+	CreatedAt     time.Time `json:"created_at"`                // When bundle was created
+	CreatedBy     string    `json:"created_by"`                // "plcbundle/v1.2.3"
+	CreatedByHost string    `json:"created_by_host,omitempty"` // Optional: hostname that created it
 
 	// === Optional Context ===
 	Cursor string `json:"cursor,omitempty"` // PLC export cursor for this bundle
 	Notes  string `json:"notes,omitempty"`  // Optional description
 
-	// === Creation Provenance ===
-	CreatedAt     time.Time `json:"created_at"`                // When bundle was created
-	CreatedBy     string    `json:"created_by"`                // "plcbundle/v1.2.3"
-	CreatedByHost string    `json:"created_by_host,omitempty"` // Optional: hostname that created it
+	// === Frame Structure (for random access) ===
+	FrameCount   int     `json:"frame_count"`   // Number of zstd frames (usually 100)
+	FrameSize    int     `json:"frame_size"`    // Operations per frame (100)
+	FrameOffsets []int64 `json:"frame_offsets"` // Byte offsets of each frame
 }
 
 // Operations handles low-level bundle file operations
 type Operations struct {
-	logger Logger
+	logger  Logger
+	verbose bool
 }
 
 // Logger interface
···
 	Println(v ...interface{})
 }
 
-func NewOperations(logger Logger) (*Operations, error) {
-	return &Operations{logger: logger}, nil
+func NewOperations(logger Logger, verbose bool) (*Operations, error) {
+	return &Operations{
+		logger:  logger,
+		verbose: verbose,
+	}, nil
 }
 
 func (op *Operations) Close() {
···
 		compressedFrames = append(compressedFrames, compressedChunk)
 	}
 
-	// 3. ✅ Calculate RELATIVE offsets (relative to first data frame)
+	// 3. Calculate RELATIVE offsets (relative to first data frame)
 	relativeOffsets := make([]int64, len(compressedFrames)+1)
 	relativeOffsets[0] = 0
 
···
 		relativeOffsets[i+1] = cumulative
 	}
 
-	// 4. ✅ Build metadata with RELATIVE offsets
+	// 4. Build metadata with RELATIVE offsets
 	metadata := &BundleMetadata{
 		Format:         fmt.Sprintf("plcbundle-v%d", MetadataFormatVersion),
 		BundleNumber:   bundleInfo.BundleNumber,
···
 		FrameCount:     len(compressedFrames),
 		FrameSize:      FrameSize,
 		Cursor:         bundleInfo.Cursor,
-		FrameOffsets:   relativeOffsets, // ✅ RELATIVE to data start!
+		FrameOffsets:   relativeOffsets, // RELATIVE to data start!
 	}
 
 	if len(operations) > 0 {
···
 	}()
 
 	// Write metadata frame
-	if _, err := WriteMetadataFrame(finalFile, metadata); err != nil {
+	if _, err := op.WriteMetadataFrame(finalFile, metadata); err != nil {
 		return "", "", 0, 0, fmt.Errorf("failed to write metadata: %w", err)
 	}
 
···
 	}
 	defer file.Close()
 
-	// ✅ Use abstracted streaming reader
+	// Use abstracted streaming reader
 	reader, err := NewStreamingReader(file)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create reader: %w", err)
···
 		return nil, fmt.Errorf("failed to open bundle: %w", err)
 	}
 
-	// ✅ Use abstracted reader
+	// Use abstracted reader
 	reader, err := NewStreamingReader(file)
 	if err != nil {
 		file.Close()
···
 	compressedHash = op.Hash(compressedData)
 	compressedSize = int64(len(compressedData))
 
-	// ✅ Use abstracted decompression
+	// Use abstracted decompression
 	decompressed, err := DecompressAll(compressedData)
 	if err != nil {
 		return "", 0, "", 0, fmt.Errorf("failed to decompress: %w", err)
···
 		return nil, fmt.Errorf("invalid position: %d", position)
 	}
 
-	// ✅ Try multiple sources for frame index (no goto!)
+	// Try multiple sources for frame index (no goto!)
 	frameOffsets, err := op.loadFrameIndex(path)
 	if err != nil {
 		// No frame index available - use legacy full scan
···
 // loadFrameIndex loads frame offsets and converts to absolute positions
 func (op *Operations) loadFrameIndex(path string) ([]int64, error) {
 	// Try embedded metadata first
-	meta, err := ExtractMetadataFromFile(path)
+	meta, err := op.ExtractMetadataFromFile(path)
 	if err == nil && len(meta.FrameOffsets) > 0 {
-		// ✅ Convert relative offsets to absolute
+		// Convert relative offsets to absolute
 		// First, get metadata frame size by re-reading
 		file, _ := os.Open(path)
 		if file != nil {
 			defer file.Close()
 
 			// Read metadata frame to find where data starts
-			magic, data, readErr := ReadSkippableFrame(file)
+			magic, data, readErr := op.ReadSkippableFrame(file)
 			if readErr == nil && magic == SkippableMagicMetadata {
 				// Metadata frame size = 4 (magic) + 4 (size) + len(data)
 				metadataFrameSize := int64(8 + len(data))
···
 	endOffset := frameOffsets[frameIndex+1]
 	frameLength := endOffset - startOffset
 
-	// ✅ DEBUG
-	if op.logger != nil {
-		op.logger.Printf("DEBUG: Frame %d: offset %d-%d, length %d bytes",
-			frameIndex, startOffset, endOffset, frameLength)
-	}
-
 	if frameLength <= 0 || frameLength > 10*1024*1024 {
 		return nil, fmt.Errorf("invalid frame length: %d (offsets: %d-%d)",
 			frameLength, startOffset, endOffset)
···
 	defer bundleFile.Close()
 
 	compressedFrame := make([]byte, frameLength)
-	n, err := bundleFile.ReadAt(compressedFrame, startOffset)
+	_, err = bundleFile.ReadAt(compressedFrame, startOffset)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read frame %d (offset %d, length %d): %w",
 			frameIndex, startOffset, frameLength, err)
 	}
 
-	if op.logger != nil {
-		op.logger.Printf("DEBUG: Read %d bytes from offset %d", n, startOffset)
-	}
-
 	// Decompress
 	decompressed, err := DecompressFrame(compressedFrame)
 	if err != nil {
-		// ✅ DEBUG: Show first few bytes to diagnose
 		if op.logger != nil {
 			preview := compressedFrame
 			if len(preview) > 16 {
 				preview = preview[:16]
 			}
-			op.logger.Printf("DEBUG: Failed frame data (first 16 bytes): % x", preview)
+			if op.verbose {
+				op.logger.Printf("DEBUG: Failed frame data (first 16 bytes): % x", preview)
+			}
 		}
 		return nil, fmt.Errorf("failed to decompress frame %d: %w", frameIndex, err)
 	}
···
 	}
 	defer file.Close()
 
-	// ✅ Use abstracted streaming reader
+	// Use abstracted streaming reader
 	reader, err := NewStreamingReader(file)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create reader: %w", err)
···
 	}
 	defer file.Close()
 
-	// ✅ Use abstracted streaming reader
+	// Use abstracted streaming reader
 	reader, err := NewStreamingReader(file)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create reader: %w", err)
···
 	}
 	defer file.Close()
 
-	// ✅ Use abstracted reader
+	// Use abstracted reader
 	reader, err := NewStreamingReader(file)
 	if err != nil {
 		return 0, 0, time.Time{}, time.Time{}, fmt.Errorf("failed to create reader: %w", err)
···
 
 // ExtractBundleMetadata extracts metadata from bundle file without decompressing
 func (op *Operations) ExtractBundleMetadata(path string) (*BundleMetadata, error) {
-	meta, err := ExtractMetadataFromFile(path)
+	meta, err := op.ExtractMetadataFromFile(path)
 	if err != nil {
 		return nil, fmt.Errorf("failed to extract metadata: %w", err)
 	}
···
 	defer file.Close()
 
 	// 1. Try to read metadata frame first
-	meta, err := ReadMetadataFrame(file)
+	meta, err := op.ReadMetadataFrame(file)
 	if err != nil {
 		// No metadata frame - fall back to regular load
 		file.Seek(0, io.SeekStart) // Reset to beginning

internal/storage/storage_test.go

···
 func TestStorageCompression(t *testing.T) {
 	tmpDir := t.TempDir()
 	logger := &testLogger{t: t}
-	ops, err := storage.NewOperations(logger)
+	ops, err := storage.NewOperations(logger, false)
 	if err != nil {
 		t.Fatalf("NewOperations failed: %v", err)
 	}
···
 
 func TestStorageHashing(t *testing.T) {
 	logger := &testLogger{t: t}
-	ops, err := storage.NewOperations(logger)
+	ops, err := storage.NewOperations(logger, false)
 	if err != nil {
 		t.Fatalf("NewOperations failed: %v", err)
 	}
···
 func TestStorageConcurrency(t *testing.T) {
 	tmpDir := t.TempDir()
 	logger := &testLogger{t: t}
-	ops, err := storage.NewOperations(logger)
+	ops, err := storage.NewOperations(logger, false)
 	if err != nil {
 		t.Fatalf("NewOperations failed: %v", err)
 	}
···
 func TestStorageEdgeCases(t *testing.T) {
 	tmpDir := t.TempDir()
 	logger := &testLogger{t: t}
-	ops, err := storage.NewOperations(logger)
+	ops, err := storage.NewOperations(logger, false)
 	if err != nil {
 		t.Fatalf("NewOperations failed: %v", err)
 	}
···
 
 func TestStorageBoundaryConditions(t *testing.T) {
 	logger := &testLogger{t: t}
-	ops, err := storage.NewOperations(logger)
+	ops, err := storage.NewOperations(logger, false)
 	if err != nil {
 		t.Fatalf("NewOperations failed: %v", err)
 	}
···
 
 func TestStorageSerialization(t *testing.T) {
 	logger := &testLogger{t: t}
-	ops, err := storage.NewOperations(logger)
+	ops, err := storage.NewOperations(logger, false)
 	if err != nil {
 		t.Fatalf("NewOperations failed: %v", err)
 	}
···
 func TestStorageUtilities(t *testing.T) {
 	tmpDir := t.TempDir()
 	logger := &testLogger{t: t}
-	ops, err := storage.NewOperations(logger)
+	ops, err := storage.NewOperations(logger, false)
 	if err != nil {
 		t.Fatalf("NewOperations failed: %v", err)
 	}
···
 func TestStorageStreaming(t *testing.T) {
 	tmpDir := t.TempDir()
 	logger := &testLogger{t: t}
-	ops, err := storage.NewOperations(logger)
+	ops, err := storage.NewOperations(logger, false)
 	if err != nil {
 		t.Fatalf("NewOperations failed: %v", err)
 	}
···
 func BenchmarkStorageOperations(b *testing.B) {
 	tmpDir := b.TempDir()
 	logger := &testLogger{t: &testing.T{}}
-	ops, _ := storage.NewOperations(logger)
+	ops, _ := storage.NewOperations(logger, false)
 	defer ops.Close()
 
 	operations := makeTestOperations(10000)

internal/storage/zstd.go

···
 }
 
 // ReadSkippableFrame with debug
-func ReadSkippableFrame(r io.Reader) (uint32, []byte, error) {
+func (ops *Operations) ReadSkippableFrame(r io.Reader) (uint32, []byte, error) {
 	var magic uint32
 	if err := binary.Read(r, binary.LittleEndian, &magic); err != nil {
 		return 0, nil, fmt.Errorf("failed to read magic: %w", err)
 	}
-
-	fmt.Fprintf(os.Stderr, "DEBUG: Read magic number: 0x%08X\n", magic)
 
 	if magic < 0x184D2A50 || magic > 0x184D2A5F {
 		return 0, nil, fmt.Errorf("not a skippable frame: magic=0x%08X (expected 0x184D2A50-0x184D2A5F)", magic)
···
 		return 0, nil, fmt.Errorf("failed to read frame size: %w", err)
 	}
 
-	fmt.Fprintf(os.Stderr, "DEBUG: Frame size: %d bytes\n", frameSize)
-
 	data := make([]byte, frameSize)
 	if _, err := io.ReadFull(r, data); err != nil {
 		return 0, nil, fmt.Errorf("failed to read frame data: %w", err)
 	}
-
-	fmt.Fprintf(os.Stderr, "DEBUG: Read %d bytes of frame data\n", len(data))
 
 	return magic, data, nil
 }
 
 // WriteMetadataFrame writes bundle metadata as skippable frame (compact JSON)
-func WriteMetadataFrame(w io.Writer, meta *BundleMetadata) (int64, error) {
+func (op *Operations) WriteMetadataFrame(w io.Writer, meta *BundleMetadata) (int64, error) {
 	jsonData, err := json.Marshal(meta)
 	if err != nil {
 		return 0, fmt.Errorf("failed to marshal metadata: %w", err)
···
 }
 
 // ReadMetadataFrame reads bundle metadata from skippable frame
-func ReadMetadataFrame(r io.Reader) (*BundleMetadata, error) {
-	magic, data, err := ReadSkippableFrame(r)
+func (ops *Operations) ReadMetadataFrame(r io.Reader) (*BundleMetadata, error) {
+	magic, data, err := ops.ReadSkippableFrame(r)
 	if err != nil {
 		return nil, err
 	}
···
 }
 
 // ExtractMetadataFromFile reads metadata without decompressing
-func ExtractMetadataFromFile(path string) (*BundleMetadata, error) {
+func (ops *Operations) ExtractMetadataFromFile(path string) (*BundleMetadata, error) {
 	file, err := os.Open(path)
 	if err != nil {
 		return nil, err
 	}
 	defer file.Close()
 
-	// ✅ DEBUG: Check first bytes
+	// Check first bytes
 	header := make([]byte, 8)
 	if _, err := file.Read(header); err != nil {
 		return nil, fmt.Errorf("failed to read header: %w", err)
 	}
 
-	fmt.Fprintf(os.Stderr, "DEBUG: First 8 bytes: % x\n", header)
-
 	// Seek back to start
 	file.Seek(0, io.SeekStart)
 
-	meta, err := ReadMetadataFrame(file)
+	meta, err := ops.ReadMetadataFrame(file)
 	if err != nil {
 		return nil, fmt.Errorf("no metadata frame found: %w", err)
 	}
···
 }
 
 // ExtractFrameIndexFromFile now just reads from metadata
-func ExtractFrameIndexFromFile(path string) ([]int64, error) {
-	meta, err := ExtractMetadataFromFile(path)
+func (ops *Operations) ExtractFrameIndexFromFile(path string) ([]int64, error) {
+	meta, err := ops.ExtractMetadataFromFile(path)
 	if err != nil {
 		return nil, err
 	}
···
 }
 
 // DebugFrameOffsets extracts and displays frame offset information
-func DebugFrameOffsets(path string) error {
-	meta, err := ExtractMetadataFromFile(path)
+func (ops *Operations) DebugFrameOffsets(path string) error {
+	meta, err := ops.ExtractMetadataFromFile(path)
 	if err != nil {
 		return fmt.Errorf("failed to extract metadata: %w", err)
 	}

internal/sync/fetcher.go

···
 
 	seenCIDs := make(map[string]bool)
 
-	// ✅ Initialize current boundaries from previous bundle (or empty if first fetch)
+	// Initialize current boundaries from previous bundle (or empty if first fetch)
 	currentBoundaryCIDs := prevBoundaryCIDs
 	if currentBoundaryCIDs == nil {
 		currentBoundaryCIDs = make(map[string]bool)
···
 		originalBatchSize := len(batch)
 		totalReceived += originalBatchSize
 
-		// ✅ CRITICAL: Strip boundary duplicates using current boundaries
+		// CRITICAL: Strip boundary duplicates using current boundaries
 		batch = f.operations.StripBoundaryDuplicates(
 			batch,
 			currentAfter,
···
 				}
 			}
 
-			// ✅ CRITICAL: Calculate NEW boundary CIDs from this fetch for next iteration
+			// CRITICAL: Calculate NEW boundary CIDs from this fetch for next iteration
 			if len(batch) > 0 {
 				boundaryTime, newBoundaryCIDs := f.operations.GetBoundaryCIDs(batch)
 				currentBoundaryCIDs = newBoundaryCIDs
···
 			}
 			allNewOps = append(allNewOps, batchNewOps...)
 
-			// ✅ Still update boundaries even without mempool
+			// Still update boundaries even without mempool
 			if len(batch) > 0 {
 				boundaryTime, newBoundaryCIDs := f.operations.GetBoundaryCIDs(batch)
 				currentBoundaryCIDs = newBoundaryCIDs

internal/sync/sync_test.go

···
 		}
 	}
 
-	return addedCount, nil // ← Return actual added count
+	return addedCount, nil
 }
 
 func (m *mockMempool) Save() error {
···
 		defer client.Close()
 
 		logger := &testLogger{t: t}
-		ops, _ := storage.NewOperations(logger)
+		ops, _ := storage.NewOperations(logger, false)
 		defer ops.Close()
 
 		fetcher := internalsync.NewFetcher(client, ops, logger)
···
 		defer client.Close()
 
 		logger := &testLogger{t: t}
-		storageOps, _ := storage.NewOperations(logger)
+		storageOps, _ := storage.NewOperations(logger, false)
 		defer storageOps.Close()
 
 		fetcher := internalsync.NewFetcher(client, storageOps, logger)
···
 		defer client.Close()
 
 		logger := &testLogger{t: t}
-		storageOps, _ := storage.NewOperations(logger)
+		storageOps, _ := storage.NewOperations(logger, false)
 		defer storageOps.Close()
 
 		fetcher := internalsync.NewFetcher(client, storageOps, logger)
···
 		defer client.Close()
 
 		logger := &testLogger{t: t}
-		storageOps, _ := storage.NewOperations(logger)
+		storageOps, _ := storage.NewOperations(logger, false)
 		defer storageOps.Close()
 
 		fetcher := internalsync.NewFetcher(client, storageOps, logger)
···
 
 func TestBundlerCreateBundle(t *testing.T) {
 	logger := &testLogger{t: t}
-	storageOps, _ := storage.NewOperations(logger)
+	storageOps, _ := storage.NewOperations(logger, false)
 	defer storageOps.Close()
 
 	t.Run("BasicBundleCreation", func(t *testing.T) {

server/server_test.go

···
 
 	// Create storage operations ONCE and reuse
 	logger := &testLogger{t: t}
-	storageOps, err := storage.NewOperations(logger)
+	storageOps, err := storage.NewOperations(logger, false)
 	if err != nil {
 		t.Fatalf("failed to create storage operations: %v", err)
 	}