Key root-not-free apart from DA, keep ADR 0266's quiet window there, and judge at one clock (hq ADR 0259 §8)

The confirmation review of 2026-10-09 found D-root and DA writing one key, machine.<m>.agent-root, from
two probes with different words, so it flapped every run; D-root is now root-not-free. D-root raised the
urgent condition after every node-engine restart while the first setuid search ran; it now keeps the
same quiet window as DA, and the root-free verb still answers that machine not free. agentConfined
takes the judging clock.

cmd/mesh-controller/probe_agent_root.go

@@ -36,14 +36,17 @@ import (
 // measure is no longer part of this judgement: it ran in the machine's runtime, as the very account an agent
 // could become, so it could not be believed.
 //
-// The one judgement (judgeRoot) is read two ways: the self-check raises `agent-root` on every machine where
+// The one judgement (judgeRoot) is read two ways: the self-check raises `root-not-free` on every machine where
 // the router or a module of its own account runs and the judgement fails; and the `root-free` verb answers it
 // live, to the router, which honours a verified sender only on its pass. A machine holding the operator's
 // graphical session, where a messaging client's desktop app may run, is not judged here: the operator accepted
 // that gap for now (hq issue 344).
 
-// kindAgentRoot is the condition a trusted party's machine that is not root-free raises.
-const kindAgentRoot = "agent-root"
+// kindRootNotFree is the condition a trusted party's machine that is not root-free raises. Its own key, apart
+// from ADR 0266's agent-can-become-root (Token agent-root, from DA): the two judge different things — DA the
+// agent account alone, this the whole of root-free — and one key from two probes flapped between them (the
+// confirmation review of 2026-10-09).
+const kindRootNotFree = "root-not-free"
 
 // routerSeat is the seat the router holds: where it runs counts as a trusted party's machine.
 const routerSeat = "operator-channel"
@@ -92,6 +95,9 @@ type rootFacts struct {
 	// Execute is whether the login shell's execute is served there; ExecuteWhy why, in words.
 	Execute    bool
 	ExecuteWhy string
+	// SearchPending is the agent account unjudged only because the node-engine's first setuid search runs,
+	// within its bound (ADR 0266's quiet window).
+	SearchPending bool
 }
 
 // rootVerdict is the judgement on one machine, as the root-free verb answers it.
@@ -100,6 +106,9 @@ type rootVerdict struct {
 	Free    bool      `json:"free"`
 	Why     string    `json:"why"`
 	Judged  time.Time `json:"judged"`
+	// Quiet is a machine not free only because its first setuid search still runs, within its bound: the
+	// self-check raises nothing for it then (ADR 0266's quiet window). It is never free for it.
+	Quiet bool `json:"quiet,omitempty"`
 }
 
 // judgeRoot is the one judgement: free only when nothing failed to read, an agent account is named and judged
@@ -127,6 +136,8 @@ func judgeRoot(f rootFacts, now time.Time) rootVerdict {
 	}
 	if len(not) > 0 {
 		v.Why = strings.Join(not, "; ")
+		// The one failure is the agent account not judged yet, because its first search runs.
+		v.Quiet = len(not) == 1 && f.SearchPending && f.AgentNamed && !f.Confined && len(f.Unread) == 0 && !f.Execute
 		return v
 	}
 	v.Free = true
@@ -142,7 +153,11 @@ type rootReader struct {
 	heard   map[string]map[string]map[string]bool
 	asked   error
 	// confined is agentConfined; settings the login shell holder's settings on a machine. Replaceable in a test.
-	confined func(ctx context.Context, node string) (named, confined bool, why string, err error)
+	confined func(ctx context.Context, node string, now time.Time) (named, confined bool, why string, err error)
+	// quiet says the one thing keeping a machine's agent account unjudged is the node-engine's first setuid
+	// search, within its bound (ADR 0266, searchStillRunning). Read by the self-check alone, to raise nothing
+	// then; nil reads no quiet. It never makes a machine root-free.
+	quiet    func(ctx context.Context, node string, now time.Time) bool
 	settings func(ctx context.Context, node, module string) ([]catalogue.Layer, error)
 }
 
@@ -154,26 +169,29 @@ func newRootReader(ctx context.Context, inv *inventory.Inventory, conn *nats.Con
 	} else {
 		r.heard, r.asked = discoverSeatVerbs(ctx, conn)
 	}
-	r.confined = func(ctx context.Context, node string) (bool, bool, string, error) {
-		return agentConfined(ctx, inv, node)
+	r.confined = func(ctx context.Context, node string, now time.Time) (bool, bool, string, error) {
+		return agentConfined(ctx, inv, node, now)
 	}
 	r.settings = inv.SettingsFor
 	return r
 }
 
-// facts reads one machine.
-func (r *rootReader) facts(ctx context.Context, machine string) rootFacts {
+// facts reads one machine, at now.
+func (r *rootReader) facts(ctx context.Context, machine string, now time.Time) rootFacts {
 	f := rootFacts{Machine: machine}
 	if r.read != nil {
 		f.Unread = append(f.Unread, "the catalogue's placements could not be read: "+r.read.Error())
 	}
-	named, confined, why, err := r.confined(ctx, machine)
+	named, confined, why, err := r.confined(ctx, machine, now)
 	if err != nil {
 		f.Unread = append(f.Unread, "the account agents run as could not be read: "+err.Error())
 	} else {
 		f.AgentNamed, f.Confined, f.ConfinedWhy = named, confined, why
 	}
 	f.Execute, f.ExecuteWhy = r.executeServed(ctx, machine)
+	if r.quiet != nil && f.AgentNamed && !f.Confined {
+		f.SearchPending = r.quiet(ctx, machine, now)
+	}
 	return f
 }
 
@@ -240,7 +258,7 @@ func claimServes(m catalogue.Manifest, seat, verb string) bool {
 func judgeRootFree(ctx context.Context, r *rootReader, machines []string, now time.Time) []rootVerdict {
 	out := make([]rootVerdict, 0, len(machines))
 	for _, m := range machines {
-		out = append(out, judgeRoot(r.facts(ctx, m), now))
+		out = append(out, judgeRoot(r.facts(ctx, m, now), now))
 	}
 	return out
 }
@@ -263,8 +281,8 @@ func trustedMachines(entries []inventory.Entry) map[string][]string {
 func agentRootObservation(v rootVerdict, trusted []string) conditions.Observation {
 	trusted = append([]string(nil), trusted...)
 	sort.Strings(trusted)
-	return conditions.Observation{Scope: conditions.ScopeMachine, ID: v.Machine, Token: kindAgentRoot,
-		Machine: v.Machine, Kind: kindAgentRoot, Severity: conditions.Urgent,
+	return conditions.Observation{Scope: conditions.ScopeMachine, ID: v.Machine, Token: kindRootNotFree,
+		Machine: v.Machine, Kind: kindRootNotFree, Severity: conditions.Urgent,
 		Summary: fmt.Sprintf("%s is not root-free, where %s run: until it is, the router approves nothing proven "+
 			"there (novox/hq ADR 0259 §8): %s", v.Machine, strings.Join(trusted, ", "), v.Why),
 		Headline: "Phone answers held on " + v.Machine,
@@ -281,10 +299,25 @@ func probeAgentRoot(ctx context.Context, d *doctor) ([]conditions.Observation, e
 	if d.js != nil {
 		conn = d.js.Conn()
 	}
-	r := newRootReader(ctx, d.open.inventory, conn)
+	inv := d.open.inventory
+	r := newRootReader(ctx, inv, conn)
 	if r.read != nil {
 		return nil, r.read
 	}
+	// The self-check alone reads ADR 0266's quiet window: nothing raised while a machine's first setuid search
+	// runs, within its bound. The root-free verb never reads it, so the machine still answers not free.
+	r.quiet = func(ctx context.Context, node string, now time.Time) bool {
+		n, err := inv.NodeByName(ctx, node)
+		if err != nil || n.AgentAccount == "" {
+			return false
+		}
+		h, had, err := inv.HealthOf(ctx, node)
+		if err != nil {
+			return false
+		}
+		quiet, err := searchStillRunning(ctx, inv, node, n.AgentAccount, h, had, now)
+		return err == nil && quiet
+	}
 	return rootObservations(ctx, r, trustedMachines(r.entries), time.Now()), nil
 }
 
@@ -297,7 +330,7 @@ func rootObservations(ctx context.Context, r *rootReader, trusted map[string][]s
 	sort.Strings(machines)
 	var out []conditions.Observation
 	for _, v := range judgeRootFree(ctx, r, machines, now) {
-		if !v.Free {
+		if !v.Free && !v.Quiet {
 			out = append(out, agentRootObservation(v, trusted[v.Machine]))
 		}
 	}