Menú
CapTP: Capability Transfer Protocol
Basado en la clasificación ocupacional SOC
Query and explore the 2600: The Hacker Quarterly magazine archive (1984-present) via DuckDB. Provides structured access to 168+ issues covering hacker culture, security, privacy, telephony, and digital rights without loading full content into context.
ACSets (Attributed C-Sets): Algebraic databases with Specter-style bidirectional navigation. Category-theoretic formalism for relational databases.
Attributed C-Sets as algebraic databases. Category-theoretic data structures generalizing graphs and dataframes with Gay.jl color integration.
ACSets (Attributed C-Sets): Algebraic databases with Specter-style bidirectional
Bridge active inference theory with robot control using K-Scale's JAX/MuJoCo stack. Use when connecting predictive coding to locomotion policies, mapping KL divergence minimization to RL training, applying mean field approximation to robotics state estimation, or implementing sim2real as inference about future observations.
Implement affective valence as directional derivative of interoceptive energy landscapes for AI alignment. Use when building alignment-aware RL agents, validating GF(3) conservation in reward signals, training Langevin-based policies, or analyzing fold-change detection signals in POMDP environments.
| name | captp |
| description | CapTP: Capability Transfer Protocol |
| version | 1.0.0 |
Trit: 0 (ERGODIC - transports capabilities without amplification) Color: #46F27F (Coordinator stream) Source: Spritely Goblins (codeberg.org/spritely/goblins)
CapTP (Capability Transfer Protocol) enables distributed object programming with capability security. Objects can live anywhere on the network; CapTP abstracts location so programmers focus on object interaction, not protocol architecture.
Core principle: Capabilities are unforgeable references. You can only invoke what you've been given.
;; Guile Goblins
(define vat (spawn-vat))
(define greeter (vat-spawn vat ^greeter))
| Concept | Description | Trit Mapping |
|---|---|---|
| Vat | Transactional actor container | 0 (ergodic boundary) |
| Actor | Encapsulated object with behavior | +1 (generative) |
| Capability | Unforgeable reference | -1 (constraining) |
;; Don't wait for result - pipeline through promises
(<- (<- alice 'get-friend) 'greet "Hello")
Reduces round-trips: send message to promise, network resolves.
| Reference | Persistence | Use Case |
|---|---|---|
| Live | Session only | Active communication |
| Sturdy | Survives restart | Reconnection, storage |
op:deliver-only → Fire-and-forget message
op:deliver → Message expecting response
op:pick → Select from multiple promises
op:abort → Cancel pending operation
op:listen → Subscribe to updates
op:gc → Garbage collection hint
# Core CapTP Bundle
keychain-secure (-1) ⊗ captp (0) ⊗ gay-mcp (+1) = 0 ✓ [Secure Transport]
shadow-goblin (-1) ⊗ captp (0) ⊗ agent-o-rama (+1) = 0 ✓ [Distributed Actors]
polyglot-spi (-1) ⊗ captp (0) ⊗ pulse-mcp-stream (+1) = 0 ✓ [Cross-Lang Objects]
temporal-coalgebra (-1) ⊗ captp (0) ⊗ koopman-generator (+1) = 0 ✓ [State Observation]
# Goblins Integration
three-match (-1) ⊗ captp (0) ⊗ gay-mcp (+1) = 0 ✓ [Colored Capabilities]
sheaf-cohomology (-1) ⊗ captp (0) ⊗ operad-compose (+1) = 0 ✓ [Compositional]
| Spritely | Our System | Function |
|---|---|---|
spawn-vat | SplitMixTernary.new(seed) | Create isolated generator |
<- (send) | next_color! | Advance state, get result |
$ (call) | color_at(idx) | Synchronous access |
| Sturdy ref | (seed, index) tuple | Reconstructable reference |
| Promise | Derivation chain | Future state determined by seed |
require 'captp'
# Create vat (generator with transactional boundary)
vat = CapTP::Vat.new(seed: 0x42D)
# Spawn actor (color stream)
actor = vat.spawn(:color_stream)
# Send message (advance stream)
promise = actor.send(:next_color)
# Pipeline (derive without waiting)
result = actor.send(:palette, 5).then { |colors| colors.map(&:hex) }
(use-modules (goblins) (goblins actor-lib cell))
;; Define actor constructor
(define (^color-stream bcom seed)
(define idx (spawn ^cell 0))
(lambda (method . args)
(case method
((next-color)
(let ((i ($ idx)))
($ idx (+ i 1))
(color-at seed i)))
((palette)
(map (lambda (i) (color-at seed i))
(iota (car args)))))))
;; Spawn in vat
(define stream (spawn ^color-stream 1069))
(<- stream 'next-color) ;; => promise of color
| Layer | Transport | Use Case |
|---|---|---|
| Tor Onion | .onion addresses | Anonymous, censorship-resistant |
| TCP Direct | IP:port | Local network, low latency |
| WebSocket | wss:// | Browser-based (Hoot target) |
| NATS | nats:// | High-throughput pub/sub |
| Tailscale | 100.x.y.z | Mesh VPN, zero-config |
You can only:
1. Use capabilities you were given
2. Create new objects (that you then have caps to)
3. Introduce objects you have caps to, to each other
# Full capability
full_stream = vat.spawn(:color_stream, seed: 0x42D)
# Attenuated: read-only, no advance
read_only = full_stream.attenuate(:color_at)
# Attenuated: limited palette size
limited = full_stream.attenuate(:palette, max: 10)
just captp-vat seed=1069 # Create vat with seed
just captp-spawn actor_type # Spawn actor in vat
just captp-send actor method # Send message
just captp-pipeline expr # Pipeline expression
just captp-sturdy actor # Get sturdy reference
| Skill | Relation |
|---|---|
| localsend-mcp | P2P file transfer via CapTP-like protocol |
| tailscale-file-transfer | Mesh VPN netlayer |
| keychain-secure | Credential capabilities |
| shadow-goblin | Validates capability boundaries |
| agent-o-rama | Generates actor proposals |
Skill Name: captp Type: Distributed Object Protocol Trit: 0 (ERGODIC) GF(3): Transports capabilities without amplification Invariant: Capabilities unforgeable, only invoke what you're given
Part of: repl-commons (REPL-using skills intermix).
Part of: acp-commons.