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/multiformats/go-base36/LICENSE.md

@@ -0,0 +1,22 @@
+The software contents of this repository are Copyright (c) Protocol Labs,
+Licensed under the `Permissive License Stack`, meaning either of:
+
+- Apache-2.0 Software License: https://www.apache.org/licenses/LICENSE-2.0
+  ([...4tr2kfsq](https://gateway.ipfs.io/ipfs/bafkreiankqxazcae4onkp436wag2lj3ccso4nawxqkkfckd6cg4tr2kfsq))
+
+- MIT Software License: https://opensource.org/licenses/MIT
+  ([...vljevcba](https://gateway.ipfs.io/ipfs/bafkreiepofszg4gfe2gzuhojmksgemsub2h4uy2gewdnr35kswvljevcba))
+
+You may not use the contents of this repository except in compliance
+with one of the listed Licenses. For an extended clarification of the
+intent behind the choice of Licensing please refer to
+https://protocol.ai/blog/announcing-the-permissive-license-stack/
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the terms listed in this notice is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See each License for the specific language
+governing permissions and limitations under that License.
+
+<!--- SPDX-License-Identifier: Apache-2.0 OR MIT -->
+`SPDX-License-Identifier: Apache-2.0 OR MIT`

vendor/github.com/multiformats/go-base36/README.md

@@ -0,0 +1,22 @@
+multiformats/go-base36
+=======================
+
+> Simple base36 codec
+
+This is an optimized codec for []byte <=> base36 string conversion
+
+## Documentation
+
+https://pkg.go.dev/github.com/multiformats/go-base36
+
+## Lead Maintainer
+
+[Steven Allen](https://github.com/stebalien)
+
+## Contributing
+
+Contributions are welcome! This repository is related to the IPFS project and therefore governed by our [contributing guidelines](https://github.com/ipfs/community/blob/master/CONTRIBUTING.md).
+
+## License
+
+[SPDX-License-Identifier: Apache-2.0 OR MIT](LICENSE.md)

vendor/github.com/multiformats/go-base36/base36.go

@@ -0,0 +1,143 @@
+/*
+Package base36 provides a reasonably fast implementation of a binary base36 codec.
+*/
+package base36
+
+// Simplified code based on https://godoc.org/github.com/mr-tron/base58
+// which in turn is based on https://github.com/trezor/trezor-crypto/commit/89a7d7797b806fac
+
+import (
+	"fmt"
+)
+
+const UcAlphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+const LcAlphabet = "0123456789abcdefghijklmnopqrstuvwxyz"
+const maxDigitOrdinal = 'z'
+const maxDigitValueB36 = 35
+
+var revAlphabet [maxDigitOrdinal + 1]byte
+
+func init() {
+	for i := range revAlphabet {
+		revAlphabet[i] = maxDigitValueB36 + 1
+	}
+	for i, c := range UcAlphabet {
+		revAlphabet[byte(c)] = byte(i)
+		if c > '9' {
+			revAlphabet[byte(c)+32] = byte(i)
+		}
+	}
+}
+
+// EncodeToStringUc encodes the given byte-buffer as base36 using [0-9A-Z] as
+// the digit-alphabet
+func EncodeToStringUc(b []byte) string { return encode(b, UcAlphabet) }
+
+// EncodeToStringLc encodes the given byte-buffer as base36 using [0-9a-z] as
+// the digit-alphabet
+func EncodeToStringLc(b []byte) string { return encode(b, LcAlphabet) }
+
+func encode(inBuf []byte, al string) string {
+
+	bufsz := len(inBuf)
+	zcnt := 0
+	for zcnt < bufsz && inBuf[zcnt] == 0 {
+		zcnt++
+	}
+
+	// It is crucial to make this as short as possible, especially for
+	// the usual case of CIDs.
+	bufsz = zcnt +
+		// This is an integer simplification of
+		// ceil(log(256)/log(36))
+		(bufsz-zcnt)*277/179 + 1
+
+	// Note: pools *DO NOT* help, the overhead of zeroing
+	// kills any performance gain to be had
+	out := make([]byte, bufsz)
+
+	var idx, stopIdx int
+	var carry uint32
+
+	stopIdx = bufsz - 1
+	for _, b := range inBuf[zcnt:] {
+		idx = bufsz - 1
+		for carry = uint32(b); idx > stopIdx || carry != 0; idx-- {
+			carry += uint32((out[idx])) * 256
+			out[idx] = byte(carry % 36)
+			carry /= 36
+		}
+		stopIdx = idx
+	}
+
+	// Determine the additional "zero-gap" in the buffer (aside from zcnt)
+	for stopIdx = zcnt; stopIdx < bufsz && out[stopIdx] == 0; stopIdx++ {
+	}
+
+	// Now encode the values with actual alphabet in-place
+	vBuf := out[stopIdx-zcnt:]
+	bufsz = len(vBuf)
+	for idx = 0; idx < bufsz; idx++ {
+		out[idx] = al[vBuf[idx]]
+	}
+
+	return string(out[:bufsz])
+}
+
+// DecodeString takes a base36 encoded string and returns a slice of the decoded
+// bytes.
+func DecodeString(s string) ([]byte, error) {
+
+	if len(s) == 0 {
+		return nil, fmt.Errorf("can not decode zero-length string")
+	}
+
+	zcnt := 0
+	for zcnt < len(s) && s[zcnt] == '0' {
+		zcnt++
+	}
+
+	// the 32bit algo stretches the result up to 2 times
+	binu := make([]byte, 2*(((len(s))*179/277)+1)) // no more than 84 bytes when len(s) <= 64
+	outi := make([]uint32, (len(s)+3)/4)           // no more than 16 bytes when len(s) <= 64
+
+	for _, r := range s {
+		if r > maxDigitOrdinal || revAlphabet[r] > maxDigitValueB36 {
+			return nil, fmt.Errorf("invalid base36 character (%q)", r)
+		}
+
+		c := uint64(revAlphabet[r])
+
+		for j := len(outi) - 1; j >= 0; j-- {
+			t := uint64(outi[j])*36 + c
+			c = (t >> 32)
+			outi[j] = uint32(t & 0xFFFFFFFF)
+		}
+	}
+
+	mask := (uint(len(s)%4) * 8)
+	if mask == 0 {
+		mask = 32
+	}
+	mask -= 8
+
+	outidx := 0
+	for j := 0; j < len(outi); j++ {
+		for mask < 32 { // loop relies on uint overflow
+			binu[outidx] = byte(outi[j] >> mask)
+			mask -= 8
+			outidx++
+		}
+		mask = 24
+	}
+
+	// find the most significant byte post-decode, if any
+	for msb := zcnt; msb < outidx; msb++ {
+		if binu[msb] > 0 {
+			return binu[msb-zcnt : outidx : outidx], nil
+		}
+	}
+
+	// it's all zeroes
+	return binu[:outidx:outidx], nil
+}

vendor/github.com/multiformats/go-base36/version.json

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