update pkg name and cmd name

Dockerfile

···
 RUN CGO_ENABLED=1 go build \
     -ldflags="-w -s -X 'main.version=${VERSION}' -X 'main.gitCommit=${GIT_COMMIT}' -X 'main.buildDate=${BUILD_DATE}'" \
     -trimpath \
-    -o plcbundle \
+    -o plcbundle-go \
     ./cmd/plcbundle
 
 FROM alpine:3.19
 
 RUN apk add --no-cache ca-certificates zstd-libs
 
-COPY --from=builder /build/plcbundle /usr/local/bin/plcbundle
+COPY --from=builder /build/plcbundle-go /usr/local/bin/plcbundle-go
 
 WORKDIR /data
 
-ENTRYPOINT ["plcbundle"]
+ENTRYPOINT ["plcbundle-go"]

Makefile

···
 .PHONY: docker-build docker-buildx docker-push docker-run docker-clean docker-shell compose-up compose-down compose-logs
 
 # Binary name
-BINARY_NAME=plcbundle
+BINARY_NAME=plcbundle-go
 INSTALL_PATH=$(GOPATH)/bin
 
 # Docker configuration
-DOCKER_IMAGE=plcbundle
+DOCKER_IMAGE=plcbundle-go
 DOCKER_TAG=$(VERSION)
 DOCKER_REGISTRY?=atscan
 DOCKER_FULL_IMAGE=$(if $(DOCKER_REGISTRY),$(DOCKER_REGISTRY)/,)$(DOCKER_IMAGE):$(DOCKER_TAG)
···
 
 # Run Docker container as CLI
 docker-run:
-	@docker run --rm -v $(PWD)/data:/data $(DOCKER_FULL_IMAGE) plcbundle $(CMD)
+	@docker run --rm -v $(PWD)/data:/data $(DOCKER_FULL_IMAGE) plcbundle-go $(CMD)
 
 # Shortcuts
 docker-info:
-	@docker run --rm -v $(PWD)/data:/data $(DOCKER_FULL_IMAGE) plcbundle info
+	@docker run --rm -v $(PWD)/data:/data $(DOCKER_FULL_IMAGE) plcbundle-go info
 
 docker-fetch:
-	@docker run --rm -v $(PWD)/data:/data $(DOCKER_FULL_IMAGE) plcbundle fetch
+	@docker run --rm -v $(PWD)/data:/data $(DOCKER_FULL_IMAGE) plcbundle-go fetch
 
 docker-verify:
-	@docker run --rm -v $(PWD)/data:/data $(DOCKER_FULL_IMAGE) plcbundle verify
+	@docker run --rm -v $(PWD)/data:/data $(DOCKER_FULL_IMAGE) plcbundle-go verify
 
 # Run as server
 docker-serve:
-	docker run --rm -it -p 8080:8080 -v $(PWD)/data:/data $(DOCKER_FULL_IMAGE) plcbundle serve --host 0.0.0.0
+	docker run --rm -it -p 8080:8080 -v $(PWD)/data:/data $(DOCKER_FULL_IMAGE) plcbundle-go serve --host 0.0.0.0
 
 # Open shell
 docker-shell:

README.md

···
 
 ```bash
 # CLI tool
-go install tangled.org/atscan.net/plcbundle/cmd/plcbundle@latest
+go install tangled.org/atscan.net/plcbundle-go/cmd/plcbundle@latest
 
 # Library
-go get tangled.org/atscan.net/plcbundle
+go get tangled.org/atscan.net/plcbundle-go
 ```
 
 ### Docker
···
 docker pull atscan/plcbundle:latest
 
 # Run CLI
-docker run --rm -v $(pwd)/data:/data atscan/plcbundle info
+docker run --rm -v $(pwd)/data:/data atscan/plcbundle-go info
 
 # Run as server
-docker run -d -p 8080:8080 -v $(pwd)/data:/data atscan/plcbundle serve --host 0.0.0.0
+docker run -d -p 8080:8080 -v $(pwd)/data:/data atscan/plcbundle-go serve --host 0.0.0.0
 
 # Or use docker compose
 curl -O https://tangled.org/@atscan.net/plcbundle/raw/main/docker-compose.yaml
···
 ### As a Library
 
 ```go
-import plcbundle "tangled.org/atscan.net/plcbundle"
+import plcbundle "tangled.org/atscan.net/plcbundle-go"
 
 mgr, _ := plcbundle.New("./plc_data", "https://plc.directory")
 defer mgr.Close()
···
 
 ```bash
 # Fetch bundles from plc.directory
-plcbundle sync
+plcbundle-go sync
 
 # Clone from remote
-plcbundle clone https://plc.example.com
+plcbundle-go clone https://plc.example.com
 
 # Verify integrity
-plcbundle verify
+plcbundle-go verify
 ```
 
 [See full CLI reference →](./docs/cli.md)
···
 
 ```bash
 # CLI usage
-docker run --rm -v $(pwd)/data:/data plcbundle info
+docker run --rm -v $(pwd)/data:/data plcbundle-go info
 
 # Server mode
 docker-compose up -d

bundle.go

···
 	"context"
 	"io"
 
-	"tangled.org/atscan.net/plcbundle/bundle"
+	"tangled.org/atscan.net/plcbundle-go/bundle"
 )
 
 // Manager is the main entry point for plcbundle operations

bundle/bundle_test.go

···
 	"testing"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/bundle"
-	"tangled.org/atscan.net/plcbundle/internal/bundleindex"
-	"tangled.org/atscan.net/plcbundle/internal/mempool"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/storage"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/bundle"
+	"tangled.org/atscan.net/plcbundle-go/internal/bundleindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/mempool"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/storage"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 var (

bundle/manager.go

···
 	"sync/atomic"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/bundleindex"
-	"tangled.org/atscan.net/plcbundle/internal/didindex"
-	"tangled.org/atscan.net/plcbundle/internal/handleresolver"
-	"tangled.org/atscan.net/plcbundle/internal/mempool"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/storage"
-	internalsync "tangled.org/atscan.net/plcbundle/internal/sync"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/internal/bundleindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/didindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/handleresolver"
+	"tangled.org/atscan.net/plcbundle-go/internal/mempool"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/storage"
+	internalsync "tangled.org/atscan.net/plcbundle-go/internal/sync"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 // defaultLogger is a simple logger implementation

bundle/metadata.go

···
 	"os"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/bundleindex"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/storage"
+	"tangled.org/atscan.net/plcbundle-go/internal/bundleindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/storage"
 )
 
 // CalculateBundleMetadata calculates complete metadata for a bundle

bundle/scanner.go

···
 	"sync"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/bundleindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/bundleindex"
 )
 
 // ScanDirectory scans the bundle directory and rebuilds the index

bundle/types.go

···
 	"path/filepath"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/bundleindex"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/internal/bundleindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 // Bundle represents a PLC bundle

cmd/plcbundle/commands/clone.go

