fix(daemon): satisfy daemonapi.Daemon contract after common@v0.4.3 bump

The latest common (v0.4.3) added Sign to daemonapi.Daemon, Info to
daemonapi.Connection, and tightened PortAllocator.Bind to return
daemonapi.Listener instead of *Listener. PR #155's adapter (written
against earlier daemonapi) no longer satisfied the interface, breaking
`go build ./...` for cmd/daemon and tests/testenv.

Changes:
- Add *Daemon.Sign(msg) []byte — forwards to identity.Sign with nil
  guard for pre-bootstrap and in-memory test cases.
- Add *Connection.Info() daemonapi.ConnectionInfo — endpoint snapshot
  for plugin consumption (struct copy, holdable across goroutines).
- Add portAllocatorAdapter + listenerAdapter wrappers so Bind returns
  the daemonapi.Listener interface and Accept/Port/Close go through
  channel/field-shaped engine methods.
- Wire d.DaemonAPI() once in cmd/daemon/main.go and tests/testenv.go,
  thread the shared value into runtime.New / NewPolicyRuntime /
  NewHandshakeRuntime instead of passing engine-typed *Daemon.
- Bump go.mod to latest sibling pseudo-versions / betas.

Verified: go build ./... + go vet ./... clean; pilot-daemon binary
runs and prints --help.

Author: teovl

cmd/daemon/main.go

