Node-engine: the have, the node's facts, the record, the health report and the data items are the seat's contract types, written through the node-engine client; the interim bridge is gone (Have group, ADR 0634 §1, §4; issue 1966)

Claude-Session: https://claude.ai/code/session_01NcbgfFSnn24M3GcqttoU7i

internal/selfcompose/selfcompose.go

@@ -19,6 +19,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"git.novox.be/novox/mesh-contracts/go/clients/nodeengineclient"
+	"git.novox.be/novox/mesh-contracts/go/seats/nodeengine"
+	"github.com/novox/mesh-host/internal/buckets"
 	"github.com/novox/mesh-host/internal/compositions"
 	engcomp "github.com/novox/mesh-host/internal/compositions"
 	"maps"
@@ -76,7 +79,7 @@ type Env struct {
 	Unseal  func(sealed string) ([]byte, error)
 	// Held is the sealed values a module's have says it runs, kept by the agent on the bus: what runs after a restart,
 	// before the agent applied anything, and after the switch once the kept declaration is old. By slot
-	// (delivery.Have.SealedAt); legacy is the list a have written before slots holds (delivery.Have.Sealed), reused
+	// (nodeengine.HaveByNodeModuleValue.SealedAt); legacy is the list a have written before slots holds (nodeengine.HaveByNodeModuleValue.Sealed), reused
 	// only within its own module.
 	// An error is a have the bus did not answer for, never one absent: the pass is then tried again (BusFailed).
 	Held func(module string) (slots compositions.Seals, legacy []string, err error)
@@ -131,7 +134,7 @@ type Composer struct {
 	// placementKeys is the seat's state placement key by key in either form, each node's placement assembled from it
 	// (delivery.PlacementKeys; research 072 row 37): a write of the holder's under way is never composed half.
 	placementKeys *delivery.PlacementKeys
-	records       map[string]delivery.NodeRecord
+	records       map[string]nodeengine.NodeRecord
 	// inOwn is, by module, whether this node's have of it names no fingerprint of the new form (mesh-wireguard, a module
 	// at a build of the old form): the node runs it inside its own composition, and composes it there again (issue 1126).
 	inOwn     map[string]bool
@@ -298,7 +301,7 @@ func New(env Env) *Composer {
 		env.Say = func(string) {}
 	}
 	return &Composer{env: env, wants: map[string]delivery.Want{}, placements: map[string]delivery.Placement{}, placementKeys: delivery.NewPlacementKeys(),
-		records: map[string]delivery.NodeRecord{}, inOwn: map[string]bool{}, modules: map[string]delivery.Module{}, values: map[string]map[string]any{},
+		records: map[string]nodeengine.NodeRecord{}, inOwn: map[string]bool{}, modules: map[string]delivery.Module{}, values: map[string]map[string]any{},
 		manifests: map[string][]byte{}, archives: map[string][]byte{}, builds: map[string]delivery.BuilderBuild{}, handed: map[string]string{}, sealedOwn: map[string]ownSealed{},
 		pkgs: map[string]compositions.Composed{}, asked: make(chan chan Pass, 8)}
 }
@@ -357,8 +360,8 @@ func (c *Composer) inputs() []input {
 		// Every node's record, and this node's own haves (what it runs inside its own composition): two watches, each
 		// within the node's grant (buscompose: readGrants of the have bucket at `*.node`, NodeKeysGrants at `<node>.>`).
 		// A watch of every key is refused by the bus (issue 1126, 2026-10-27 09:21: the fold's `>` stopped every agent).
-		{delivery.HaveBucket, "*." + delivery.HaveNodeWord, nil, (*Composer).takeRecordChanged},
-		{delivery.HaveBucket, node + ".>", nil, (*Composer).takeModuleHave},
+		{buckets.Have, "*." + nodeengineclient.NodeWord, nil, (*Composer).takeRecordChanged},
+		{buckets.Have, node + ".>", nil, (*Composer).takeModuleHave},
 		{delivery.ModulesBucket, ">", (*Composer).takeModule, nil},
 		{ResolvedBucket, node + ".>", (*Composer).takeValue, nil},
 		// The builder's builds: a pass that held a module for a build not yet done is made again when it lands (issue
@@ -690,13 +693,13 @@ func (c *Composer) takePlacement(u agent.Update) {
 }
 
 func (c *Composer) takeRecord(u agent.Update) {
-	node, _, isNode, err := delivery.ParseHaveKey(u.Key)
+	node, _, isNode, err := nodeengineclient.ParseHaveKey(u.Key)
 	if err != nil || !isNode {
 		return
 	}
 	c.mu.Lock()
 	defer c.mu.Unlock()
-	h, err := delivery.DecodeHaveNode(u.Value)
+	h, err := nodeengineclient.DecodeHaveNode(u.Value)
 	if u.Deleted || err != nil || h.Record == nil {
 		delete(c.records, node)
 		return
@@ -715,13 +718,13 @@ func (c *Composer) takeRecordChanged(u agent.Update) bool {
 // id; mesh-wireguard: none). Read from the haves, which outlast a restart, never from what the agent has applied
 // this run: a fresh agent composes before it applies anything (review of the fold, round 1).
 func (c *Composer) takeModuleHave(u agent.Update) bool {
-	node, module, isNode, err := delivery.ParseHaveKey(u.Key)
+	node, module, isNode, err := nodeengineclient.ParseHaveKey(u.Key)
 	if err != nil || isNode || node != c.env.Node {
 		return false
 	}
 	in := false
 	if !u.Deleted {
-		if h, err := delivery.DecodeHave(u.Value); err == nil {
+		if h, err := nodeengineclient.DecodeHave(u.Value); err == nil {
 			// A have that names nothing it runs, failed (the node could not compose a module it never ran: NotComposed), is
 			// no module run inside the node's own composition: taken as one, it was composed from its manifest past its
 			// build (issue 1126, review round 1 of the builds).
@@ -729,9 +732,9 @@ func (c *Composer) takeModuleHave(u agent.Update) bool {
 			// mesh-host #189, novox's postgres 2026-10-31): taken as one, it was composed from its manifest and refused
 			// for its secret reader before the start backed it up again. Any other have naming nothing keeps the rule
 			// (waiting for a yes inside the node's own stays in).
-			interrupted := h.Phase == delivery.PhaseHeld && h.Detail == agent.BackupInterrupted
-			runsNothing := (h.Phase == delivery.PhaseFailed || interrupted) && h.FP == "" && h.Composed == ""
-			in = h.Phase != delivery.PhaseRemoved && !runsNothing && !strings.HasPrefix(h.FP, delivery.SourcePrefix2)
+			interrupted := h.Phase == nodeengineclient.PhaseHeld && h.Detail == agent.BackupInterrupted
+			runsNothing := (h.Phase == nodeengineclient.PhaseFailed || interrupted) && h.Fp == "" && h.Composed == ""
+			in = h.Phase != nodeengineclient.PhaseRemoved && !runsNothing && !strings.HasPrefix(h.Fp, delivery.SourcePrefix2)
 		}
 	}
 	c.mu.Lock()
@@ -749,7 +752,7 @@ func (c *Composer) takeModuleHave(u agent.Update) bool {
 
 // inOwnOf is, of the modules p places, those the node runs inside its own composition (c.inOwn), sorted; c.mu held.
 // Machines is, from the placements this composer holds, each node by its address on the private network, and the hub's
-// node: what names the machine a failing network part points at (delivery.NetworkPart.Targets, issue 774). Empty
+// node: what names the machine a failing network part points at (nodeengine.NetworkPart.Targets, issue 774). Empty
 // before any placement is read.
 func (c *Composer) Machines() (byAddress map[string]string, hub string) {
 	c.mu.Lock()
@@ -1079,7 +1082,7 @@ func (c *Composer) refused(why string, held map[string]string) {
 	c.refusal = said
 	c.held = heldModules(held)
 	if why != "" {
-		c.held = append(c.held, delivery.HaveNodeWord)
+		c.held = append(c.held, nodeengineclient.NodeWord)
 	}
 	c.mu.Unlock()
 	if !same && c.env.Refused != nil {
@@ -1374,10 +1377,10 @@ func (r reader) Placements(context.Context) (map[string]delivery.Placement, erro
 	return out, nil
 }
 
-func (r reader) Records(context.Context) (map[string]delivery.NodeRecord, error) {
+func (r reader) Records(context.Context) (map[string]nodeengine.NodeRecord, error) {
 	r.c.mu.Lock()
 	defer r.c.mu.Unlock()
-	out := make(map[string]delivery.NodeRecord, len(r.c.records))
+	out := make(map[string]nodeengine.NodeRecord, len(r.c.records))
 	for k, v := range r.c.records {
 		out[k] = v
 	}