···
 	"time"
 
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/cmd/plcbundle/ui"
-	internalsync "tangled.org/atscan.net/plcbundle/internal/sync"
+	"tangled.org/atscan.net/plcbundle-go/cmd/plcbundle/ui"
+	internalsync "tangled.org/atscan.net/plcbundle-go/internal/sync"
 )
 
 func NewCloneCommand() *cobra.Command {
···
 		Args: cobra.RangeArgs(1, 2),
 
 		Example: `  # Clone into default 'bundles' directory
-  plcbundle clone https://plc.example.com
+  plcbundle-go clone https://plc.example.com
   
   # Clone into specific directory
-  plcbundle clone https://plc.example.com my-plc-data
+  plcbundle-go clone https://plc.example.com my-plc-data
   
   # Clone with more parallel workers (faster)
-  plcbundle clone https://plc.example.com --workers 8
+  plcbundle-go clone https://plc.example.com --workers 8
   
   # Resume interrupted clone
-  plcbundle clone https://plc.example.com --resume
+  plcbundle-go clone https://plc.example.com --resume
   
   # Verbose output (shows each bundle)
-  plcbundle clone https://plc.example.com my-bundles -v`,
+  plcbundle-go clone https://plc.example.com my-bundles -v`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			remoteURL := strings.TrimSuffix(args[0], "/")

cmd/plcbundle/commands/common.go

···
 	"time"
 
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/bundle"
-	"tangled.org/atscan.net/plcbundle/internal/bundleindex"
-	"tangled.org/atscan.net/plcbundle/internal/didindex"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	internalsync "tangled.org/atscan.net/plcbundle/internal/sync"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/bundle"
+	"tangled.org/atscan.net/plcbundle-go/internal/bundleindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/didindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	internalsync "tangled.org/atscan.net/plcbundle-go/internal/sync"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 // BundleManager interface (for testing/mocking)

cmd/plcbundle/commands/detector.go

···
 
 	"github.com/goccy/go-json"
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/cmd/plcbundle/ui"
-	"tangled.org/atscan.net/plcbundle/detector"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/cmd/plcbundle/ui"
+	"tangled.org/atscan.net/plcbundle-go/detector"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
 )
 
 func NewDetectorCommand() *cobra.Command {
···
   Load JavaScript detectors from .js files with a detect() function.`,
 
 		Example: `  # List available detectors
-  plcbundle detector list
+  plcbundle-go detector list
 
   # Run detector on bundles
-  plcbundle detector run invalid_handle --bundles 1-100
+  plcbundle-go detector run invalid_handle --bundles 1-100
 
   # Run with parallel processing
-  plcbundle detector run invalid_handle --bundles 1-100 --workers 8
+  plcbundle-go detector run invalid_handle --bundles 1-100 --workers 8
 
   # Run custom detector script
-  plcbundle detector run ./my_detector.js --bundles 1-100
+  plcbundle-go detector run ./my_detector.js --bundles 1-100
 
   # Run multiple detectors
-  plcbundle detector run invalid_handle aka_spam --bundles 1-100
+  plcbundle-go detector run invalid_handle aka_spam --bundles 1-100
 
   # Run all detectors
-  plcbundle detector run all --bundles 1-100
+  plcbundle-go detector run all --bundles 1-100
 
   # Filter JSONL from stdin
-  cat ops.jsonl | plcbundle detector filter invalid_handle > clean.jsonl
+  cat ops.jsonl | plcbundle-go detector filter invalid_handle > clean.jsonl
 
   # Get detector info
-  plcbundle detector info invalid_handle`,
+  plcbundle-go detector info invalid_handle`,
 	}
 
 	// Add subcommands
···
 		Long:  `List all available built-in and loaded detectors`,
 
 		Example: `  # List all detectors
-  plcbundle detector list`,
+  plcbundle-go detector list`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			registry := detector.DefaultRegistry()
···
 			for _, d := range detectors {
 				fmt.Printf("  %-20s %s (v%s)\n", d.Name(), d.Description(), d.Version())
 			}
-			fmt.Printf("\nUse 'plcbundle detector info <name>' for details\n")
+			fmt.Printf("\nUse 'plcbundle-go detector info <name>' for details\n")
 
 			return nil
 		},
···
 		Long:  `Test a detector on a specific bundle and show results`,
 
 		Example: `  # Test on bundle 42
-  plcbundle detector test invalid_handle --bundle 42
+  plcbundle-go detector test invalid_handle --bundle 42
 
   # Verbose output with samples
-  plcbundle detector test aka_spam --bundle 100 -v
+  plcbundle-go detector test aka_spam --bundle 100 -v
 
   # Custom confidence threshold
-  plcbundle detector test spam_pds --bundle 50 --confidence 0.85`,
+  plcbundle-go detector test spam_pds --bundle 50 --confidence 0.85`,
 
 		Args: cobra.ExactArgs(1),
 
···
   • Special keyword 'all' to run all built-in detectors`,
 
 		Example: `  # Run single detector
-  plcbundle detector run invalid_handle --bundles 1-100
+  plcbundle-go detector run invalid_handle --bundles 1-100
 
   # Run with 8 parallel workers (faster)
-  plcbundle detector run invalid_handle --bundles 1-1000 --workers 8
+  plcbundle-go detector run invalid_handle --bundles 1-1000 --workers 8
 
   # Run multiple detectors in parallel
-  plcbundle detector run invalid_handle aka_spam --bundles 1-100 -w 4
+  plcbundle-go detector run invalid_handle aka_spam --bundles 1-100 -w 4
 
   # Run custom script
-  plcbundle detector run ./my_detector.js --bundles 1-100
+  plcbundle-go detector run ./my_detector.js --bundles 1-100
 
   # Run all built-in detectors
-  plcbundle detector run all --bundles 1-100 --workers 8
+  plcbundle-go detector run all --bundles 1-100 --workers 8
 
   # Save results to file
-  plcbundle detector run all --bundles 1-100 -w 8 > results.csv
+  plcbundle-go detector run all --bundles 1-100 -w 8 > results.csv
 
   # Disable progress bar (for scripting)
-  plcbundle detector run spam --bundles 1-100 --no-progress
+  plcbundle-go detector run spam --bundles 1-100 --no-progress
 
   # Enable profiling
-  plcbundle detector run all --bundles 1-100 --pprof :6060`,
+  plcbundle-go detector run all --bundles 1-100 --pprof :6060`,
 
 		Args: cobra.MinimumNArgs(1),
 
···
 Perfect for cleaning datasets or pre-processing.`,
 
 		Example: `  # Filter with built-in detector
-  cat ops.jsonl | plcbundle detector filter invalid_handle > clean.jsonl
+  cat ops.jsonl | plcbundle-go detector filter invalid_handle > clean.jsonl
 
   # Filter with custom script
-  plcbundle export --all | plcbundle detector filter ./spam.js > clean.jsonl
+  plcbundle export --all | plcbundle-go detector filter ./spam.js > clean.jsonl
 
   # Chain multiple detectors
-  cat ops.jsonl | plcbundle detector filter invalid_handle aka_spam > clean.jsonl
+  cat ops.jsonl | plcbundle-go detector filter invalid_handle aka_spam > clean.jsonl
 
   # Custom confidence
-  cat ops.jsonl | plcbundle detector filter spam_pds --confidence 0.95 > clean.jsonl`,
+  cat ops.jsonl | plcbundle-go detector filter spam_pds --confidence 0.95 > clean.jsonl`,
 
 		Args: cobra.MinimumNArgs(1),
 
