Integrate BACKBEAT SDK and resolve KACHING license validation

Major integrations and fixes:
- Added BACKBEAT SDK integration for P2P operation timing
- Implemented beat-aware status tracking for distributed operations
- Added Docker secrets support for secure license management
- Resolved KACHING license validation via HTTPS/TLS
- Updated docker-compose configuration for clean stack deployment
- Disabled rollback policies to prevent deployment failures
- Added license credential storage (CHORUS-DEV-MULTI-001)

Technical improvements:
- BACKBEAT P2P operation tracking with phase management
- Enhanced configuration system with file-based secrets
- Improved error handling for license validation
- Clean separation of KACHING and CHORUS deployment stacks

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

vendor/github.com/libp2p/go-reuseport/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2013 Conformal Systems LLC.
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

vendor/github.com/libp2p/go-reuseport/README.md

@@ -0,0 +1,48 @@
+# go-reuseport
+
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](https://protocol.ai)
+[![GoDoc](https://godoc.org/github.com/libp2p/go-reuseport?status.svg)](https://godoc.org/github.com/libp2p/go-reuseport)
+[![](https://img.shields.io/badge/project-libp2p-yellow.svg?style=flat-square)](https://libp2p.io/)
+[![](https://img.shields.io/badge/freenode-%23libp2p-yellow.svg?style=flat-square)](https://webchat.freenode.net/?channels=%23libp2p)
+[![codecov](https://codecov.io/gh/libp2p/go-reuseport/branch/master/graph/badge.svg)](https://codecov.io/gh/libp2p/go-reuseport)
+[![Travis CI](https://travis-ci.org/libp2p/go-reuseport.svg?branch=master)](https://travis-ci.org/libp2p/go-reuseport)
+[![Discourse posts](https://img.shields.io/discourse/https/discuss.libp2p.io/posts.svg)](https://discuss.libp2p.io)
+
+This package enables listening and dialing from _the same_ TCP or UDP port.
+This means that the following sockopts may be set:
+
+```
+SO_REUSEADDR
+SO_REUSEPORT
+```
+
+This is a simple package to help with address reuse. This is particularly
+important when attempting to do TCP NAT holepunching, which requires a process
+to both Listen and Dial on the same TCP port. This package provides some
+utilities around enabling this behaviour on various OS.
+
+## Examples
+
+
+```Go
+// listen on the same port. oh yeah.
+l1, _ := reuse.Listen("tcp", "127.0.0.1:1234")
+l2, _ := reuse.Listen("tcp", "127.0.0.1:1234")
+```
+
+```Go
+// dial from the same port. oh yeah.
+l1, _ := reuse.Listen("tcp", "127.0.0.1:1234")
+l2, _ := reuse.Listen("tcp", "127.0.0.1:1235")
+c, _ := reuse.Dial("tcp", "127.0.0.1:1234", "127.0.0.1:1235")
+```
+
+**Note: cant dial self because tcp/ip stacks use 4-tuples to identify connections, and doing so would clash.**
+
+## Tested
+
+Tested on `darwin`, `linux`, and `windows`.
+
+---
+
+The last gx published version of this module was: 0.2.2: Qme8kdM7thoCqLqd7GYCRqipoZJS64rhJo5MBcTpyWfsL9

vendor/github.com/libp2p/go-reuseport/addr.go

@@ -0,0 +1,20 @@
+package reuseport
+
+import (
+	"net"
+)
+
+func ResolveAddr(network, address string) (net.Addr, error) {
+	switch network {
+	default:
+		return nil, net.UnknownNetworkError(network)
+	case "ip", "ip4", "ip6":
+		return net.ResolveIPAddr(network, address)
+	case "tcp", "tcp4", "tcp6":
+		return net.ResolveTCPAddr(network, address)
+	case "udp", "udp4", "udp6":
+		return net.ResolveUDPAddr(network, address)
+	case "unix", "unixgram", "unixpacket":
+		return net.ResolveUnixAddr(network, address)
+	}
+}

vendor/github.com/libp2p/go-reuseport/codecov.yml

@@ -0,0 +1,3 @@
+coverage:
+  range: "50...100"
+comment: off

vendor/github.com/libp2p/go-reuseport/control_freebsd.go

@@ -0,0 +1,27 @@
+//go:build freebsd
+
+package reuseport
+
+import (
+	"syscall"
+
+	"golang.org/x/sys/unix"
+)
+
+func Control(network, address string, c syscall.RawConn) (err error) {
+	controlErr := c.Control(func(fd uintptr) {
+		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1)
+		if err != nil {
+			return
+		}
+		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1)
+		if err != nil {
+			return
+		}
+		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT_LB, 1)
+	})
+	if controlErr != nil {
+		err = controlErr
+	}
+	return
+}

vendor/github.com/libp2p/go-reuseport/control_plan9.go

@@ -0,0 +1,9 @@
+package reuseport
+
+import (
+	"syscall"
+)
+
+func Control(network, address string, c syscall.RawConn) error {
+	return nil
+}

vendor/github.com/libp2p/go-reuseport/control_unix.go

@@ -0,0 +1,23 @@
+//go:build !plan9 && !windows && !wasm && !freebsd
+
+package reuseport
+
+import (
+	"syscall"
+
+	"golang.org/x/sys/unix"
+)
+
+func Control(network, address string, c syscall.RawConn) (err error) {
+	controlErr := c.Control(func(fd uintptr) {
+		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1)
+		if err != nil {
+			return
+		}
+		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1)
+	})
+	if controlErr != nil {
+		err = controlErr
+	}
+	return
+}

vendor/github.com/libp2p/go-reuseport/control_wasm.go

@@ -0,0 +1,11 @@
+//go:build wasm
+
+package reuseport
+
+import (
+	"syscall"
+)
+
+func Control(network, address string, c syscall.RawConn) error {
+	return nil
+}

vendor/github.com/libp2p/go-reuseport/control_windows.go

@@ -0,0 +1,17 @@
+package reuseport
+
+import (
+	"syscall"
+
+	"golang.org/x/sys/windows"
+)
+
+func Control(network, address string, c syscall.RawConn) (err error) {
+	controlErr := c.Control(func(fd uintptr) {
+		err = windows.SetsockoptInt(windows.Handle(fd), windows.SOL_SOCKET, windows.SO_REUSEADDR, 1)
+	})
+	if controlErr != nil {
+		err = controlErr
+	}
+	return
+}

vendor/github.com/libp2p/go-reuseport/interface.go

@@ -0,0 +1,72 @@
+// Package reuseport provides Listen and Dial functions that set socket
+// options in order to be able to reuse ports. You should only use this
+// package if you know what SO_REUSEADDR and SO_REUSEPORT are.
+//
+// For example:
+//
+//	// listen on the same port. oh yeah.
+//	l1, _ := reuse.Listen("tcp", "127.0.0.1:1234")
+//	l2, _ := reuse.Listen("tcp", "127.0.0.1:1234")
+//
+//	// dial from the same port. oh yeah.
+//	l1, _ := reuse.Listen("tcp", "127.0.0.1:1234")
+//	l2, _ := reuse.Listen("tcp", "127.0.0.1:1235")
+//	c, _ := reuse.Dial("tcp", "127.0.0.1:1234", "127.0.0.1:1235")
+//
+// Note: cant dial self because tcp/ip stacks use 4-tuples to identify connections,
+// and doing so would clash.
+package reuseport
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"time"
+)
+
+// Available returns whether or not SO_REUSEPORT or equivalent behaviour is
+// available in the OS.
+func Available() bool {
+	return true
+}
+
+var listenConfig = net.ListenConfig{
+	Control: Control,
+}
+
+// Listen listens at the given network and address. see net.Listen
+// Returns a net.Listener created from a file discriptor for a socket
+// with SO_REUSEPORT and SO_REUSEADDR option set.
+func Listen(network, address string) (net.Listener, error) {
+	return listenConfig.Listen(context.Background(), network, address)
+}
+
+// ListenPacket listens at the given network and address. see net.ListenPacket
+// Returns a net.Listener created from a file discriptor for a socket
+// with SO_REUSEPORT and SO_REUSEADDR option set.
+func ListenPacket(network, address string) (net.PacketConn, error) {
+	return listenConfig.ListenPacket(context.Background(), network, address)
+}
+
+// Dial dials the given network and address. see net.Dial
+// Returns a net.Conn created from a file descriptor for a socket
+// with SO_REUSEPORT and SO_REUSEADDR option set.
+func Dial(network, laddr, raddr string) (net.Conn, error) {
+	return DialTimeout(network, laddr, raddr, time.Duration(0))
+}
+
+// Dial dials the given network and address, with the given timeout. see
+// net.DialTimeout Returns a net.Conn created from a file descriptor for
+// a socket with SO_REUSEPORT and SO_REUSEADDR option set.
+func DialTimeout(network, laddr, raddr string, timeout time.Duration) (net.Conn, error) {
+	nla, err := ResolveAddr(network, laddr)
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve local addr: %w", err)
+	}
+	d := net.Dialer{
+		Control:   Control,
+		LocalAddr: nla,
+		Timeout:   timeout,
+	}
+	return d.Dial(network, raddr)
+}

vendor/github.com/libp2p/go-reuseport/version.json

@@ -0,0 +1,3 @@
+{
+  "version": "v0.4.0"
+}