Give every module an identity and ask once to keep a shared folder (hq ADR 0325, issue 575)

A module's containers that declare identity run as an identity the controller allocates once, mesh-wide,
from 50000-59999; each access names its users and whether its folder is taken; an access wait is excused
for a folder the mesh may not keep yet, and the operator is asked once per folder and machine, the folder
taken only on the warrant. All of it is sent only to an engine at contract 5. A placement for an access a
newer build brings is judged against that build (issue 575). mesh-host pinned to the ADR 0325 branch head.

internal/link/protocol.go

@@ -8,6 +8,7 @@ package link
 
 import (
 	"encoding/base64"
+	"encoding/json"
 	"github.com/novox/mesh-host/rootsearch"
 	"strconv"
 	"strings"
@@ -436,6 +437,14 @@ const ReadinessContract = 2
 // parses strictly and would refuse the whole declaration for it.
 const RootContract = 3
 
+// IdentityContract is the statement of an engine that gives each module its identity and keeps shared folders
+// (novox/hq ADR 0325; mesh-host internal/link IdentityContract): it reads a declaration's `identities`, a container's
+// resolved `identity`, an access's `users` and `taken`, states an access it may not keep yet as waiting
+// (ResourceHealth.AccessWaits), and hears the take act (AskAccessAct). Only to such an engine is any of it sent: an
+// older one parses strictly and would refuse the whole declaration for it. Four, the grant's number (ADR 0312,
+// superseded), is what engines stated before; the controller sends no grant to any engine (#270).
+const IdentityContract = 5
+
 // ReasonRoot starts the reason of an account verdict that found a way to root (ADR 0266); the node-engine's
 // own words (mesh-host internal/accounts ReasonRoot).
 const ReasonRoot = "can become root without a person"
@@ -580,6 +589,36 @@ type Wait struct {
 	What    string `json:"what"`
 }
 
+// WaitKindAccess is the kind of a wait on an access (novox/hq ADR 0325 §7; mesh-host internal/link).
+const WaitKindAccess = "access"
+
+// AccessWait is one access waiting for the operator (novox/hq ADR 0325 §7): the access by its module's own id for
+// it, the part (its module), and what the operator gives, in words with no path — "let the mesh keep the shared
+// folder movies", or "mount the disk that holds books". Beside Waits because mesh-sdk's health.Wait names a secret or
+// a setting and nothing else. From an engine at IdentityContract or later.
+type AccessWait struct {
+	Kind   string `json:"kind"`
+	Access string `json:"access"`
+	Part   string `json:"part"`
+	What   string `json:"what"`
+}
+
+// WaitsForDisk says an access wait is for a disk that is not there (ADR 0325 §9) rather than for the operator's word
+// to keep a folder: read from the engine's words, the one thing its wait says of which it is.
+func (w AccessWait) WaitsForDisk() bool {
+	return strings.HasPrefix(strings.TrimSpace(w.What), "mount the disk")
+}
+
+// KeptEntry is one user of a kept folder as the engine's listing says it (ADR 0325 §4), with a note beside the tool
+// runner's entry.
+type KeptEntry struct {
+	Identity string `json:"identity"`
+	UID      int    `json:"uid"`
+	Use      string `json:"use"`
+	From     string `json:"from"`
+	Note     string `json:"note,omitempty"`
+}
+
 // ResourceHealth is one long-running resource's state.
 type ResourceHealth struct {
 	Module   string    `json:"module"`
@@ -606,6 +645,11 @@ type ResourceHealth struct {
 	// Waits is what a resource in StateWaiting waits for (novox/hq ADR 0283). Empty otherwise, and from an
 	// engine older than that.
 	Waits []Wait `json:"waits,omitempty"`
+	// AccessWaits is what an access stated waiting waits for (novox/hq ADR 0325 §7); Act the last walk under its
+	// folder, kept as the engine said it; Entries the kept folder's listing. From an engine at IdentityContract only.
+	AccessWaits []AccessWait    `json:"access-waits,omitempty"`
+	Act         json.RawMessage `json:"act,omitempty"`
+	Entries     []KeptEntry     `json:"entries,omitempty"`
 }
 
 // HealthSaid is the health event's body: the machine and its statement. The machine is read from the