···
 		Long:  `Show detailed information about a specific detector`,
 
 		Example: `  # Show detector info
-  plcbundle detector info invalid_handle
-  plcbundle detector info aka_spam`,
+  plcbundle-go detector info invalid_handle
+  plcbundle-go detector info aka_spam`,
 
 		Args: cobra.ExactArgs(1),
 
···
 
 			fmt.Printf("Usage examples:\n")
 			fmt.Printf("  # Test on single bundle\n")
-			fmt.Printf("  plcbundle detector test %s --bundle 42\n\n", d.Name())
+			fmt.Printf("  plcbundle-go detector test %s --bundle 42\n\n", d.Name())
 			fmt.Printf("  # Run on range and save\n")
-			fmt.Printf("  plcbundle detector run %s --bundles 1-100 > results.csv\n\n", d.Name())
+			fmt.Printf("  plcbundle-go detector run %s --bundles 1-100 > results.csv\n\n", d.Name())
 			fmt.Printf("  # Filter JSONL stream\n")
-			fmt.Printf("  cat ops.jsonl | plcbundle detector filter %s > clean.jsonl\n\n", d.Name())
+			fmt.Printf("  cat ops.jsonl | plcbundle-go detector filter %s > clean.jsonl\n\n", d.Name())
 
 			return nil
 		},

cmd/plcbundle/commands/did.go

···
 
 	"github.com/goccy/go-json"
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/cmd/plcbundle/ui"
-	"tangled.org/atscan.net/plcbundle/internal/didindex"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/cmd/plcbundle/ui"
+	"tangled.org/atscan.net/plcbundle-go/internal/didindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
 )
 
 func NewDIDCommand() *cobra.Command {
···
 require a DID index to be built for optimal performance.`,
 
 		Example: `  # Lookup all operations for a DID
-  plcbundle did lookup did:plc:524tuhdhh3m7li5gycdn6boe
+  plcbundle-go did lookup did:plc:524tuhdhh3m7li5gycdn6boe
 
   # Resolve to current DID document
-  plcbundle did resolve did:plc:524tuhdhh3m7li5gycdn6boe
+  plcbundle-go did resolve did:plc:524tuhdhh3m7li5gycdn6boe
 
   # Show complete audit log
-  plcbundle did history did:plc:524tuhdhh3m7li5gycdn6boe
+  plcbundle-go did history did:plc:524tuhdhh3m7li5gycdn6boe
 
   # Show DID statistics
-  plcbundle did stats did:plc:524tuhdhh3m7li5gycdn6boe
+  plcbundle-go did stats did:plc:524tuhdhh3m7li5gycdn6boe
 
   # Batch process from file
-  plcbundle did batch dids.txt`,
+  plcbundle-go did batch dids.txt`,
 	}
 
 	// Add subcommands
···
 Requires DID index to be built.`,
 
 		Example: `  # Lookup by DID
-  plcbundle did lookup did:plc:524tuhdhh3m7li5gycdn6boe
+  plcbundle-go did lookup did:plc:524tuhdhh3m7li5gycdn6boe
 
   # Lookup by handle
-  plcbundle did lookup tree.fail
-  plcbundle did lookup ngerakines.me
+  plcbundle-go did lookup tree.fail
+  plcbundle-go did lookup ngerakines.me
 
   # With non-default handle resolver configured
   plcbundle --handle-resolver https://quickdid.smokesignal.tools did lookup tree.fail`,
···
 
 			stats := mgr.GetDIDIndexStats()
 			if !stats["exists"].(bool) {
-				fmt.Fprintf(os.Stderr, "⚠️  DID index not found. Run: plcbundle index build\n")
+				fmt.Fprintf(os.Stderr, "⚠️  DID index not found. Run: plcbundle-go index build\n")
 				fmt.Fprintf(os.Stderr, "    Falling back to full scan (slow)...\n\n")
 			}
 
···
 O(1) lookup of latest operation.`,
 
 		Example: `  # Resolve DID
-  plcbundle did resolve did:plc:524tuhdhh3m7li5gycdn6boe
+  plcbundle-go did resolve did:plc:524tuhdhh3m7li5gycdn6boe
 
   # Show timings and other details
-  plcbundle did resolve did:plc:524tuhdhh3m7li5gycdn6boe --verbose
+  plcbundle-go did resolve did:plc:524tuhdhh3m7li5gycdn6boe --verbose
 
   # Get raw PLC state (not W3C format)
-  plcbundle did resolve did:plc:524tuhdhh3m7li5gycdn6boe --raw
+  plcbundle-go did resolve did:plc:524tuhdhh3m7li5gycdn6boe --raw
 
   # Pipe to jq
-  plcbundle did resolve did:plc:524tuhdhh3m7li5gycdn6boe | jq .service
+  plcbundle-go did resolve did:plc:524tuhdhh3m7li5gycdn6boe | jq .service
   
   # Resolve by handle
-  plcbundle did resolve tree.fail`,
+  plcbundle-go did resolve tree.fail`,
 
 		Args: cobra.ExactArgs(1),
 
···
 This provides a full audit trail of all changes to the DID.`,
 
 		Example: `  # Show full history
-  plcbundle did history did:plc:524tuhdhh3m7li5gycdn6boe
+  plcbundle-go did history did:plc:524tuhdhh3m7li5gycdn6boe
 
   # Include nullified operations
-  plcbundle did history did:plc:524tuhdhh3m7li5gycdn6boe --include-nullified
+  plcbundle-go did history did:plc:524tuhdhh3m7li5gycdn6boe --include-nullified
 
   # Compact one-line format
-  plcbundle did history did:plc:524tuhdhh3m7li5gycdn6boe --compact
+  plcbundle-go did history did:plc:524tuhdhh3m7li5gycdn6boe --compact
 
   # JSON output
-  plcbundle did history did:plc:524tuhdhh3m7li5gycdn6boe --json`,
+  plcbundle-go did history did:plc:524tuhdhh3m7li5gycdn6boe --json`,
 
 		Args: cobra.ExactArgs(1),
 
···
   - Omit file + use --stdin: reads from stdin`,
 
 		Example: `  # Batch lookup from file
-  plcbundle did batch dids.txt --action lookup
+  plcbundle-go did batch dids.txt --action lookup
 
   # Read from stdin
-  cat dids.txt | plcbundle did batch --stdin --action lookup
-  cat dids.txt | plcbundle did batch - --action resolve
+  cat dids.txt | plcbundle-go did batch --stdin --action lookup
+  cat dids.txt | plcbundle-go did batch - --action resolve
 
   # Export operations for DIDs from stdin
-  echo "did:plc:524tuhdhh3m7li5gycdn6boe" | plcbundle did batch - --action export
+  echo "did:plc:524tuhdhh3m7li5gycdn6boe" | plcbundle-go did batch - --action export
 
   # Pipe results
-  plcbundle did batch dids.txt --action resolve -o resolved.jsonl
+  plcbundle-go did batch dids.txt --action resolve -o resolved.jsonl
 
   # Parallel processing
-  cat dids.txt | plcbundle did batch --stdin --action lookup --workers 8
+  cat dids.txt | plcbundle-go did batch --stdin --action lookup --workers 8
 
   # Chain commands
-  grep "did:plc:" some_file.txt | plcbundle did batch - --action export > ops.jsonl`,
+  grep "did:plc:" some_file.txt | plcbundle-go did batch - --action export > ops.jsonl`,
 
 		Args: cobra.MaximumNArgs(1),
 
