fix did audit log (show nullified)

bundle/manager.go

···
 }
 
 // GetDIDOperations retrieves all operations for a DID (bundles + mempool combined)
-func (m *Manager) GetDIDOperations(ctx context.Context, did string, verbose bool) ([]plcclient.PLCOperation, error) {
+// Returns: operations only, operations with locations, error
+func (m *Manager) GetDIDOperations(ctx context.Context, did string, verbose bool) ([]plcclient.PLCOperation, []PLCOperationWithLocation, error) {
 	if err := plcclient.ValidateDIDFormat(did); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	// Set verbose mode
···
 		m.didIndex.SetVerbose(verbose)
 	}
 
-	// Get bundled operations from DID index
-	bundledOps, err := m.didIndex.GetDIDOperations(ctx, did, m)
+	// Get bundled operations from DID index (includes nullified)
+	bundledOpsWithLoc, err := m.didIndex.GetDIDOperations(ctx, did, m)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
+	}
+
+	// Convert to bundle types
+	opsWithLoc := make([]PLCOperationWithLocation, len(bundledOpsWithLoc))
+	bundledOps := make([]plcclient.PLCOperation, len(bundledOpsWithLoc))
+	for i, r := range bundledOpsWithLoc {
+		opsWithLoc[i] = PLCOperationWithLocation{
+			Operation: r.Operation,
+			Bundle:    r.Bundle,
+			Position:  r.Position,
+		}
+		bundledOps[i] = r.Operation
 	}
 
 	// Get mempool operations
 	mempoolOps, err := m.GetDIDOperationsFromMempool(did)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	if len(mempoolOps) > 0 && verbose {
 		m.logger.Printf("DEBUG: Found %d operations in mempool", len(mempoolOps))
 	}
 
-	// Combine and sort
+	// Combine operations (for the slice return)
 	allOps := append(bundledOps, mempoolOps...)
 
 	sort.Slice(allOps, func(i, j int) bool {
 		return allOps[i].CreatedAt.Before(allOps[j].CreatedAt)
 	})
 
-	return allOps, nil
+	return allOps, opsWithLoc, nil
 }
 
 // GetDIDOperationsFromMempool retrieves operations for a DID from mempool only
···
 
 	// Delegate to DID index for bundled operations
 	return m.didIndex.GetLatestDIDOperation(ctx, did, m)
-}
-
-// GetDIDOperationsWithLocations returns operations along with their bundle/position info
-func (m *Manager) GetDIDOperationsWithLocations(ctx context.Context, did string, verbose bool) ([]PLCOperationWithLocation, error) {
-	if err := plcclient.ValidateDIDFormat(did); err != nil {
-		return nil, err
-	}
-
-	// Set verbose mode
-	if m.didIndex != nil {
-		m.didIndex.SetVerbose(verbose)
-	}
-
-	// Delegate to DID index
-	results, err := m.didIndex.GetDIDOperationsWithLocations(ctx, did, m)
-	if err != nil {
-		return nil, err
-	}
-
-	// Convert to bundle's type
-	bundleResults := make([]PLCOperationWithLocation, len(results))
-	for i, r := range results {
-		bundleResults[i] = PLCOperationWithLocation{
-			Operation: r.Operation,
-			Bundle:    r.Bundle,
-			Position:  r.Position,
-		}
-	}
-
-	return bundleResults, nil
 }
 
 // VerifyChain verifies the entire bundle chain

cmd/plcbundle/commands/common.go

···
 	GetDIDIndexStats() map[string]interface{}
 	GetDIDIndex() *didindex.Manager
 	BuildDIDIndex(ctx context.Context, progress func(int, int)) error
-	GetDIDOperations(ctx context.Context, did string, verbose bool) ([]plcclient.PLCOperation, error)
-	GetDIDOperationsWithLocations(ctx context.Context, did string, verbose bool) ([]bundle.PLCOperationWithLocation, error)
+	GetDIDOperations(ctx context.Context, did string, verbose bool) ([]plcclient.PLCOperation, []PLCOperationWithLocation, error)
 	GetDIDOperationsFromMempool(did string) ([]plcclient.PLCOperation, error)
 	GetLatestDIDOperation(ctx context.Context, did string) (*plcclient.PLCOperation, error)
 	LoadOperation(ctx context.Context, bundleNum, position int) (*plcclient.PLCOperation, error)