@@ -189,7 +189,15 @@ func main() {
 	// L11 plugin lifecycle (T7.1): composition root owns the
 	// ServiceRegistry via plugins/runtime. Daemon never imports
 	// pkg/coreapi.
-	rt := runtime.New(d)
+	//
+	// runtime + the per-plugin Runtime constructors take a
+	// daemonapi.Daemon. *Daemon doesn't satisfy that interface
+	// directly (engine-typed Connection/PortAllocator/etc.); the
+	// adapter at pkg/daemon/zz_daemonapi_conformance.go does. We
+	// resolve it once via d.DaemonAPI() and thread the shared value
+	// everywhere — keeps the type assertion in one place.
+	dapi := d.DaemonAPI()
+	rt := runtime.New(dapi)
 
 	ta := trustedagents.NewService()
 	if err := rt.Register(ta); err != nil {
@@ -215,14 +223,14 @@ func main() {
 		}
 	}
 
-	policySvc := policy.NewService(runtime.NewPolicyRuntime(d))
+	policySvc := policy.NewService(runtime.NewPolicyRuntime(dapi))
 	if err := rt.Register(policySvc); err != nil {
 		log.Fatalf("register policy: %v", err)
 	}
 	d.RegisterPolicyManager(runtime.AsDaemonPolicyManager(policySvc.Manager()))
 
 	// Manual trust-handshake (port 444) — extracted from pkg/daemon in T3.3.
-	hsSvc := handshake.NewService(runtime.NewHandshakeRuntime(d))
+	hsSvc := handshake.NewService(runtime.NewHandshakeRuntime(dapi))
 	if err := rt.Register(hsSvc); err != nil {
 		log.Fatalf("register handshake: %v", err)
 	}

go.mod

@@ -4,6 +4,7 @@ go 1.25.10
 
 require (
 	github.com/coder/websocket v1.8.14
+<<<<<<< HEAD
 	github.com/pilot-protocol/app-store v0.1.0
 	github.com/pilot-protocol/beacon v0.1.0
 	github.com/pilot-protocol/common v0.4.4
@@ -17,6 +18,21 @@ require (
 	github.com/pilot-protocol/skillinject v0.1.0
 	github.com/pilot-protocol/trustedagents v0.1.0
 	github.com/pilot-protocol/webhook v0.1.0
+=======
+	github.com/pilot-protocol/app-store v1.0.1-beta.1
+	github.com/pilot-protocol/beacon v0.2.3-0.20260529143248-4f632d9c0953
+	github.com/pilot-protocol/common v0.4.3
+	github.com/pilot-protocol/dataexchange v0.2.1-beta.1
+	github.com/pilot-protocol/eventstream v0.2.2
+	github.com/pilot-protocol/handshake v0.2.1-0.20260529034908-6f286b1fa5c8
+	github.com/pilot-protocol/nameserver v0.2.1
+	github.com/pilot-protocol/policy v0.2.1
+	github.com/pilot-protocol/rendezvous v0.2.2-0.20260529153356-45c9d2195c20
+	github.com/pilot-protocol/runtime v0.3.1-0.20260529034924-948bcb891b24
+	github.com/pilot-protocol/skillinject v0.2.2-0.20260529041510-e36bc173e7e7
+	github.com/pilot-protocol/trustedagents v0.2.3-beta.3
+	github.com/pilot-protocol/webhook v0.2.1-0.20260529034934-0d9094bbdede
+>>>>>>> 20c941f (fix(daemon): satisfy daemonapi.Daemon contract after common@v0.4.3 bump)
 )
 
 require (
@@ -49,7 +65,6 @@ replace github.com/pilot-protocol/app-store => ../app-store
 
 replace github.com/pilot-protocol/updater => ../updater
 
-replace github.com/pilot-protocol/common => ../common
 
 replace github.com/pilot-protocol/handshake => ../handshake
 

pkg/daemon/daemon.go

@@ -2002,6 +2002,21 @@ func (d *Daemon) Identity() *crypto.Identity {
 	return d.identity
 }
 
+// Sign signs msg with the daemon's Ed25519 private key. Returns nil
+// when no identity is loaded (in-memory tests, pre-bootstrap).
+//
+// Required by daemonapi.Daemon (common@v0.4.3). The adapter at
+// zz_daemonapi_conformance.go forwards to this directly.
+func (d *Daemon) Sign(msg []byte) []byte {
+	d.identityMu.RLock()
+	id := d.identity
+	d.identityMu.RUnlock()
+	if id == nil {
+		return nil
+	}
+	return id.Sign(msg)
+}
+
 // RotateKey generates a new Ed25519 keypair, proves ownership of the current
 // key to the registry via a `rotate:<node_id>` signature, atomically swaps the
 // in-memory identity on success, and persists it to disk. Returns the

pkg/daemon/zz_daemonapi_conformance.go

@@ -12,6 +12,67 @@ import (
 	registry "github.com/pilot-protocol/common/registry/client"
 )
 
+// --- Connection.Info ------------------------------------------------
+//
+// daemonapi.Connection requires Info() ConnectionInfo. Bolted onto
+// *Connection here (rather than ports.go) so the I/O-heavy types in
+// ports.go stay free of plugin-API concerns and the interface
+// fulfilment lives next to its adapter siblings.
+
+// Info returns an endpoint snapshot for plugin consumption. Required
+// by daemonapi.Connection (common@v0.4.3).
+func (c *Connection) Info() daemonapi.ConnectionInfo {
+	return daemonapi.ConnectionInfo{
+		LocalAddr:  c.LocalAddr,
+		LocalPort:  c.LocalPort,
+		RemoteAddr: c.RemoteAddr,
+		RemotePort: c.RemotePort,
+	}
+}
+
+// --- PortAllocator + Listener adapters ------------------------------
+//
+// daemonapi.PortAllocator wants Bind to return daemonapi.Listener.
+// daemonapi.Listener wants Accept/Port/Close methods. The concrete
+// *PortManager and *Listener types use channel-shaped APIs (TrySend,
+// AcceptCh) that pre-date daemonapi, so we wrap them here without
+// changing the engine's call sites.
+
+// portAllocatorAdapter wraps *PortManager so its Bind returns the
+// daemonapi.Listener interface (via a listenerAdapter) instead of
+// the daemon-engine-typed *Listener.
+type portAllocatorAdapter struct{ pm *PortManager }
+
+func (a portAllocatorAdapter) Bind(port uint16) (daemonapi.Listener, error) {
+	ln, err := a.pm.Bind(port)
+	if err != nil {
+		return nil, err
+	}
+	return listenerAdapter{ln: ln}, nil
+}
+
+func (a portAllocatorAdapter) Unbind(port uint16) { a.pm.Unbind(port) }
+
+// listenerAdapter wraps *Listener so it satisfies daemonapi.Listener:
+// channel-shaped AcceptCh becomes an Accept() method, the Port field
+// becomes a Port() method, and close() becomes Close().
+type listenerAdapter struct{ ln *Listener }
+
+func (a listenerAdapter) Accept() (daemonapi.Connection, bool) {
+	conn, ok := <-a.ln.AcceptCh
+	if !ok {
+		return nil, false
+	}
+	return conn, true
+}
+
+func (a listenerAdapter) Port() uint16 { return a.ln.Port }
+
+func (a listenerAdapter) Close() error {
+	a.ln.close()
+	return nil
+}
+
 // daemonAPIAdapter wraps a *Daemon to satisfy daemonapi.Daemon.
 //
 // Why an adapter instead of changing *Daemon's method signatures:
@@ -49,6 +110,7 @@ func (a daemonAPIAdapter) Stop() error  { return a.d.Stop() }
 func (a daemonAPIAdapter) NodeID() uint32             { return a.d.NodeID() }
 func (a daemonAPIAdapter) Identity() *crypto.Identity { return a.d.Identity() }
 func (a daemonAPIAdapter) IdentityPath() string       { return a.d.IdentityPath() }
+func (a daemonAPIAdapter) Sign(msg []byte) []byte     { return a.d.Sign(msg) }
 
 // --- Configuration ---------------------------------------------------
 
@@ -95,7 +157,9 @@ func (a daemonAPIAdapter) NewConnReadWriter(c daemonapi.Connection) daemonapi.Co
 	return a.d.NewConnReadWriter(conn)
 }
 
-func (a daemonAPIAdapter) Ports() daemonapi.PortAllocator    { return a.d.Ports() }
+func (a daemonAPIAdapter) Ports() daemonapi.PortAllocator {
+	return portAllocatorAdapter{pm: a.d.Ports()}
+}
 func (a daemonAPIAdapter) Tunnels() daemonapi.TunnelRegistry { return a.d.Tunnels() }
 
 // --- Registry --------------------------------------------------------

tests/testenv.go

@@ -218,7 +218,12 @@ func (env *TestEnv) AddDaemonOnly(opts ...func(*daemon.Config)) (*daemon.Daemon,
 // corresponding plugin is skipped. Returns the runtime so callers
 // can call StartPlugins/StopPlugins around d.Start/d.Stop.
 func registerStandardPlugins(t testingT, d *daemon.Daemon, cfg *daemon.Config) *pluginsruntime.Runtime {
-	rt := pluginsruntime.New(d)
+	// runtime + per-plugin Runtime constructors expect daemonapi.Daemon.
+	// *Daemon satisfies that interface via the adapter at
+	// pkg/daemon/zz_daemonapi_conformance.go; we resolve it once and
+	// thread the shared value everywhere — same shape as cmd/daemon.
+	dapi := d.DaemonAPI()
+	rt := pluginsruntime.New(dapi)
 	if !cfg.DisableDataExchange {
 		if err := rt.Register(dataexchange.NewService(dataexchange.ServiceConfig{})); err != nil {
 			t.Fatalf("register dataexchange: %v", err)
@@ -230,7 +235,7 @@ func registerStandardPlugins(t testingT, d *daemon.Daemon, cfg *daemon.Config) *
 		}
 	}
 	if !cfg.DisablePolicyRunner {
-		policySvc := policy.NewService(pluginsruntime.NewPolicyRuntime(d))
+		policySvc := policy.NewService(pluginsruntime.NewPolicyRuntime(dapi))
 		if err := rt.Register(policySvc); err != nil {
 			t.Fatalf("register policy: %v", err)
 		}
@@ -239,7 +244,7 @@ func registerStandardPlugins(t testingT, d *daemon.Daemon, cfg *daemon.Config) *
 	// Handshake plugin (T3.3) — registered by default so production
 	// behavior matches: tests that don't want it can flip a Disable*
 	// flag on Config (none today, since smoke + e2e all need handshake).
-	hsSvc := handshake.NewService(pluginsruntime.NewHandshakeRuntime(d))
+	hsSvc := handshake.NewService(pluginsruntime.NewHandshakeRuntime(dapi))
 	if err := rt.Register(hsSvc); err != nil {
 		t.Fatalf("register handshake: %v", err)
 	}