···
 			} else if !fromStdin {
 				return fmt.Errorf("either provide filename or use --stdin flag\n" +
 					"Examples:\n" +
-					"  plcbundle did batch dids.txt\n" +
-					"  plcbundle did batch --stdin\n" +
-					"  cat dids.txt | plcbundle did batch -")
+					"  plcbundle-go did batch dids.txt\n" +
+					"  plcbundle-go did batch --stdin\n" +
+					"  cat dids.txt | plcbundle-go did batch -")
 			}
 
 			mgr, _, err := getManager(&ManagerOptions{Cmd: cmd})
···
 Without DID: shows global index statistics`,
 
 		Example: `  # Stats for specific DID
-  plcbundle did stats did:plc:524tuhdhh3m7li5gycdn6boe
+  plcbundle-go did stats did:plc:524tuhdhh3m7li5gycdn6boe
 
   # Global index stats
-  plcbundle did stats --global
-  plcbundle did stats
+  plcbundle-go did stats --global
+  plcbundle-go did stats
 
   # JSON output
-  plcbundle did stats did:plc:524tuhdhh3m7li5gycdn6boe --json`,
+  plcbundle-go did stats did:plc:524tuhdhh3m7li5gycdn6boe --json`,
 
 		Args: cobra.MaximumNArgs(1),
 
···
 
 	if !stats["exists"].(bool) {
 		fmt.Printf("DID index does not exist\n")
-		fmt.Printf("Run: plcbundle index build\n")
+		fmt.Printf("Run: plcbundle-go index build\n")
 		return nil
 	}
 

cmd/plcbundle/commands/diff.go

···
 
 	"github.com/goccy/go-json"
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/bundle"
-	"tangled.org/atscan.net/plcbundle/internal/bundleindex"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/bundle"
+	"tangled.org/atscan.net/plcbundle-go/internal/bundleindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
 )
 
 func NewDiffCommand() *cobra.Command {
···
   • Local file path (e.g., /path/to/plc_bundles.json)`,
 
 		Example: `  # High-level comparison
-  plcbundle diff https://plc.example.com
+  plcbundle-go diff https://plc.example.com
 
   # Show all differences (verbose)
-  plcbundle diff https://plc.example.com -v
+  plcbundle-go diff https://plc.example.com -v
 
   # Deep dive into specific bundle
-  plcbundle diff https://plc.example.com --bundle 23
+  plcbundle-go diff https://plc.example.com --bundle 23
 
   # Compare bundle with operation samples
-  plcbundle diff https://plc.example.com --bundle 23 --show-operations
+  plcbundle-go diff https://plc.example.com --bundle 23 --show-operations
 
   # Show first 50 operations
-  plcbundle diff https://plc.example.com --bundle 23 --sample 50
+  plcbundle-go diff https://plc.example.com --bundle 23 --sample 50
 
   # Using alias
-  plcbundle compare https://plc.example.com`,
+  plcbundle-go compare https://plc.example.com`,
 
 		Args: cobra.ExactArgs(1),
 
···
 	// If there are hash mismatches, suggest deep dive
 	if len(comparison.HashMismatches) > 0 {
 		fmt.Printf("\n💡 Tip: Use --bundle flag to investigate specific mismatches:\n")
-		fmt.Printf("   plcbundle diff %s --bundle %d --show-operations\n",
+		fmt.Printf("   plcbundle-go diff %s --bundle %d --show-operations\n",
 			target, comparison.HashMismatches[0].BundleNumber)
 	}
 

cmd/plcbundle/commands/export.go

···
 
 	"github.com/goccy/go-json"
 	"github.com/spf13/cobra"
-	internalsync "tangled.org/atscan.net/plcbundle/internal/sync"
+	internalsync "tangled.org/atscan.net/plcbundle-go/internal/sync"
 )
 
 func NewExportCommand() *cobra.Command {
···
 Supports filtering by count and timestamp for selective exports.`,
 
 		Example: `  # Export all existing bundles
-  plcbundle export --all
+  plcbundle-go export --all
 
   # Export and sync new bundles
-  plcbundle export --all --sync
+  plcbundle-go export --all --sync
 
   # Export specific range (existing only)
-  plcbundle export --range 1-100
+  plcbundle-go export --range 1-100
 
   # Export with limit
-  plcbundle export --all --count 50000
+  plcbundle-go export --all --count 50000
 
   # Export after timestamp
-  plcbundle export --all --after 2024-01-01T00:00:00Z
+  plcbundle-go export --all --after 2024-01-01T00:00:00Z
 
   # Combine filters
-  plcbundle export --range 1-100 --count 10000 --after 2024-01-01T00:00:00Z
+  plcbundle-go export --range 1-100 --count 10000 --after 2024-01-01T00:00:00Z
 
   # Export from specific PLC directory
-  plcbundle export --all --sync --plc https://plc.directory
+  plcbundle-go export --all --sync --plc https://plc.directory
 
   # Pipe to file
-  plcbundle export --all > operations.jsonl
+  plcbundle-go export --all > operations.jsonl
 
   # Process with jq
-  plcbundle export --all | jq -r .did | sort | uniq -c
+  plcbundle-go export --all | jq -r .did | sort | uniq -c
 
   # Sync and filter with detector
-  plcbundle export --all --sync | plcbundle detector filter spam
+  plcbundle-go export --all --sync | plcbundle-go detector filter spam
 
   # Using aliases (backwards compatible)
-  plcbundle stream --all --sync
-  plcbundle backfill --all`,
+  plcbundle-go stream --all --sync
+  plcbundle-go backfill --all`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			verbose, _ := cmd.Root().PersistentFlags().GetBool("verbose")

cmd/plcbundle/commands/index.go

···
 
 	"github.com/goccy/go-json"
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/cmd/plcbundle/ui"
+	"tangled.org/atscan.net/plcbundle-go/cmd/plcbundle/ui"
 )
 
 func NewIndexCommand() *cobra.Command {
···
 resolution and query operations.`,
 
 		Example: `  # Build DID position index
-  plcbundle index build
+  plcbundle-go index build
 
   # Repair DID index (rebuild from bundles)
-  plcbundle index repair
+  plcbundle-go index repair
 
   # Show DID index statistics
-  plcbundle index stats
+  plcbundle-go index stats
 
   # Verify DID index integrity
-  plcbundle index verify`,
+  plcbundle-go index verify`,
 	}
 
 	cmd.AddCommand(newIndexBuildCommand())
···
 are added. Use --force to rebuild from scratch.`,
 
 		Example: `  # Build index
-  plcbundle index build
+  plcbundle-go index build
 
   # Force rebuild from scratch
-  plcbundle index build --force`,
+  plcbundle-go index build --force`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			mgr, dir, err := getManager(&ManagerOptions{Cmd: cmd})
···
   • Upgrade to new index version`,
 
 		Example: `  # Repair DID index
-  plcbundle index repair
+  plcbundle-go index repair
 
   # Verbose output
-  plcbundle index repair -v`,
+  plcbundle-go index repair -v`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			verbose, _ := cmd.Root().PersistentFlags().GetBool("verbose")
···
 			stats := mgr.GetDIDIndexStats()
 			if !stats["exists"].(bool) {
 				fmt.Printf("DID index does not exist\n")
-				fmt.Printf("Use: plcbundle index build\n")
+				fmt.Printf("Use: plcbundle-go index build\n")
 				return nil
 			}
 
···
 shard distribution, cache statistics, and coverage.`,
 
 		Example: `  # Show statistics
-  plcbundle index stats
+  plcbundle-go index stats
 
   # JSON output
-  plcbundle index stats --json`,
+  plcbundle-go index stats --json`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			mgr, dir, err := getManager(&ManagerOptions{Cmd: cmd})
···
 
 			if !stats["exists"].(bool) {
 				fmt.Printf("DID index does not exist\n")
-				fmt.Printf("Run: plcbundle index build\n")
+				fmt.Printf("Run: plcbundle-go index build\n")
 				return nil
 			}
 
···
 Automatically repairs minor issues.`,
 
 		Example: `  # Verify DID index
-  plcbundle index verify
+  plcbundle-go index verify
 
   # Verbose output
-  plcbundle index verify -v`,
+  plcbundle-go index verify -v`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			mgr, dir, err := getManager(&ManagerOptions{Cmd: cmd})
···
 
 			if !stats["exists"].(bool) {
 				fmt.Printf("DID index does not exist\n")
-				fmt.Printf("Run: plcbundle index build\n")
+				fmt.Printf("Run: plcbundle-go index build\n")
 				return nil
 			}
 

cmd/plcbundle/commands/inspect.go

···
 
 	"github.com/goccy/go-json"
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/internal/storage"
+	"tangled.org/atscan.net/plcbundle-go/internal/storage"
 )
 
 // ============================================================================
