Read what a node was sent from its assignment keys; a pulled-in module keeps a standing key; a hand send is a time (issue 1109)

SentBuilds answers from the keys of the node's assignments that name a commit, known when the node was sent anything and no key says its commit unknown. A send that names its builds writes the commit, build and rollout on each carried module's key (a module nothing assigns gets a standing key marked pulled-in, never a state) and clears what every other key of the node named; a send by hand writes sent-unknown, a time, on every key and clears their commits. A failed write of these fails the record of the send. node.sent_builds is no longer written. The plan pass ends a pulled-in key only when no send carries it.

internal/chain/pending_test.go

@@ -61,3 +61,27 @@ func TestTheTransitionsOfAPendingAssignment(t *testing.T) {
 		t.Error("a claim moves a wait to applying and back")
 	}
 }
+
+// **A module only pulled in is a standing value marked pulled-in, never a state, and a hand send makes a key say its commit
+// unknown with a time** (issue 1109): every reader treats a non-empty state as no assignment, so a pulled-in key must have
+// none; and unknown is never written in `commit`.
+func TestAPulledInValueStandsAndAHandSendIsATimeNotACommit(t *testing.T) {
+	at := time.Date(2026, 10, 18, 3, 0, 0, 0, time.UTC)
+	pulled := Assignment{Node: "anchor", Module: "mesh-wireguard", PulledIn: true, Commit: "c1", Build: "b1", Since: at}
+	if !pulled.Stands() || pulled.State != "" {
+		t.Fatalf("a pulled-in value does not stand: %+v", pulled)
+	}
+	raw, _ := json.Marshal(pulled)
+	if !strings.Contains(string(raw), `"pulled-in":true`) || strings.Contains(string(raw), `"state"`) || strings.Contains(string(raw), `"assigned"`) {
+		t.Fatalf("the pulled-in value is %s", raw)
+	}
+	unknown := Assignment{Node: "anchor", Module: "notes", Assigned: at, SentUnknown: at}
+	raw, _ = json.Marshal(unknown)
+	if !strings.Contains(string(raw), `"sent-unknown":"2026-10-18T03:00:00Z"`) || strings.Contains(string(raw), `"commit"`) || !unknown.Stands() {
+		t.Fatalf("the hand-sent value is %s", raw)
+	}
+	plain, _ := json.Marshal(Assignment{Node: "anchor", Module: "notes", Assigned: at})
+	if strings.Contains(string(plain), "pulled-in") || strings.Contains(string(plain), "sent-unknown") {
+		t.Fatalf("a value that is neither says so: %s", plain)
+	}
+}

internal/chain/records.go

@@ -196,6 +196,14 @@ type Assignment struct {
 	// Pending is the assignment's wait for its build (novox/hq ADR 0261), kept in the value of the key it waits for and, when
 	// it is made, carried into the value that stands: the record of what became of the wait.
 	Pending *Pending `json:"pending,omitempty"`
+
+	// PulledIn marks a standing value of a module that is on the machine only because another requires it, or because a
+	// send carried it: no time assigned, but a key all the same, so what the machine was sent of it is kept and read
+	// (issue 1109). Never a state: every reader treats a non-empty state as no assignment, and would take it off the machine.
+	PulledIn bool `json:"pulled-in,omitempty"`
+	// SentUnknown is when a send by hand made what the machine runs unknown (a declaration sent with no builds known): the
+	// commit is cleared with it. Absent normally; a send that names its builds clears it.
+	SentUnknown time.Time `json:"sent-unknown,omitzero"`
 }
 
 // StatePending is the State of a value that holds no assignment but a pending one.