cmd/plcbundle/commands/did.go

···
   • DID: did:plc:524tuhdhh3m7li5gycdn6boe
   • Handle: tree.fail (resolves via configured resolver)
 
-Requires DID index to be built. If not available, will fall back to
-full scan (slow).`,
+Requires DID index to be built.`,
 
 		Example: `  # Lookup by DID
   plcbundle did lookup did:plc:524tuhdhh3m7li5gycdn6boe
 
-  # Lookup by handle (requires --resolver-url)
+  # Lookup by handle
   plcbundle did lookup tree.fail
   plcbundle did lookup ngerakines.me
 
···
 
 			// Lookup operations
 			lookupStart := time.Now()
-			opsWithLoc, err := mgr.GetDIDOperationsWithLocations(ctx, did, verbose)
+			_, opsWithLoc, err := mgr.GetDIDOperations(ctx, did, verbose)
 			if err != nil {
 				return err
 			}
···
 			ctx := context.Background()
 
 			// Get all operations with locations
-			opsWithLoc, err := mgr.GetDIDOperationsWithLocations(ctx, did, verbose)
+			_, opsWithLoc, err := mgr.GetDIDOperations(ctx, did, verbose)
 			if err != nil {
 				return err
 			}
···
 	ctx := context.Background()
 
 	// Get operations
-	opsWithLoc, err := mgr.GetDIDOperationsWithLocations(ctx, did, false)
+	_, opsWithLoc, err := mgr.GetDIDOperations(ctx, did, false)
 	if err != nil {
 		return err
 	}
···
 	errorCount := 0
 
 	for i, did := range dids {
-		opsWithLoc, err := mgr.GetDIDOperationsWithLocations(ctx, did, false)
+		_, opsWithLoc, err := mgr.GetDIDOperations(ctx, did, false)
 		if err != nil {
 			errorCount++
 			fmt.Fprintf(output, "%s,error,0,0,0,0\n", did)
···
 	defer writer.Flush()
 
 	for i, did := range dids {
-		opsWithLoc, err := mgr.GetDIDOperationsWithLocations(ctx, did, false)
+		_, opsWithLoc, err := mgr.GetDIDOperations(ctx, did, false)
 		if err != nil {
 			errorCount++
 			if i < 10 { // Only log first few errors

internal/didindex/lookup.go

···
 	"tangled.org/atscan.net/plcbundle/internal/plcclient"
 )
 
-// GetDIDOperations retrieves all operations for a DID from bundles
-func (dim *Manager) GetDIDOperations(ctx context.Context, did string, provider BundleProvider) ([]plcclient.PLCOperation, error) {
-	if err := plcclient.ValidateDIDFormat(did); err != nil {
-		return nil, err
-	}
-
-	if !dim.Exists() {
-		return nil, fmt.Errorf("DID index not available - run 'plcbundle index build' to enable DID lookups")
-	}
-
-	if dim.verbose {
-		dim.logger.Printf("DEBUG: Using DID index for lookup")
-	}
-
-	locations, err := dim.GetDIDLocations(did)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(locations) == 0 {
-		return []plcclient.PLCOperation{}, nil
-	}
-
-	// Filter nullified
-	var validLocations []OpLocation
-	for _, loc := range locations {
-		if !loc.Nullified() {
-			validLocations = append(validLocations, loc)
-		}
-	}
-
-	if dim.verbose {
-		dim.logger.Printf("DEBUG: Filtered %d valid locations (from %d total)",
-			len(validLocations), len(locations))
-	}
-
-	if len(validLocations) == 1 {
-		loc := validLocations[0]
-		op, err := provider.LoadOperation(ctx, loc.BundleInt(), loc.PositionInt())
-		if err != nil {
-			return nil, err
-		}
-		return []plcclient.PLCOperation{*op}, nil
-	}
-
-	// For multiple operations: group by bundle to minimize bundle loads
-	bundleMap := make(map[uint16][]uint16)
-	for _, loc := range validLocations {
-		bundleMap[loc.Bundle()] = append(bundleMap[loc.Bundle()], loc.Position())
-	}
-
-	if dim.verbose {
-		dim.logger.Printf("DEBUG: Loading from %d bundle(s)", len(bundleMap))
-	}
-
-	// Load operations
-	var allOps []plcclient.PLCOperation
-	for bundleNum, positions := range bundleMap {
-		// Optimization: If single position from bundle, use LoadOperation
-		if len(positions) == 1 {
-			op, err := provider.LoadOperation(ctx, int(bundleNum), int(positions[0]))
-			if err != nil {
-				dim.logger.Printf("Warning: failed to load operation at bundle %d position %d: %v",
-					bundleNum, positions[0], err)
-				continue
-			}
-			allOps = append(allOps, *op)
-		} else {
-			// Multiple positions: load full bundle
-			bundle, err := provider.LoadBundleForDIDIndex(ctx, int(bundleNum))
-			if err != nil {
-				dim.logger.Printf("Warning: failed to load bundle %d: %v", bundleNum, err)
-				continue
-			}
-
-			for _, pos := range positions {
-				if int(pos) < len(bundle.Operations) {
-					allOps = append(allOps, bundle.Operations[pos])
-				}
-			}
-		}
-	}
-
-	if dim.verbose {
-		dim.logger.Printf("DEBUG: Loaded %d total operations", len(allOps))
-	}
-
-	// Sort by time
-	sort.Slice(allOps, func(i, j int) bool {
-		return allOps[i].CreatedAt.Before(allOps[j].CreatedAt)
-	})
-
-	return allOps, nil
-}
-
-// GetDIDOperationsWithLocations returns operations with their bundle/position metadata
-func (dim *Manager) GetDIDOperationsWithLocations(ctx context.Context, did string, provider BundleProvider) ([]OpLocationWithOperation, error) {
+// GetDIDOperations retrieves all operations for a DID WITH location metadata
+// Returns operations with bundle/position info (includes nullified operations)
+func (dim *Manager) GetDIDOperations(ctx context.Context, did string, provider BundleProvider) ([]OpLocationWithOperation, error) {
 	if err := plcclient.ValidateDIDFormat(did); err != nil {
 		return nil, err
 	}
···
 		return nil, fmt.Errorf("DID index not available - run 'plcbundle index build' to enable DID lookups")
 	}
 
-	if dim.verbose {
-		dim.logger.Printf("DEBUG: Using DID index for lookup with locations")
-	}
-
 	locations, err := dim.GetDIDLocations(did)
 	if err != nil {
 		return nil, err
···
 		return []OpLocationWithOperation{}, nil
 	}
 
-	if dim.verbose {
-		dim.logger.Printf("DEBUG: Found %d locations in index", len(locations))
-	}
-
 	// Group by bundle
 	bundleMap := make(map[uint16][]OpLocation)
 	for _, loc := range locations {
 		bundleMap[loc.Bundle()] = append(bundleMap[loc.Bundle()], loc)
-	}
-
-	if dim.verbose {
-		dim.logger.Printf("DEBUG: Loading from %d bundle(s)", len(bundleMap))
 	}
 
 	var results []OpLocationWithOperation
···
 	sort.Slice(results, func(i, j int) bool {
 		return results[i].Operation.CreatedAt.Before(results[j].Operation.CreatedAt)
 	})
-
-	if dim.verbose {
-		dim.logger.Printf("DEBUG: Loaded %d total operations", len(results))
-	}
 
 	return results, nil
 }

server/handlers.go

···
 			return
 		}
 
-		operations, err := s.manager.GetDIDOperations(context.Background(), did, false)
+		operations, _, err := s.manager.GetDIDOperations(context.Background(), did, false)
 		if err != nil {
 			sendJSON(w, 500, map[string]string{"error": err.Error()})
 			return
···
 
 func (s *Server) handleDIDAuditLog(input string) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// Resolve handle to DID
 		did, _, err := s.manager.ResolveHandleOrDID(r.Context(), input)
 		if err != nil {
 			sendJSON(w, 400, map[string]string{"error": err.Error()})
 			return
 		}
 
-		operations, err := s.manager.GetDIDOperations(context.Background(), did, false)
+		operations, _, err := s.manager.GetDIDOperations(context.Background(), did, false)
 		if err != nil {
 			sendJSON(w, 500, map[string]string{"error": err.Error()})
 			return