···
 Can inspect either by bundle number (from repository) or direct file path.`,
 
 		Example: `  # Inspect from repository
-  plcbundle inspect 42
+  plcbundle-go inspect 42
 
   # Inspect specific file
-  plcbundle inspect /path/to/000042.jsonl.zst
-  plcbundle inspect 000042.jsonl.zst
+  plcbundle-go inspect /path/to/000042.jsonl.zst
+  plcbundle-go inspect 000042.jsonl.zst
 
   # Skip certain analysis sections
-  plcbundle inspect 42 --skip-patterns --skip-crypto
+  plcbundle-go inspect 42 --skip-patterns --skip-crypto
 
   # Show sample operations
-  plcbundle inspect 42 --samples --sample-count 20
+  plcbundle-go inspect 42 --samples --sample-count 20
 
   # Verify all hashes
-  plcbundle inspect 42 --verify
+  plcbundle-go inspect 42 --verify
 
   # JSON output (for scripting)
-  plcbundle inspect 42 --json`,
+  plcbundle-go inspect 42 --json`,
 
 		Args: cobra.ExactArgs(1),
 

cmd/plcbundle/commands/log.go

···
 
 	"github.com/spf13/cobra"
 	"golang.org/x/term"
-	"tangled.org/atscan.net/plcbundle/internal/bundleindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/bundleindex"
 )
 
 func NewLogCommand() *cobra.Command {
···
 is a terminal, just like 'git log'. Use --no-pager to disable.`,
 
 		Example: `  # Show all bundles (newest first, auto-paged)
-  plcbundle log
+  plcbundle-go log
 
   # Show last 10 bundles
-  plcbundle log --last 10
-  plcbundle log -n 10
+  plcbundle-go log --last 10
+  plcbundle-go log -n 10
 
   # One-line format
-  plcbundle log --oneline
+  plcbundle-go log --oneline
 
   # Hide hashes
-  plcbundle log --no-hashes
+  plcbundle-go log --no-hashes
 
   # Oldest first (ascending order)
-  plcbundle log --reverse
+  plcbundle-go log --reverse
 
   # Disable pager (direct output)
-  plcbundle log --no-pager
+  plcbundle-go log --no-pager
 
   # Combination
-  plcbundle log -n 20 --oneline
+  plcbundle-go log -n 20 --oneline
 
   # Using alias
-  plcbundle history -n 5`,
+  plcbundle-go history -n 5`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			mgr, dir, err := getManager(&ManagerOptions{Cmd: cmd})
···
 		fmt.Printf("No bundles in repository\n")
 		fmt.Printf("Directory: %s\n\n", dir)
 		fmt.Printf("Get started:\n")
-		fmt.Printf("  plcbundle clone <url>    Clone from remote\n")
-		fmt.Printf("  plcbundle sync           Fetch from PLC directory\n")
+		fmt.Printf("  plcbundle-go clone <url>    Clone from remote\n")
+		fmt.Printf("  plcbundle-go sync           Fetch from PLC directory\n")
 		return nil
 	}
 

cmd/plcbundle/commands/ls.go

