Drop artifact-store-tools' controller client; the provisioner client reads placement

The controller is not placed and its assignments mirror is frozen (ADR
0590). artifact-store-tools already answers through the seat's holder, so
its controller client goes. mesh-provisioner-client reads the seat
mesh-placement's placement, which its account is granted whole: a module
placed here stays while the seat holds no plan of it, filled from its last
plan, and leaves only when neither names it (issue 1126 B12).

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

modules/artifact-store-tools/cmd/artifact-store-tools/definitions_test.go

@@ -153,7 +153,7 @@ func TestOlderNamesNotReadAreSaidFirst(t *testing.T) {
 func references(t *testing.T, a *asked) func(map[string]any) (any, error) {
 	f := world()
 	s := &Store{Container: "mesh-registry", Run: f.run(t)}
-	for _, tl := range Tools(s, Controller{Ask: a.ask}, &Catalogue{Ask: a.ask}) {
+	for _, tl := range Tools(s, recordsAsked{a}, &Catalogue{Ask: a.ask}) {
 		if tl.Name == "artifact_store_references" {
 			return tl.Run
 		}

modules/artifact-store-tools/cmd/artifact-store-tools/records.go

@@ -2,22 +2,16 @@ package main
 
 import (
 	"encoding/json"
-	"errors"
-	"fmt"
-	"strconv"
 	"strings"
 )
 
-// What the records say, asked of the controller and never copied (novox/hq ADR 0251 §2). The
-// controller decides what the mesh keeps; this bundle only sets that beside what the store holds.
+// What the records say, in the shape the seat's holder answers them (Holder; novox/hq ADR 0251 §2, ADR 0571 clause 2):
+// the holder decides what the mesh keeps; the tools only set that beside what the store holds.
 
 // Asking is how a tool on the mesh is asked: stdio.Ask, or a test's.
 type Asking func(key string, body any) (json.RawMessage, error)
 
-// ControllerSeat is the seat whose verbs the controller serves.
-const ControllerSeat = "mesh-controller"
-
-// Record is one reference the mesh recorded making, as the controller's `artifacts` answers it.
+// Record is one reference the mesh recorded making, as the seat's `artifacts` answers it.
 type Record struct {
 	Reference  string   `json:"reference"`
 	Repository string   `json:"repository,omitempty"`
@@ -27,7 +21,7 @@ type Record struct {
 	Why        []string `json:"why,omitempty"`
 }
 
-// Records is the controller's `artifacts` answer.
+// Records is the seat's `artifacts` answer.
 type Records struct {
 	Store      string         `json:"store"`
 	KeptBuilds int            `json:"kept_builds"`
@@ -39,7 +33,7 @@ type Records struct {
 	Note string `json:"-"`
 }
 
-// CollectAnswer is the controller's `collect` answer.
+// CollectAnswer is the seat's `collect` answer.
 type CollectAnswer struct {
 	DryRun         bool     `json:"dry_run"`
 	Store          string   `json:"store"`
@@ -53,15 +47,12 @@ type CollectAnswer struct {
 	Skipped        int      `json:"skipped"`
 	Left           int      `json:"left"`
 	Stopped        string   `json:"stopped"`
-	// Rest is whatever else the controller said, passed on as it said it.
+	// Rest is whatever else the sweep said, passed on as it said it.
 	Rest map[string]json.RawMessage `json:"-"`
 }
 
-// Controller asks the controller's seat through the runtime.
-type Controller struct{ Ask Asking }
-
-// answerOf reads a verb's answer whatever wraps it: the controller's {output, ok, answer}, a text the
-// runtime handed over, or the protocol's content list.
+// answerOf reads a verb's answer whatever wraps it: {output, ok, answer}, a text the runtime handed over, or the
+// protocol's content list.
 func answerOf(raw json.RawMessage) (json.RawMessage, string, bool) {
 	var s string
 	if json.Unmarshal(raw, &s) == nil {
@@ -95,89 +86,11 @@ func answerOf(raw json.RawMessage) (json.RawMessage, string, bool) {
 	return raw, string(raw), true
 }
 
-func (c Controller) verb(name string, args map[string]any) (json.RawMessage, error) {
-	if c.Ask == nil {
-		return nil, errors.New("this bundle has no way to ask the controller")
-	}
-	raw, err := c.Ask("seat:"+ControllerSeat+"."+name, args)
-	if err != nil {
-		return nil, fmt.Errorf("the controller's %s could not be asked: %w", name, err)
-	}
-	answer, output, ok := answerOf(raw)
-	if !ok {
-		return nil, fmt.Errorf("the controller refused %s: %s", name, lastLine(output))
-	}
-	if len(answer) == 0 || string(answer) == "null" {
-		return nil, fmt.Errorf("the controller's %s answered no data: %s", name, lastLine(output))
-	}
-	return answer, nil
-}
-
 func lastLine(s string) string {
 	lines := strings.Split(strings.TrimSpace(s), "\n")
 	return strings.TrimSpace(lines[len(lines)-1])
 }
 
-// Artifacts asks what the records say, with the references already let go of when the answer can carry
-// them; when it cannot, without, and says so.
-func (c Controller) Artifacts(repository string) (*Records, error) {
-	args := map[string]any{"collected": "true"}
-	if repository != "" {
-		args["repository"] = repository
-	}
-	raw, err := c.verb("artifacts", args)
-	collected := true
-	note := ""
-	if err != nil {
-		delete(args, "collected")
-		var again error
-		raw, again = c.verb("artifacts", args)
-		if again != nil {
-			return nil, again
-		}
-		collected = false
-		note = "the references the mesh already let go of could not be asked for (" + err.Error() +
-			"), so a manifest the mesh let go of that the store still holds is counted as unrecorded"
-	}
-	var r Records
-	if err := json.Unmarshal(raw, &r); err != nil {
-		return nil, fmt.Errorf("the controller's artifacts answer is not readable: %v", err)
-	}
-	for i := range r.References {
-		fill(&r.References[i])
-	}
-	r.CollectedAsked, r.Note = collected, note
-	return &r, nil
-}
-
-// Collect asks the controller's sweep: a dry run unless confirm, which needs why.
-func (c Controller) Collect(why string, confirm bool, most int) (*CollectAnswer, error) {
-	args := map[string]any{}
-	if confirm {
-		if strings.TrimSpace(why) == "" {
-			return nil, errors.New("a real collection needs why: nothing was asked")
-		}
-		args["why"] = why
-		args["confirm"] = "true"
-	}
-	if most > 0 {
-		args["most"] = strconv.Itoa(most)
-	}
-	raw, err := c.verb("collect", args)
-	if err != nil {
-		return nil, err
-	}
-	var a CollectAnswer
-	if err := json.Unmarshal(raw, &a); err != nil {
-		return nil, fmt.Errorf("the controller's collect answer is not readable: %v", err)
-	}
-	_ = json.Unmarshal(raw, &a.Rest)
-	if !confirm && !a.DryRun && len(a.LetGo) > 0 {
-		return nil, fmt.Errorf("the controller let go of %d artifacts when only a dry run was asked", len(a.LetGo))
-	}
-	return &a, nil
-}
-
 // fill reads the repository, digest and kind out of a reference when the answer left them out.
 func fill(r *Record) {
 	repo, digest, kind := splitReference(r.Reference)

modules/artifact-store-tools/cmd/artifact-store-tools/store_test.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"reflect"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"testing"
@@ -280,7 +281,7 @@ func TestOnlyTheirBytesLeaveOutWhatAnotherStateMarks(t *testing.T) {
 	}
 }
 
-// asked records every ask, and answers as the controller would.
+// asked records every ask, and answers as the seat and the catalogue would.
 type asked struct {
 	mu    sync.Mutex
 	calls []string
@@ -293,6 +294,51 @@ type asked struct {
 	noCatalogue bool
 }
 
+// recordsAsked is the tools' Recorded in a test: each call asked of asked, as `artifacts` or `collect`, with the
+// arguments a real run gives the seat's sweep.
+type recordsAsked struct{ a *asked }
+
+func (r recordsAsked) Artifacts(repository string) (*Records, error) {
+	args := map[string]any{"collected": "true"}
+	if repository != "" {
+		args["repository"] = repository
+	}
+	raw, err := r.a.ask("artifacts", args)
+	if err != nil {
+		return nil, err
+	}
+	var recs Records
+	answer, _, _ := answerOf(raw)
+	if err := json.Unmarshal(answer, &recs); err != nil {
+		return nil, err
+	}
+	for i := range recs.References {
+		fill(&recs.References[i])
+	}
+	recs.CollectedAsked = true
+	return &recs, nil
+}
+
+func (r recordsAsked) Collect(why string, confirm bool, most int) (*CollectAnswer, error) {
+	args := map[string]any{}
+	if confirm {
+		if strings.TrimSpace(why) == "" {
+			return nil, fmt.Errorf("a real collection needs why: nothing was asked")
+		}
+		args["why"], args["confirm"] = why, "true"
+	}
+	if most > 0 {
+		args["most"] = strconv.Itoa(most)
+	}
+	raw, err := r.a.ask("collect", args)
+	if err != nil {
+		return nil, err
+	}
+	var c CollectAnswer
+	answer, _, _ := answerOf(raw)
+	return &c, json.Unmarshal(answer, &c)
+}
+
 func (a *asked) ask(key string, body any) (json.RawMessage, error) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
@@ -304,7 +350,7 @@ func (a *asked) ask(key string, body any) (json.RawMessage, error) {
 	}
 	var answer any
 	switch key {
-	case "seat:mesh-controller.artifacts":
+	case "artifacts":
 		answer = records()
 	case CatalogueModules:
 		if a.noCatalogue {
@@ -331,7 +377,7 @@ func (a *asked) ask(key string, body any) (json.RawMessage, error) {
 		// The catalogue's tool answers through the runtime as the protocol's content list.
 		raw, _ := json.Marshal(map[string]any{"module": map[string]any{"module": name, "manifest": json.RawMessage(manifest)}})
 		return json.Marshal(map[string]any{"content": []map[string]any{{"type": "text", "text": string(raw)}}})
-	case "seat:mesh-controller.collect":
+	case "collect":
 		if args["confirm"] == "true" {
 			answer = CollectAnswer{LetGo: []string{"artifact-store://app/server@" + d("m-old")}}
 		} else {
@@ -347,7 +393,7 @@ func (a *asked) ask(key string, body any) (json.RawMessage, error) {
 func tool(t *testing.T, a *asked, name string) func(map[string]any) (any, error) {
 	f := world()
 	s := &Store{Container: "mesh-registry", Run: f.run(t)}
-	for _, tl := range Tools(s, Controller{Ask: a.ask}, &Catalogue{Ask: a.ask}) {
+	for _, tl := range Tools(s, recordsAsked{a}, &Catalogue{Ask: a.ask}) {
 		if tl.Name == name {
 			return tl.Run
 		}
@@ -390,21 +436,6 @@ func TestARealRunWithoutWhyIsRefusedAndAsksNothing(t *testing.T) {
 	}
 }
 
-func TestReferencesFallBackWhenCollectedCannotBeCarried(t *testing.T) {
-	a := &asked{fail: map[string]bool{"collected": true}}
-	out, err := tool(t, a, "artifact_store_references")(map[string]any{"repository": "app/server"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	m := out.(map[string]any)
-	if m["note"] == nil || m["manifests"] == nil {
-		t.Errorf("answer %v", m)
-	}
-	if _, err := tool(t, a, "artifact_store_references")(map[string]any{"repository": "nope"}); err == nil {
-		t.Error("an unknown repository was answered")
-	}
-}
-
 func TestTheToolsServedAreTheToolsTheManifestNames(t *testing.T) {
 	raw, err := os.ReadFile("../../module.json")
 	if err != nil {
@@ -423,7 +454,7 @@ func TestTheToolsServedAreTheToolsTheManifestNames(t *testing.T) {
 		t.Fatal(err)
 	}
 	var served []string
-	for _, tl := range Tools(&Store{}, Controller{}, &Catalogue{}) {
+	for _, tl := range Tools(&Store{}, recordsAsked{&asked{}}, &Catalogue{}) {
 		if !strings.HasPrefix(tl.Name, "artifact_store_") || tl.Description == "" || tl.Run == nil {
 			t.Errorf("tool %q", tl.Name)
 		}

modules/artifact-store-tools/cmd/artifact-store-tools/tools.go

@@ -12,7 +12,7 @@ import (
 )
 
 // Recorded is what says which references the mesh keeps and lets go of them: the seat's holder (Holder, novox/hq ADR
-// 0571 clause 2), or before it the controller (Controller), each in the controller's answer's shape.
+// 0571 clause 2), or a test's stand-in.
 type Recorded interface {
 	Artifacts(repository string) (*Records, error)
 	Collect(why string, confirm bool, most int) (*CollectAnswer, error)