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
2026-11-05 15:21:48 +01:00
parent 5906e18028
commit 7eb7b9fa62
44 changed files with 650 additions and 549 deletions
@@ -4,6 +4,8 @@ import (
 	"context"
 	"encoding/json"
 	"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/compositions"
 	"maps"
 	"slices"
@@ -300,7 +302,7 @@ func TestAWantAndItsCompositionApplyTheModuleAndTheHaveNamesBoth(t *testing.T) {
 	eventually(t, "the module was not applied", func() bool { return len(b.appliedList()) == 1 })
 	eventually(t, "the have does not name both", func() bool {
 		h := b.haves.last("web")
-		return h.FP == fp && h.Composed == dig && h.Phase == string(delivery.PhaseRunning)
+		return h.FP == fp && h.Composed == dig && h.Phase == string(nodeengineclient.PhaseRunning)
 	})
 	// Settled is told once what runs holds the module, so a declaration read then names its files (the filling's Knock;
 	// ace, 2026-10-25 21:17).
@@ -337,7 +339,7 @@ func TestStartingOnWhatTheKeptDeclarationHoldsAppliesNothing(t *testing.T) {
 	stop := b.run()
 	defer stop()
 	eventually(t, "the have was not written", func() bool { return b.haves.last("web").Composed == dig })
-	if h := b.haves.last("web"); h.FP != fp || h.Phase != string(delivery.PhaseRunning) {
+	if h := b.haves.last("web"); h.FP != fp || h.Phase != string(nodeengineclient.PhaseRunning) {
 		t.Fatalf("the have: %+v", h)
 	}
 	time.Sleep(50 * time.Millisecond)
@@ -357,7 +359,7 @@ func TestStartingOnItsOwnHaveAppliesNothing(t *testing.T) {
 		fp := fpOf("a")
 		ck, craw, dig := composition(t, "avahi", fp, false, file("avahi", "x", "1"))
 		wk, wraw := wantFor(t, "avahi", fp, dig, "")
-		b.haves.stored = map[string]Have{"avahi": {Module: "avahi", FP: fp, Composed: dig, Phase: string(delivery.PhaseFailed),
+		b.haves.stored = map[string]Have{"avahi": {Module: "avahi", FP: fp, Composed: dig, Phase: string(nodeengineclient.PhaseFailed),
 			Detail: "apply: unit failed to start"}}
 		b.comps.before(ck, craw)
 		b.wants.before(wk, wraw)
@@ -372,7 +374,7 @@ func TestStartingOnItsOwnHaveAppliesNothing(t *testing.T) {
 		fp := fpOf("a")
 		ck, craw, dig := composition(t, "avahi", fp, false, file("avahi", "x", "1"))
 		wk, wraw := wantFor(t, "avahi", fp, dig, "")
-		b.haves.stored = map[string]Have{"avahi": {Module: "avahi", FP: fp, Composed: dig, Phase: string(delivery.PhaseFailed),
+		b.haves.stored = map[string]Have{"avahi": {Module: "avahi", FP: fp, Composed: dig, Phase: string(nodeengineclient.PhaseFailed),
 			Detail: NotComposedDetail + "frombus: the credentials of ace: context canceled"}}
 		b.comps.before(ck, craw)
 		b.wants.before(wk, wraw)
@@ -380,7 +382,7 @@ func TestStartingOnItsOwnHaveAppliesNothing(t *testing.T) {
 		defer stop()
 		eventually(t, "the mark was not cleared", func() bool {
 			h := b.haves.last("avahi")
-			return h.Phase == string(delivery.PhaseRunning) && h.FP == fp && h.Composed == dig && h.Detail == ""
+			return h.Phase == string(nodeengineclient.PhaseRunning) && h.FP == fp && h.Composed == dig && h.Detail == ""
 		})
 		if got := b.appliedList(); len(got) != 0 {
 			t.Fatalf("a module whose mark names what the want names was applied: %v", got)
@@ -427,7 +429,7 @@ func testStartingOnItsOwnHaveSaysTheHaveAgainSoItsHealthIsThisEngines(t *testing
 	if len(log) != 1 {
 		t.Fatalf("the have was said %d times, want once: %+v", len(log), log)
 	}
-	if h := log[0]; h.Module != "xorg" || h.FP != fp || h.Composed != dig || h.Phase != string(delivery.PhaseRunning) || h.Detail != "kept" {
+	if h := log[0]; h.Module != "xorg" || h.FP != fp || h.Composed != dig || h.Phase != string(nodeengineclient.PhaseRunning) || h.Detail != "kept" {
 		t.Fatalf("the have said again: %+v", h)
 	}
 	if got := b.appliedList(); len(got) != 0 {
@@ -454,7 +456,7 @@ func TestAFailedApplyIsRetriedOnlyByAChangeOfEitherKey(t *testing.T) {
 		eventually(t, "not applied", func() bool { return len(b.appliedList()) == 1 })
 		eventually(t, "the have does not say failed", func() bool {
 			h := b.haves.last("web")
-			return h.Phase == string(delivery.PhaseFailed) && strings.Contains(h.Detail, "no space") && h.FP == fp
+			return h.Phase == string(nodeengineclient.PhaseFailed) && strings.Contains(h.Detail, "no space") && h.FP == fp
 		})
 		// An unrelated key changes: not a retry.
 		ck9, craw9, _ := composition(t, "web", fpOf("9"), false, file("web", "x", "9"))
@@ -472,7 +474,7 @@ func TestAFailedApplyIsRetriedOnlyByAChangeOfEitherKey(t *testing.T) {
 			t.Fatalf("a failed apply was refused a retry: %v", err)
 		}
 		eventually(t, "the asked retry did not apply", func() bool { return len(b.appliedList()) == 2 })
-		eventually(t, "not running", func() bool { return b.haves.last("web").Phase == string(delivery.PhaseRunning) })
+		eventually(t, "not running", func() bool { return b.haves.last("web").Phase == string(nodeengineclient.PhaseRunning) })
 		for module, words := range map[string]string{"web": "runs what its want names", "ghost": "has no want"} {
 			if err := b.ag.RetryFailed(module); err == nil || !strings.Contains(err.Error(), words) {
 				t.Errorf("a retry of %s: %v, want refused saying %q", module, err, words)
@@ -509,7 +511,7 @@ func TestAFailedApplyIsRetriedOnlyByAChangeOfEitherKey(t *testing.T) {
 		eventually(t, "not applied", func() bool { return len(b.appliedList()) == 1 })
 		eventually(t, "the have does not say whom it waits on", func() bool {
 			h := b.haves.last("web")
-			return h.Phase == string(delivery.PhaseFailed) && strings.Contains(h.Detail, "tried again once distribution has settled")
+			return h.Phase == string(nodeengineclient.PhaseFailed) && strings.Contains(h.Detail, "tried again once distribution has settled")
 		})
 		b.idle()
 		if n := len(b.appliedList()); n != 1 {
@@ -527,7 +529,7 @@ func TestAFailedApplyIsRetriedOnlyByAChangeOfEitherKey(t *testing.T) {
 		eventually(t, "not tried again on the holder's settled", func() bool { return len(b.appliedList()) == 2 })
 		eventually(t, "the have does not say what triggered the retry", func() bool {
 			h := b.haves.last("web")
-			return h.Phase == string(delivery.PhaseFailed) && strings.Contains(h.Detail, "last tried again at") && strings.Contains(h.Detail, "distribution settled")
+			return h.Phase == string(nodeengineclient.PhaseFailed) && strings.Contains(h.Detail, "last tried again at") && strings.Contains(h.Detail, "distribution settled")
 		})
 		b.idle()
 		if n := len(b.appliedList()); n != 2 {
@@ -536,7 +538,7 @@ func TestAFailedApplyIsRetriedOnlyByAChangeOfEitherKey(t *testing.T) {
 		// The failed have carries the pull it waits on (ENG-9, read through node_haves): the image, whose settled it waits
 		// on, and what triggered the last retry.
 		if w := b.haves.last("web").PullWait; w == nil || w.Holder != "distribution" || w.Image != "reg/x@sha256:1" ||
-			w.Began.IsZero() || !strings.Contains(w.Retried, "distribution settled") || w.RetriedAt.IsZero() {
+			w.Began.IsZero() || !strings.Contains(w.Retried, "distribution settled") || w.RetriedAt == nil {
 			t.Fatalf("the failed have says it waits on %+v", w)
 		}
 		// The next settled answers once more, and the pull works: the module runs, and waits on nothing.
@@ -546,7 +548,7 @@ func TestAFailedApplyIsRetriedOnlyByAChangeOfEitherKey(t *testing.T) {
 		tick()
 		b.ag.Settled("distribution")
 		eventually(t, "not tried again on the next settled", func() bool { return len(b.appliedList()) == 3 })
-		eventually(t, "not running", func() bool { return b.haves.last("web").Phase == string(delivery.PhaseRunning) })
+		eventually(t, "not running", func() bool { return b.haves.last("web").Phase == string(nodeengineclient.PhaseRunning) })
 		if w := b.haves.last("web").PullWait; w != nil {
 			t.Fatalf("a running module's have still waits on %+v", w)
 		}
@@ -620,11 +622,11 @@ func TestAFailedApplyIsRetriedOnlyByAChangeOfEitherKey(t *testing.T) {
 				b.ag.RetryTransient()
 			}
 			eventually(t, "not applied again without a new revision", func() bool { return len(b.appliedList()) == 2 })
-			eventually(t, "not running", func() bool { return b.haves.last("vault").Phase == string(delivery.PhaseRunning) })
+			eventually(t, "not running", func() bool { return b.haves.last("vault").Phase == string(nodeengineclient.PhaseRunning) })
 			b.haves.mu.Lock()
 			defer b.haves.mu.Unlock()
 			for _, h := range b.haves.log {
-				if h.Phase == string(delivery.PhaseFailed) {
+				if h.Phase == string(nodeengineclient.PhaseFailed) {
 					t.Errorf("a transient failure was written failed: %+v", h)
 				}
 			}
@@ -664,7 +666,7 @@ func TestADataModuleIsBackedUpFirstAndHeldWhenItFails(t *testing.T) {
 	})
 	eventually(t, "the have does not say held", func() bool {
 		h := b.haves.last("db")
-		return h.Phase == string(delivery.PhaseHeld) && strings.Contains(h.Detail, "repository is locked") && h.FP == fp1
+		return h.Phase == string(nodeengineclient.PhaseHeld) && strings.Contains(h.Detail, "repository is locked") && h.FP == fp1
 	})
 	if got := b.appliedList(); len(got) != 0 {
 		t.Fatalf("something was applied behind a failed backup: %v", got)
@@ -703,7 +705,7 @@ func TestADataModuleIsBackedUpFirstAndHeldWhenItFails(t *testing.T) {
 	}
 	eventually(t, "not running at the new fingerprint", func() bool {
 		h := b.haves.last("db")
-		return h.Phase == string(delivery.PhaseRunning) && h.FP == fp2 && h.Composed == dig2
+		return h.Phase == string(nodeengineclient.PhaseRunning) && h.FP == fp2 && h.Composed == dig2
 	})

 	// The node agent stopped while the backup ran, the module known only from its have: the held have names what runs
@@ -713,7 +715,7 @@ func TestADataModuleIsBackedUpFirstAndHeldWhenItFails(t *testing.T) {
 	ib.comps.before(ck2, craw2)
 	iwk, iwraw := wantFor(t, "db", fp2, dig2, delivery.BackupAgain)
 	ib.wants.before(iwk, iwraw)
-	ib.haves.stored = map[string]Have{"db": {Module: "db", FP: fp1, Composed: dig1, Phase: string(delivery.PhaseRunning)}}
+	ib.haves.stored = map[string]Have{"db": {Module: "db", FP: fp1, Composed: dig1, Phase: string(nodeengineclient.PhaseRunning)}}
 	began := make(chan struct{})
 	ib.env.Backup = func(ctx context.Context, _ string) Backup {
 		close(began)
@@ -723,7 +725,7 @@ func TestADataModuleIsBackedUpFirstAndHeldWhenItFails(t *testing.T) {
 	stopI := ib.run()
 	<-began
 	stopI()
-	if h := ib.haves.last("db"); h.Phase != string(delivery.PhaseHeld) || h.FP != fp1 || h.Composed != dig1 || h.Detail != BackupInterrupted {
+	if h := ib.haves.last("db"); h.Phase != string(nodeengineclient.PhaseHeld) || h.FP != fp1 || h.Composed != dig1 || h.Detail != BackupInterrupted {
 		t.Errorf("held after an interrupted backup: %+v", h)
 	}

@@ -733,24 +735,24 @@ func TestADataModuleIsBackedUpFirstAndHeldWhenItFails(t *testing.T) {
 	for _, row := range []struct {
 		detail, backup   string
 		backups, applied int
-		phase            delivery.Phase
+		phase            string
 		namesNothing     bool // the have names no fp and no composition
 	}{
-		{BackupInterrupted, delivery.BackupAgain, 1, 1, delivery.PhaseRunning, false},
+		{BackupInterrupted, delivery.BackupAgain, 1, 1, nodeengineclient.PhaseRunning, false},
 		// novox's postgres: its held have, written before mesh-host #189, names nothing it runs.
-		{BackupInterrupted, "", 1, 1, delivery.PhaseRunning, true},
+		{BackupInterrupted, "", 1, 1, nodeengineclient.PhaseRunning, true},
 		// A backup that failed, and the want carries the operator's answer, written before this start (nats on novox,
 		// 2026-11-04, issue 1585): again backs it up and applies, skip applies without one; no answer keeps the hold.
-		{"restic: the repository is locked", delivery.BackupAgain, 1, 1, delivery.PhaseRunning, false},
-		{"restic: the repository is locked", delivery.BackupSkip, 0, 1, delivery.PhaseRunning, false},
-		{"restic: the repository is locked", "", 0, 0, delivery.PhaseHeld, false},
+		{"restic: the repository is locked", delivery.BackupAgain, 1, 1, nodeengineclient.PhaseRunning, false},
+		{"restic: the repository is locked", delivery.BackupSkip, 0, 1, nodeengineclient.PhaseRunning, false},
+		{"restic: the repository is locked", "", 0, 0, nodeengineclient.PhaseHeld, false},
 	} {
 		r := newBed(t)
 		r.comps.before(ck1, craw1)
 		r.comps.before(ck2, craw2)
 		wk, wraw := wantFor(t, "db", fp2, dig2, row.backup)
 		r.wants.before(wk, wraw)
-		held := Have{Module: "db", FP: fp1, Composed: dig1, Phase: string(delivery.PhaseHeld), Detail: row.detail}
+		held := Have{Module: "db", FP: fp1, Composed: dig1, Phase: string(nodeengineclient.PhaseHeld), Detail: row.detail}
 		if row.namesNothing {
 			held.FP, held.Composed = "", ""
 		}
@@ -800,7 +802,7 @@ func TestADataModuleIsBackedUpFirstAndHeldWhenItFails(t *testing.T) {
 				return raw
 			}
 			r.wants.before(wk, selfWant(row.atStart))
-			r.haves.stored = map[string]Have{"nats": {Module: "nats", FP: fp2, Composed: dig, Phase: string(delivery.PhaseHeld),
+			r.haves.stored = map[string]Have{"nats": {Module: "nats", FP: fp2, Composed: dig, Phase: string(nodeengineclient.PhaseHeld),
 				Detail: "the backup failed: sh: exit status 1"}}
 			stopR := r.run()
 			defer stopR()
@@ -831,7 +833,7 @@ func TestADataModuleIsBackedUpFirstAndHeldWhenItFails(t *testing.T) {
 			eventually(t, "the answer was not acted on", func() bool { return len(r.appliedList()) == 1 })
 			eventually(t, "not running after the answer", func() bool {
 				h := r.haves.last("nats")
-				return h.Phase == string(delivery.PhaseRunning) && h.Composed == dig
+				return h.Phase == string(nodeengineclient.PhaseRunning) && h.Composed == dig
 			})
 			r.mu.Lock()
 			n := len(r.backups)
@@ -959,9 +961,9 @@ func TestEverythingIsWhatTheAgentRunsAndWhatIsKeptForTheRest(t *testing.T) {
 	if got := a.Everything(); len(got) != 2 {
 		t.Fatalf("before the agent holds anything: %d compositions, want the 2 kept", len(got))
 	}
-	a.running["web"] = delivery.Have{FP: fpOf("a"), Composed: "sha256:" + strings.Repeat("1", 64), Phase: delivery.PhaseRunning}
+	a.running["web"] = nodeengine.HaveByNodeModuleValue{Fp: fpOf("a"), Composed: "sha256:" + strings.Repeat("1", 64), Phase: nodeengineclient.PhaseRunning}
 	ck, craw, dig := composition(t, "web", fpOf("a"), false, file("web", "x", "new"))
-	a.running["web"] = delivery.Have{FP: fpOf("a"), Composed: dig, Phase: delivery.PhaseRunning}
+	a.running["web"] = nodeengine.HaveByNodeModuleValue{Fp: fpOf("a"), Composed: dig, Phase: nodeengineclient.PhaseRunning}
 	a.takeComposition(Update{Key: ck, Value: craw, Revision: 1})
 	got := a.Everything()
 	if len(got) != 2 {
@@ -998,7 +1000,7 @@ func TestEverythingIsWhatTheAgentRunsAndWhatIsKeptForTheRest(t *testing.T) {
 		webDig, _ := compositions.DigestOf(web)
 		store.kept[NodeModule], store.kept["web"] = ownRaw, webRaw
 		b.haves.Write(context.Background(), Have{Module: NodeModule, Composed: ownDig})
-		b.haves.Write(context.Background(), Have{Module: "web", FP: fpOf("a"), Composed: webDig, Phase: string(delivery.PhaseRunning)})
+		b.haves.Write(context.Background(), Have{Module: "web", FP: fpOf("a"), Composed: webDig, Phase: string(nodeengineclient.PhaseRunning)})
 		// The composer's first pass reads what runs when its watch begins, before the agent reads any have.
 		firstCh := make(chan []compositions.Composed, 1)
 		comps := b.comps
@@ -1143,7 +1145,7 @@ func TestAFailedApplyIsAppliedAgainAfterARestartWhateverIsKept(t *testing.T) {
 	b.comps.before(ck, craw)
 	b.wants.before(wk, wraw)
 	b.kept = map[string][]json.RawMessage{"web": {file("web", "x", "1")}}
-	b.haves.stored = map[string]Have{"web": {Module: "web", FP: fp, Composed: dig, Phase: string(delivery.PhaseFailed)}}
+	b.haves.stored = map[string]Have{"web": {Module: "web", FP: fp, Composed: dig, Phase: string(nodeengineclient.PhaseFailed)}}
 	stop := b.run()
 	defer stop()
 	eventually(t, "a failed apply was marked running from the kept declaration", func() bool { return len(b.appliedList()) == 1 })
@@ -1425,7 +1427,7 @@ func TestWhatRunsBeforeTheAgentTakesAModuleNamesItsFilledPaths(t *testing.T) {
 		{name: "a have naming the bucket's value", have: &Have{Module: "power", FP: fp, Composed: appliedDig},
 			bucket: appliedRaw, filled: old + "," + added, told: "the haves were read at the start", data: true},
 		{name: "a have applying names nothing that runs yet", have: &Have{Module: "power", FP: fp, Composed: appliedDig,
-			Phase: string(delivery.PhaseApplying)}, bucket: appliedRaw, filled: old, told: "the haves were read at the start"},
+			Phase: string(nodeengineclient.PhaseApplying)}, bucket: appliedRaw, filled: old, told: "the haves were read at the start"},
 		{name: "a data module from the kept declaration says Data as its manifest does", filled: old,
 			told: "the haves were read at the start", data: true,
 			holdsData: func(context.Context, string) (bool, bool) { return true, true }},
@@ -1583,7 +1585,7 @@ func TestTheNodesOwnCompositionIsAppliedWhenItDiffersAndARecordMoveWaitsForAYes(
 	// names what runs; composed again, the have is what it runs. web was applied by this agent; idle was not since the
 	// agent's start (the switch and every delivery of the node-engine restart it), so what runs is what its have said.
 	idleFP, idleDig := fpOf("c"), "sha256:"+strings.Repeat("9", 64)
-	b.haves.Write(context.Background(), Have{Module: "idle", FP: idleFP, Composed: idleDig, Phase: string(delivery.PhaseRunning),
+	b.haves.Write(context.Background(), Have{Module: "idle", FP: idleFP, Composed: idleDig, Phase: string(nodeengineclient.PhaseRunning),
 		Sealed: compositions.Seals{"idle.key#sealed": `{"box":"idle"}`}})
 	want("idle", idleFP, "")
 	eventually(t, "idle's want was not taken", func() bool {
@@ -1599,7 +1601,7 @@ func TestTheNodesOwnCompositionIsAppliedWhenItDiffersAndARecordMoveWaitsForAYes(
 		module, fp, composed, slot, sealed string
 	}{{"web", fp, dig, "web.pw#sealed", "1"}, {"idle", idleFP, idleDig, "idle.key#sealed", `{"box":"idle"}`}} {
 		h := b.haves.last(row.module)
-		if h.Phase != string(delivery.PhaseFailed) || h.FP != row.fp || h.Composed != row.composed ||
+		if h.Phase != string(nodeengineclient.PhaseFailed) || h.FP != row.fp || h.Composed != row.composed ||
 			len(h.Sealed) != 1 || h.Sealed[row.slot] != row.sealed || !strings.Contains(h.Detail, "web's password") {
 			t.Errorf("%s's have while the node cannot compose: %+v", row.module, h)
 		}
@@ -1614,7 +1616,7 @@ func TestTheNodesOwnCompositionIsAppliedWhenItDiffersAndARecordMoveWaitsForAYes(
 	want("fresh", fpOf("e"), "") // never ran, its have absent: marked, naming nothing it runs
 	// A have that already says another cause keeps it (review of the switch, round 1): an apply that failed.
 	brokenFP, brokenDig := fpOf("f"), "sha256:"+strings.Repeat("8", 64)
-	b.haves.Write(context.Background(), Have{Module: "broken", FP: brokenFP, Composed: brokenDig, Phase: string(delivery.PhaseFailed),
+	b.haves.Write(context.Background(), Have{Module: "broken", FP: brokenFP, Composed: brokenDig, Phase: string(nodeengineclient.PhaseFailed),
 		Detail: "apply: unit failed to start"})
 	want("broken", brokenFP, "")
 	eventually(t, "unread's want was not taken", func() bool {
@@ -1626,7 +1628,7 @@ func TestTheNodesOwnCompositionIsAppliedWhenItDiffersAndARecordMoveWaitsForAYes(
 	if h := b.haves.last("unread"); h.Module != "" {
 		t.Errorf("a module whose have could not be read was marked: %+v", h)
 	}
-	if h := b.haves.last("fresh"); h.Phase != string(delivery.PhaseFailed) || h.FP != "" {
+	if h := b.haves.last("fresh"); h.Phase != string(nodeengineclient.PhaseFailed) || h.FP != "" {
 		t.Errorf("a module that never ran, its have absent, is not marked: %+v", h)
 	}
 	if h := b.haves.last("broken"); h.Detail != "apply: unit failed to start" || h.Composed != brokenDig {
@@ -1642,7 +1644,7 @@ func TestTheNodesOwnCompositionIsAppliedWhenItDiffersAndARecordMoveWaitsForAYes(
 	}
 	b.ag.NotComposed(context.Background(), "")
 	for _, row := range []struct{ module, composed string }{{"web", dig}, {"idle", idleDig}} {
-		if h := b.haves.last(row.module); h.Phase != string(delivery.PhaseRunning) || h.Composed != row.composed || len(h.Sealed) != 1 {
+		if h := b.haves.last(row.module); h.Phase != string(nodeengineclient.PhaseRunning) || h.Composed != row.composed || len(h.Sealed) != 1 {
 			t.Errorf("%s's have once the node composes again: %+v", row.module, h)
 		}
 	}
@@ -1650,14 +1652,14 @@ func TestTheNodesOwnCompositionIsAppliedWhenItDiffersAndARecordMoveWaitsForAYes(
 	// novox) is marked alone, naming its own words; web, which composes, keeps running, unmarked. Composed again, idle's
 	// have is what it runs.
 	b.ag.NotComposedEach(context.Background(), "", map[string]string{"idle": "idle says ${config:name}, and nothing sets it"})
-	if h := b.haves.last("idle"); h.Phase != string(delivery.PhaseFailed) || h.Composed != idleDig || !strings.Contains(h.Detail, "${config:name}") {
+	if h := b.haves.last("idle"); h.Phase != string(nodeengineclient.PhaseFailed) || h.Composed != idleDig || !strings.Contains(h.Detail, "${config:name}") {
 		t.Errorf("idle's have while it alone is held: %+v", h)
 	}
-	if h := b.haves.last("web"); h.Phase != string(delivery.PhaseRunning) || h.Composed != dig {
+	if h := b.haves.last("web"); h.Phase != string(nodeengineclient.PhaseRunning) || h.Composed != dig {
 		t.Errorf("web, which composes, is marked beside idle: %+v", h)
 	}
 	b.ag.NotComposedEach(context.Background(), "", nil)
-	if h := b.haves.last("idle"); h.Phase != string(delivery.PhaseRunning) || h.Composed != idleDig {
+	if h := b.haves.last("idle"); h.Phase != string(nodeengineclient.PhaseRunning) || h.Composed != idleDig {
 		t.Errorf("idle's have once it composes again: %+v", h)
 	}
 	// A revision at the same build (a config value changed) is applied.
@@ -1682,7 +1684,7 @@ func TestTheNodesOwnCompositionIsAppliedWhenItDiffersAndARecordMoveWaitsForAYes(
 	b.comps.put(dk, drawMoved)
 	eventually(t, "db's revision did not wait for a yes", func() bool {
 		h := b.haves.last("db")
-		return h.Phase == string(delivery.PhaseWaitingYes) && h.Waits == ddigMoved
+		return h.Phase == string(nodeengineclient.PhaseWaitingYes) && h.Waits == ddigMoved
 	})
 	if h := b.haves.last("db"); h.BuildAlone {
 		t.Errorf("a revision at the build it runs is said to change the build alone: %+v", h)
@@ -1692,8 +1694,8 @@ func TestTheNodesOwnCompositionIsAppliedWhenItDiffersAndARecordMoveWaitsForAYes(
 	keep(dk, draw)
 	keep(dk, drawMoved)
 	view, err := b.ag.Composition(context.Background(), "db", "", true)
-	if err != nil || view.Have == nil || view.Have.Phase != string(delivery.PhaseWaitingYes) || view.Composition.Digest != ddigMoved ||
-		view.Runs == nil || view.Runs.Composed != ddig || view.Judged.Judgement != string(delivery.JudgedRecreates) ||
+	if err != nil || view.Have == nil || view.Have.Phase != string(nodeengineclient.PhaseWaitingYes) || view.Composition.Digest != ddigMoved ||
+		view.Runs == nil || view.Runs.Composed != ddig || view.Judged.Judgement != string(nodeengineclient.JudgedRecreates) ||
 		!view.Judged.WaitsForYes || len(view.Diff) != 1 || view.Diff[0].ID != "db.server" || view.Diff[0].Change != "changed" ||
 		len(view.Revisions) != 2 {
 		t.Errorf("the composition of db waiting for a yes reads %+v (%v)", view, err)
@@ -1731,7 +1733,7 @@ func TestTheNodesOwnCompositionIsAppliedWhenItDiffersAndARecordMoveWaitsForAYes(
 	b.comps.put(dk, draw)
 	eventually(t, "db's have stays waiting-yes after its composition went back to what runs", func() bool {
 		h := b.haves.last("db")
-		return h.Phase == string(delivery.PhaseRunning) && h.Composed == ddig && h.Waits == ""
+		return h.Phase == string(nodeengineclient.PhaseRunning) && h.Composed == ddig && h.Waits == ""
 	})
 	if got := len(b.appliedList()); got != 4 {
 		t.Fatalf("a composition equal to what runs was applied again: %d applies", got)
@@ -1742,7 +1744,7 @@ func TestTheNodesOwnCompositionIsAppliedWhenItDiffersAndARecordMoveWaitsForAYes(
 	// node-engine restart it): its have alone says what runs. Its move waits for a yes as db's does, and its have keeps
 	// what runs (fingerprint, digest, sealed values) rather than naming nothing (review of L2, round 3).
 	recFP, recDig := fpOf("d"), "sha256:"+strings.Repeat("8", 64)
-	b.haves.Write(context.Background(), Have{Module: "rec", FP: recFP, Composed: recDig, Phase: string(delivery.PhaseRunning),
+	b.haves.Write(context.Background(), Have{Module: "rec", FP: recFP, Composed: recDig, Phase: string(nodeengineclient.PhaseRunning),
 		Sealed: compositions.Seals{"rec.key#sealed": `{"box":"rec"}`}})
 	rk, rraw, rdig := unsigned("rec", fpB, container("rec@sha256:"+strings.Repeat("3", 64)))
 	b.comps.put(dk2, draw2)
@@ -1757,7 +1759,7 @@ func TestTheNodesOwnCompositionIsAppliedWhenItDiffersAndARecordMoveWaitsForAYes(
 	}{{"db", fp, "", ddig2, nil, false}, {"rec", recFP, recDig, rdig, compositions.Seals{"rec.key#sealed": `{"box":"rec"}`}, true}} {
 		eventually(t, row.module+"'s move did not wait for a yes", func() bool {
 			h := b.haves.last(row.module)
-			return h.Phase == string(delivery.PhaseWaitingYes) && h.Waits == row.waits
+			return h.Phase == string(nodeengineclient.PhaseWaitingYes) && h.Waits == row.waits
 		})
 		h := b.haves.last(row.module)
 		if h.FP != row.fp || (row.composed != "" && h.Composed != row.composed) || h.Composed == "" ||
@@ -1775,8 +1777,8 @@ func TestTheNodesOwnCompositionIsAppliedWhenItDiffersAndARecordMoveWaitsForAYes(
 	want("rec", fpB, rdig)
 	eventually(t, "the yes did not apply the move", func() bool {
 		h, r := b.haves.last("db"), b.haves.last("rec")
-		return len(b.appliedList()) == applied+2 && h.Phase == string(delivery.PhaseRunning) && h.FP == fpB &&
-			r.Phase == string(delivery.PhaseRunning) && r.FP == fpB && r.Composed == rdig
+		return len(b.appliedList()) == applied+2 && h.Phase == string(nodeengineclient.PhaseRunning) && h.FP == fpB &&
+			r.Phase == string(nodeengineclient.PhaseRunning) && r.FP == fpB && r.Composed == rdig
 	})
 }

@@ -1816,7 +1818,7 @@ func testAnEngineStartReconcilesAModuleFromTheMachinesFacts(t *testing.T) {
 			}
 			if c.held {
 				b.haves.stored = map[string]Have{"web": {Module: "web", FP: fpOf("0"), Composed: "sha256:" + strings.Repeat("0", 64),
-					Phase: string(delivery.PhaseHeld), Detail: "restic: the repository is locked"}}
+					Phase: string(nodeengineclient.PhaseHeld), Detail: "restic: the repository is locked"}}
 			}
 			if c.kept {
 				b.kept = map[string][]json.RawMessage{"web": rs}
@@ -1867,7 +1869,7 @@ func testReconcileAppliesARunningModuleAgainAndLeavesTheHeldAndTheUnwantedAlone(
 	stop := b.run()
 	defer stop()
 	eventually(t, "web was not settled", func() bool { return b.haves.last("web").Composed == digW })
-	eventually(t, "db was not held", func() bool { return b.haves.last("db").Phase == string(delivery.PhaseHeld) })
+	eventually(t, "db was not held", func() bool { return b.haves.last("db").Phase == string(nodeengineclient.PhaseHeld) })
 	if got := b.appliedList(); len(got) != 0 {
 		t.Fatalf("applied at the start: %v", got)
 	}
@@ -1882,13 +1884,13 @@ func testReconcileAppliesARunningModuleAgainAndLeavesTheHeldAndTheUnwantedAlone(
 	if got := b.appliedList(); len(got) != 0 {
 		t.Fatalf("a held module and an unwanted one were applied: %v", got)
 	}
-	if h := b.haves.last("db"); h.Phase != string(delivery.PhaseHeld) {
+	if h := b.haves.last("db"); h.Phase != string(nodeengineclient.PhaseHeld) {
 		t.Fatalf("the held module's have changed: %+v", h)
 	}

 	b.ag.Reconcile("web")
 	eventually(t, "web was not applied again", func() bool { return len(b.appliedList()) == 1 })
-	eventually(t, "web is not running again", func() bool { return b.haves.last("web").Phase == string(delivery.PhaseRunning) })
+	eventually(t, "web is not running again", func() bool { return b.haves.last("web").Phase == string(nodeengineclient.PhaseRunning) })

 	b.mu.Lock()
 	b.failWith = "systemctl start web.service: exit status 1"
@@ -1896,7 +1898,7 @@ func testReconcileAppliesARunningModuleAgainAndLeavesTheHeldAndTheUnwantedAlone(
 	b.ag.Reconcile("web")
 	eventually(t, "the failed re-apply did not write the have failed with its words", func() bool {
 		h := b.haves.last("web")
-		return h.Phase == string(delivery.PhaseFailed) && h.Detail == "systemctl start web.service: exit status 1"
+		return h.Phase == string(nodeengineclient.PhaseFailed) && h.Detail == "systemctl start web.service: exit status 1"
 	})
 	time.Sleep(50 * time.Millisecond)
 	if got := b.appliedList(); len(got) != 2 {