···
 	"time"
 
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/internal/bundleindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/bundleindex"
 )
 
 func NewLsCommand() *cobra.Command {
···
 shell scripts and automation.`,
 
 		Example: `  # List all bundles
-  plcbundle ls
+  plcbundle-go ls
 
   # Last 10 bundles
-  plcbundle ls -n 10
+  plcbundle-go ls -n 10
 
   # Oldest first
-  plcbundle ls --reverse
+  plcbundle-go ls --reverse
 
   # Custom format
-  plcbundle ls --format "bundle,hash,date,size"
+  plcbundle-go ls --format "bundle,hash,date,size"
 
   # CSV format
-  plcbundle ls --separator ","
+  plcbundle-go ls --separator ","
 
   # Scripting examples
-  plcbundle ls | awk '{print $1}'           # Just bundle numbers
-  plcbundle ls | grep 000150                # Find specific bundle
-  plcbundle ls -n 5 | cut -f1,4             # First and 4th columns
-  plcbundle ls --format bundle,hash         # Custom columns
-  plcbundle ls --separator "," > bundles.csv # Export to CSV`,
+  plcbundle-go ls | awk '{print $1}'           # Just bundle numbers
+  plcbundle-go ls | grep 000150                # Find specific bundle
+  plcbundle-go ls -n 5 | cut -f1,4             # First and 4th columns
+  plcbundle-go ls --format bundle,hash         # Custom columns
+  plcbundle-go ls --separator "," > bundles.csv # Export to CSV`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			mgr, _, err := getManager(&ManagerOptions{Cmd: cmd})

cmd/plcbundle/commands/mempool.go

···
 
 	"github.com/goccy/go-json"
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 func NewMempoolCommand() *cobra.Command {
···
 strict chronological order and automatically validates consistency.`,
 
 		Example: `  # Show mempool status
-  plcbundle mempool
-  plcbundle mempool status
+  plcbundle-go mempool
+  plcbundle-go mempool status
 
   # Clear all operations
-  plcbundle mempool clear
+  plcbundle-go mempool clear
 
   # Export operations as JSONL
-  plcbundle mempool dump
-  plcbundle mempool dump > operations.jsonl
+  plcbundle-go mempool dump
+  plcbundle-go mempool dump > operations.jsonl
 
   # Using alias
-  plcbundle mp status`,
+  plcbundle-go mp status`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			// Default to status subcommand
···
 next bundle, validation status, and memory usage.`,
 
 		Example: `  # Show status
-  plcbundle mempool status
-  plcbundle mempool
+  plcbundle-go mempool status
+  plcbundle-go mempool
 
   # Verbose output with samples
-  plcbundle mempool status -v`,
+  plcbundle-go mempool status -v`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return mempoolStatus(cmd, args)
···
   • Force fresh start`,
 
 		Example: `  # Clear with confirmation
-  plcbundle mempool clear
+  plcbundle-go mempool clear
 
   # Force clear without confirmation
-  plcbundle mempool clear --force
-  plcbundle mempool clear -f`,
+  plcbundle-go mempool clear --force
+  plcbundle-go mempool clear -f`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			mgr, dir, err := getManager(&ManagerOptions{Cmd: cmd})
···
 Perfect for backup, analysis, or piping to other tools.`,
 
 		Example: `  # Dump to stdout
-  plcbundle mempool dump
+  plcbundle-go mempool dump
 
   # Save to file
-  plcbundle mempool dump > mempool.jsonl
-  plcbundle mempool dump -o mempool.jsonl
+  plcbundle-go mempool dump > mempool.jsonl
+  plcbundle-go mempool dump -o mempool.jsonl
 
   # Pipe to jq
-  plcbundle mempool dump | jq -r .did
+  plcbundle-go mempool dump | jq -r .did
 
   # Count operations
-  plcbundle mempool dump | wc -l
+  plcbundle-go mempool dump | wc -l
 
   # Using alias
-  plcbundle mempool export`,
+  plcbundle-go mempool export`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			mgr, _, err := getManager(&ManagerOptions{Cmd: cmd})

cmd/plcbundle/commands/migrate.go

···
 	"time"
 
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/cmd/plcbundle/ui"
-	"tangled.org/atscan.net/plcbundle/internal/bundleindex"
-	"tangled.org/atscan.net/plcbundle/internal/storage"
+	"tangled.org/atscan.net/plcbundle-go/cmd/plcbundle/ui"
+	"tangled.org/atscan.net/plcbundle-go/internal/bundleindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/storage"
 )
 
 func NewMigrateCommand() *cobra.Command {
···
 Original files are replaced atomically. Use --dry-run to preview.`,
 
 		Example: `  # Preview migration (recommended first)
-  plcbundle migrate --dry-run
+  plcbundle-go migrate --dry-run
 
   # Migrate all legacy bundles
-  plcbundle migrate
+  plcbundle-go migrate
 
   # Force migration even if .idx files exist
-  plcbundle migrate --force
+  plcbundle-go migrate --force
 
   # Parallel migration (faster)
-  plcbundle migrate --workers 8
+  plcbundle-go migrate --workers 8
 
   # Verbose output
-  plcbundle migrate -v`,
+  plcbundle-go migrate -v`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			verbose, _ := cmd.Root().PersistentFlags().GetBool("verbose")

cmd/plcbundle/commands/op.go

···
 
 	"github.com/goccy/go-json"
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 func NewOpCommand() *cobra.Command {
···
 Example: 88410345 = bundle 8841, position 345`,
 
 		Example: `  # Get operation as JSON
-  plcbundle op get 42 1337
-  plcbundle op get 420000
+  plcbundle-go op get 42 1337
+  plcbundle-go op get 420000
 
   # Show operation (formatted)
-  plcbundle op show 42 1337
-  plcbundle op show 88410345
+  plcbundle-go op show 42 1337
+  plcbundle-go op show 88410345
 
   # Find by CID
-  plcbundle op find bafyreig3...`,
+  plcbundle-go op find bafyreig3...`,
 	}
 
 	// Add subcommands
···
 Use -v/--verbose to see detailed timing breakdown.`,
 
 		Example: `  # By bundle + position
-  plcbundle op get 42 1337
+  plcbundle-go op get 42 1337
 
   # By global position
-  plcbundle op get 88410345
+  plcbundle-go op get 88410345
 
   # With timing metrics
-  plcbundle op get 42 1337 -v
-  plcbundle op get 88410345 --verbose
+  plcbundle-go op get 42 1337 -v
+  plcbundle-go op get 88410345 --verbose
 
   # Pipe to jq
-  plcbundle op get 42 1337 | jq .did`,
+  plcbundle-go op get 42 1337 | jq .did`,
 
 		Args: cobra.RangeArgs(1, 2),
 
···
   • Performance metrics (with -v)`,
 
 		Example: `  # By bundle + position
-  plcbundle op show 42 1337
+  plcbundle-go op show 42 1337
 
   # By global position
-  plcbundle op show 88410345
+  plcbundle-go op show 88410345
 
   # Verbose with timing and full JSON
-  plcbundle op show 42 1337 -v`,
+  plcbundle-go op show 42 1337 -v`,
 
 		Args: cobra.RangeArgs(1, 2),
 
···
 Note: This performs a full scan and can be slow on large repositories.`,
 
 		Example: `  # Find by CID
-  plcbundle op find bafyreig3tg4k...
+  plcbundle-go op find bafyreig3tg4k...
 
   # Pipe to op get
-  plcbundle op find bafyreig3... | awk '{print $3, $5}' | xargs plcbundle op get`,
+  plcbundle-go op find bafyreig3... | awk '{print $3, $5}' | xargs plcbundle-go op get`,
 
 		Args: cobra.ExactArgs(1),
 

cmd/plcbundle/commands/progress_helper.go

···
 package commands
 
 import (
-	"tangled.org/atscan.net/plcbundle/cmd/plcbundle/ui"
+	"tangled.org/atscan.net/plcbundle-go/cmd/plcbundle/ui"
 )
 
 // NewBundleProgressBar creates a progress bar with auto-calculated bytes from bundles

cmd/plcbundle/commands/query.go

···
 	"github.com/goccy/go-json"
 	"github.com/jmespath-community/go-jmespath" // Correct import
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/cmd/plcbundle/ui"
+	"tangled.org/atscan.net/plcbundle-go/cmd/plcbundle/ui"
 )
 
 func NewQueryCommand() *cobra.Command {

cmd/plcbundle/commands/rollback.go

···
 	"strings"
 
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/cmd/plcbundle/ui"
-	"tangled.org/atscan.net/plcbundle/internal/bundleindex"
+	"tangled.org/atscan.net/plcbundle-go/cmd/plcbundle/ui"
+	"tangled.org/atscan.net/plcbundle-go/internal/bundleindex"
 )
 
 func NewRollbackCommand() *cobra.Command {
···
   7. Optionally rebuilds DID index`,
 
 		Example: `  # Rollback TO bundle 100 (keeps 1-100, removes 101+)
-  plcbundle rollback --to 100
+  plcbundle-go rollback --to 100
 
   # Remove last 5 bundles
-  plcbundle rollback --last 5
+  plcbundle-go rollback --last 5
 
   # Rollback without confirmation
-  plcbundle rollback --to 50 --force
+  plcbundle-go rollback --to 50 --force
 
   # Rollback and rebuild DID index
-  plcbundle rollback --to 100 --rebuild-did-index
+  plcbundle-go rollback --to 100 --rebuild-did-index
 
   # Rollback but keep bundle files (index-only)
-  plcbundle rollback --to 100 --keep-files`,
+  plcbundle-go rollback --to 100 --keep-files`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			verbose, _ := cmd.Root().PersistentFlags().GetBool("verbose")
···
 			fmt.Printf("         Index has bundle %06d, but repository now at %06d\n",
 				config.LastBundle, plan.targetBundle)
 		}
-		fmt.Printf("         Run: plcbundle index build\n")
+		fmt.Printf("         Run: plcbundle-go index build\n")
 	}
 
 	return nil
