Keep the node's own composition's sealed values in its key and read a policy within the agent's context, so a restart applies nothing again (issue 1126)

internal/selfcompose/selfcompose.go

@@ -453,11 +453,10 @@ func (c *Composer) runningBox(box string) string {
 	}
 	if c.env.Held != nil {
 		c.mu.Lock()
+		// The node's own key among them (agent.NodeModule): its core boxes, as its last run said them.
 		modules := make([]string, 0, len(c.wants))
 		for m := range c.wants {
-			if m != agent.NodeModule {
-				modules = append(modules, m)
-			}
+			modules = append(modules, m)
 		}
 		c.mu.Unlock()
 		sort.Strings(modules)
@@ -514,15 +513,16 @@ func (c *Composer) builtManifest(ctx context.Context, module, fp string) (string
 }
 
 // Policy is a module's upgrade policy as its manifest at the indexer's trunk derives it (catalogue.DerivedUpgrade), for
-// the agent's judgement of a move (ADR 0547 §3); empty when the manifest is not known or cannot be read.
-func (c *Composer) Policy(module string) string {
+// the agent's judgement of a move (ADR 0547 §3); empty when the manifest is not known or cannot be read. The manifest is
+// read within ctx, the agent's (review of L2, round 1, finding 5), so a stopping agent stops the read.
+func (c *Composer) Policy(ctx context.Context, module string) string {
 	c.mu.Lock()
 	m, ok := c.modules[module]
 	c.mu.Unlock()
 	if !ok || m.Manifest == "" {
 		return ""
 	}
-	raw, err := reader{c: c}.Manifest(context.Background(), m.Manifest)
+	raw, err := reader{c: c}.Manifest(ctx, m.Manifest)
 	if err != nil {
 		return ""
 	}

internal/selfcompose/selfcompose_test.go

@@ -237,14 +237,18 @@ func TestTheNodeComposesItsWantsFromTheBus(t *testing.T) {
 		}
 		return sealed[0]
 	}
+	// And the node's own key (review of L2, round 3, finding 1): a core box its own composition carries is held there, and
+	// kept after a restart as a module's is, so the node's own composition does not move either.
 	for _, row := range []struct {
-		name, held string
-		kept       bool
-	}{{"the have holds the rotated value", boxOf(string(rotated.Value)), true}, {"the have holds the value before the rotation", boxOf(before), false}} {
+		name, held, in string
+		kept           bool
+	}{{"the have holds the rotated value", boxOf(string(rotated.Value)), "keeper", true},
+		{"the have holds the value before the rotation", boxOf(before), "keeper", false},
+		{"the node's own key holds the rotated value", boxOf(string(rotated.Value)), agent.NodeModule, true}} {
 		restarted := env
 		restarted.Running = func() []delivery.Composed { return nil }
 		restarted.Held = func(module string) []string {
-			if module == "keeper" {
+			if module == row.in {
 				return []string{row.held}
 			}
 			return nil
@@ -258,7 +262,7 @@ func TestTheNodeComposesItsWantsFromTheBus(t *testing.T) {
 			return nil, fmt.Errorf("not sealed to n1: %s", box)
 		}
 		again := New(restarted)
-		again.wants = map[string]delivery.Want{"keeper": {FP: fp, Self: true}}
+		again.wants = map[string]delivery.Want{"keeper": {FP: fp, Self: true}, agent.NodeModule: {}}
 		rows, err := reader{c: again}.OwnSecrets(ctx, "n1")
 		if err != nil || len(rows) != 1 {
 			t.Fatalf("%s: own secrets %+v, %v", row.name, rows, err)