···
 	if !opts.rebuildDIDIndex && plan.hasDIDIndex {
 		fmt.Printf("💡 Next Steps\n")
 		fmt.Printf("   DID index is out of date. Rebuild with:\n")
-		fmt.Printf("   plcbundle index build\n\n")
+		fmt.Printf("   plcbundle-go index build\n\n")
 	}
 }

cmd/plcbundle/commands/server.go

···
 	"time"
 
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/bundle"
-	internalsync "tangled.org/atscan.net/plcbundle/internal/sync"
-	"tangled.org/atscan.net/plcbundle/server"
+	"tangled.org/atscan.net/plcbundle-go/bundle"
+	internalsync "tangled.org/atscan.net/plcbundle-go/internal/sync"
+	"tangled.org/atscan.net/plcbundle-go/server"
 )
 
 func NewServerCommand() *cobra.Command {
···
   - Live mempool (in sync mode)
 
 Sync mode (--sync) runs as a daemon, continuously fetching new bundles.
-For one-time sync, use 'plcbundle sync' command instead.`,
+For one-time sync, use 'plcbundle-go sync' command instead.`,
 
 		Example: `  # Basic server (read-only, current directory)
-  plcbundle server
+  plcbundle-go server
 
   # Server with specific directory
-  plcbundle server --dir ./my-bundles
+  plcbundle-go server --dir ./my-bundles
 
   # Live syncing server (daemon mode)
-  plcbundle server --sync
-  plcbundle server -s
+  plcbundle-go server --sync
+  plcbundle-go server -s
 
   # Using alias
-  plcbundle serve -s
+  plcbundle-go serve -s
 
   # Custom port and host
-  plcbundle server --port 3000 --host 0.0.0.0
+  plcbundle-go server --port 3000 --host 0.0.0.0
 
   # Full featured server
-  plcbundle server -s --websocket --resolver
+  plcbundle-go server -s --websocket --resolver
 
   # Fast sync interval
-  plcbundle server -s --interval 30s
+  plcbundle-go server -s --interval 30s
 
   # Sync with limit (stop after 1000 bundles)
-  plcbundle server -s --max-bundles 1000
+  plcbundle-go server -s --max-bundles 1000
 
   # Public server with all features
-  plcbundle serve -s --websocket --resolver --host 0.0.0.0 --port 80`,
+  plcbundle-go serve -s --websocket --resolver --host 0.0.0.0 --port 80`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			verbose, _ := cmd.Root().PersistentFlags().GetBool("verbose")

cmd/plcbundle/commands/status.go

···
 	"time"
 
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/bundle"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/bundle"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 func NewStatusCommand() *cobra.Command {
···
 storage, timeline, mempool, and DID index status.`,
 
 		Example: `  # Show status
-  plcbundle status
+  plcbundle-go status
 
   # Using alias
-  plcbundle info`,
+  plcbundle-go info`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			mgr, dir, err := getManager(&ManagerOptions{Cmd: cmd})
···
 	if bundleCount == 0 {
 		fmt.Printf("⚠️  Empty repository (no bundles)\n\n")
 		fmt.Printf("Get started:\n")
-		fmt.Printf("  plcbundle clone <url>    Clone from remote\n")
-		fmt.Printf("  plcbundle sync           Fetch from PLC directory\n\n")
+		fmt.Printf("  plcbundle-go clone <url>    Clone from remote\n")
+		fmt.Printf("  plcbundle-go sync           Fetch from PLC directory\n\n")
 		return nil
 	}
 

cmd/plcbundle/commands/sync.go

···
 	"time"
 
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/bundle"
-	internalsync "tangled.org/atscan.net/plcbundle/internal/sync"
+	"tangled.org/atscan.net/plcbundle-go/bundle"
+	internalsync "tangled.org/atscan.net/plcbundle-go/internal/sync"
 )
 
 func NewSyncCommand() *cobra.Command {
···
 that continuously syncs at regular intervals.`,
 
 		Example: `  # Fetch new bundles once
-  plcbundle sync
+  plcbundle-go sync
 
   # Fetch from specific directory
-  plcbundle sync --dir ./my-bundles
+  plcbundle-go sync --dir ./my-bundles
 
   # Run continuously (daemon mode)
-  plcbundle sync --continuous
+  plcbundle-go sync --continuous
 
   # Custom sync interval
-  plcbundle sync --continuous --interval 30s
+  plcbundle-go sync --continuous --interval 30s
 
   # Fetch maximum 10 bundles then stop
-  plcbundle sync --max-bundles 10
+  plcbundle-go sync --max-bundles 10
 
   # Continuous with limit
-  plcbundle sync --continuous --max-bundles 100 --interval 1m
+  plcbundle-go sync --continuous --max-bundles 100 --interval 1m
 
   # Verbose output
-  plcbundle sync --continuous -v`,
+  plcbundle-go sync --continuous -v`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			verbose, _ := cmd.Root().PersistentFlags().GetBool("verbose")

cmd/plcbundle/commands/verify.go

···
 	"time"
 
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/bundle"
-	"tangled.org/atscan.net/plcbundle/cmd/plcbundle/ui"
+	"tangled.org/atscan.net/plcbundle-go/bundle"
+	"tangled.org/atscan.net/plcbundle-go/cmd/plcbundle/ui"
 )
 
 func NewVerifyCommand() *cobra.Command {
···
   • Chain hash calculations are valid`,
 
 		Example: `  # Verify entire chain
-  plcbundle verify
-  plcbundle verify --chain
+  plcbundle-go verify
+  plcbundle-go verify --chain
 
   # Verify specific bundle
-  plcbundle verify --bundle 42
+  plcbundle-go verify --bundle 42
 
   # Verify range of bundles
-  plcbundle verify --range 1-100
+  plcbundle-go verify --range 1-100
 
   # Verbose output
-  plcbundle verify --chain -v
+  plcbundle-go verify --chain -v
 
   # Parallel verification (faster for ranges)
-  plcbundle verify --range 1-1000 --parallel --workers 8`,
+  plcbundle-go verify --range 1-1000 --parallel --workers 8`,
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			verbose, _ := cmd.Root().PersistentFlags().GetBool("verbose")

cmd/plcbundle/main.go

···
 	"os"
 
 	"github.com/spf13/cobra"
-	"tangled.org/atscan.net/plcbundle/cmd/plcbundle/commands"
+	"tangled.org/atscan.net/plcbundle-go/cmd/plcbundle/commands"
 )
 
 func main() {
···
 
 func newRootCommand() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "plcbundle",
+		Use:   "plcbundle-go",
 		Short: "DID PLC Bundle Management Tool",
-		Long: `plcbundle - DID PLC Bundle Management Tool
+		Long: `plcbundle-go - DID PLC Bundle Management Tool
 
 Tool for archiving AT Protocol's DID PLC Directory operations
 into immutable, cryptographically-chained bundles of 10,000
···
 		Use:   "version",
 		Short: "Show version information",
 		Run: func(cmd *cobra.Command, args []string) {
-			cmd.Printf("plcbundle version %s\n", GetVersion())
+			cmd.Printf("plcbundle-go version %s\n", GetVersion())
 			cmd.Printf("  commit: %s\n", getGitCommit())
 			cmd.Printf("  built:  %s\n", getBuildDate())
 		},
···
 To load completions:
 
 Bash:
-  $ source <(plcbundle completion bash)
+  $ source <(plcbundle-go completion bash)
   
   # To load automatically:
-  $ plcbundle completion bash > /etc/bash_completion.d/plcbundle
+  $ plcbundle-go completion bash > /etc/bash_completion.d/plcbundle-go
 
 Zsh:
-  $ plcbundle completion zsh > ~/.zsh/completion/_plcbundle
+  $ plcbundle-go completion zsh > ~/.zsh/completion/_plcbundle-go
   
   # Add to ~/.zshrc:
   fpath=(~/.zsh/completion $fpath)
 
 Fish:
-  $ plcbundle completion fish > ~/.config/fish/completions/plcbundle.fish`,
+  $ plcbundle-go completion fish > ~/.config/fish/completions/plcbundle-go.fish`,
 
 		Args:                  cobra.ExactArgs(1),
 		ValidArgs:             []string{"bash", "zsh", "fish", "powershell"},
···
 }
 
 func printRootHelp() {
-	fmt.Print(`plcbundle ` + GetVersion() + ` - DID PLC Bundle Management
+	fmt.Print(`plcbundle-go ` + GetVersion() + ` - DID PLC Bundle Management
 
-Usage: plcbundle <command> [options]
+Usage: plcbundle-go <command> [options]
 
 Main Commands:
   sync                 Fetch new bundles from PLC
···
   Tools:    watch, heal, clean, mempool, detector
 
 Getting Started:
-  plcbundle clone https://plc.example.com
-  plcbundle sync
-  plcbundle status
+  plcbundle-go clone https://plc.example.com
+  plcbundle-go sync
+  plcbundle-go status
 
-Run 'plcbundle help' for full documentation
-Run 'plcbundle <command> --help' for command help
+Run 'plcbundle-go help' for full documentation
+Run 'plcbundle-go <command> --help' for command help
 `)
 }

detector/builtin.go

···
 	"regexp"
 	"strings"
 
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
 )
 
 // NoOpDetector is an empty detector for speed testing

detector/detector.go

···
 	"context"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
 )
 
 // Detector represents a spam detection algorithm

detector/runner.go

···
 	"sync"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/bundle"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/bundle"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
 )
 
 // Runner executes detectors against operations

detector/script.go

···
 	"time"
 
 	"github.com/goccy/go-json"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
 )
 
 // ScriptDetector runs a JavaScript detector via Unix socket

go.mod

···
-module tangled.org/atscan.net/plcbundle
+module tangled.org/atscan.net/plcbundle-go
 
 go 1.25
 

internal/bundleindex/index_test.go

···
 	"testing"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/bundleindex"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/internal/bundleindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 type testLogger struct {

internal/didindex/bundle.go

···
 	"context"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
 )
 
 // BundleProvider is an interface to avoid circular dependencies

internal/didindex/lookup.go

···
 	"sort"
 	"sync"
 
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
 )
 
 // GetDIDOperations retrieves all operations for a DID WITH location metadata

internal/didindex/manager.go

···
 
 	"github.com/goccy/go-json"
 	"golang.org/x/sys/unix"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
 )
 
 // NewManager creates a new DID index manager

internal/didindex/manager_test.go

···
 import (
 	"testing"
 
-	"tangled.org/atscan.net/plcbundle/internal/didindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/didindex"
 )
 
 func TestOpLocationPacking(t *testing.T) {

internal/didindex/types.go

···
 	"sync"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
 )
 
 const (

internal/mempool/mempool.go

···
 	"time"
 
 	"github.com/goccy/go-json"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 const MEMPOOL_FILE_PREFIX = "plc_mempool_"

internal/mempool/mempool_test.go

···
 	"testing"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/mempool"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/internal/mempool"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 type testLogger struct {

internal/plcclient/plc_test.go

···
 	"testing"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/storage"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/storage"
 )
 
 // TestPLCOperation tests operation parsing and methods

internal/storage/storage.go

···
 	"time"
 
 	"github.com/goccy/go-json"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
 )
 
 const (

internal/storage/storage_test.go

···
 	"testing"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/storage"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/storage"
 )
 
 type testLogger struct {

internal/sync/bundler.go

···
 import (
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/storage"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/storage"
 )
 
 // CreateBundle creates a bundle structure from operations

internal/sync/cloner.go

···
 	"time"
 
 	"github.com/goccy/go-json"
-	"tangled.org/atscan.net/plcbundle/internal/bundleindex"
-	"tangled.org/atscan.net/plcbundle/internal/storage"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/internal/bundleindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/storage"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 // Cloner handles cloning bundles from remote endpoints

internal/sync/fetcher.go

···
 	"fmt"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/storage"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/storage"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 // Fetcher handles fetching operations from PLC directory

internal/sync/sync_test.go

···
 	"time"
 
 	"github.com/goccy/go-json"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/storage"
-	internalsync "tangled.org/atscan.net/plcbundle/internal/sync"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/storage"
+	internalsync "tangled.org/atscan.net/plcbundle-go/internal/sync"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 type testLogger struct {

internal/sync/syncer.go

···
 	"context"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 // SyncLoopConfig configures continuous syncing

internal/types/types_test.go

···
 	"fmt"
 	"testing"
 
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 // ====================================================================================

options.go

···
 package plcbundle
 
 import (
-	"tangled.org/atscan.net/plcbundle/bundle"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/bundle"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
 )
 
 type config struct {

server/handlers.go

···
 	"time"
 
 	"github.com/goccy/go-json"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 func (s *Server) handleRoot() http.HandlerFunc {

server/helpers.go

···
 	"net/http"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/bundle"
+	"tangled.org/atscan.net/plcbundle-go/bundle"
 )
 
 // getScheme determines the HTTP scheme

server/server.go

···
 	"net/http"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/bundle"
+	"tangled.org/atscan.net/plcbundle-go/bundle"
 )
 
 // New creates a new HTTP server

server/server_test.go

···
 	"time"
 
 	"github.com/gorilla/websocket"
-	"tangled.org/atscan.net/plcbundle/bundle"
-	"tangled.org/atscan.net/plcbundle/internal/bundleindex"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/storage"
-	"tangled.org/atscan.net/plcbundle/server"
+	"tangled.org/atscan.net/plcbundle-go/bundle"
+	"tangled.org/atscan.net/plcbundle-go/internal/bundleindex"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/storage"
+	"tangled.org/atscan.net/plcbundle-go/server"
 )
 
 type testLogger struct {

server/types.go

···
 	"net/http"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/bundle"
+	"tangled.org/atscan.net/plcbundle-go/bundle"
 )
 
 // Server serves bundle data over HTTP

server/types_test.go

···
 	"testing"
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/server"
+	"tangled.org/atscan.net/plcbundle-go/server"
 )
 
 func TestServerResponseTypes(t *testing.T) {

server/websocket.go

···
 
 	"github.com/goccy/go-json"
 	"github.com/gorilla/websocket"
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
-	"tangled.org/atscan.net/plcbundle/internal/types"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/types"
 )
 
 var upgrader = websocket.Upgrader{

types.go

···
 import (
 	"time"
 
-	"tangled.org/atscan.net/plcbundle/internal/plcclient"
+	"tangled.org/atscan.net/plcbundle-go/internal/plcclient"
 )
 
 // Bundle represents a PLC bundle (public version)