Judge a send by when a fault began, not when it was last raised (hq issue 348)

On 2026-10-09 the control node's resolver refused from 10:57:57 UTC. A
node-engine restarted by the 10:59:34 send said its names undecided, that
statement cleared the network condition, the next look raised it again
after the send, and the gate put back two builds for a fault older than
them.

- A condition keeps First across a reopening; the gate reads Began.
- An undecided network statement (unknown, starting) clears nothing.
- D10 counts what a release's tier names as rolling, so a walked
  node-engine is not core-behind on its own first machine.
- D2 raises a resolver that refuses every try at once: a refusal is an
  answer, not a loaded resolver (issue 277).

internal/conditions/store_test.go

@@ -378,3 +378,56 @@ func TestATransitionIsOfferedAgainWhileTheBusIsAway(t *testing.T) {
 		t.Fatalf("said %+v, unsaid %d", said, k.Unsaid())
 	}
 }
+
+// **A reopening keeps when the fault began** (novox/hq issue 348): Raised is the reopening, Began the
+// first raising — also from a keeper that read what cleared from the history — and past the window a
+// raising is a new fault that begins then.
+func TestAReopeningKeepsWhenTheFaultBegan(t *testing.T) {
+	k, store, told, c := keeper(t)
+	ctx := t.Context()
+	first, err := k.Observe(ctx, silent("ace"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !first.Began().Equal(first.Raised) || !first.First.IsZero() {
+		t.Fatalf("a first raising began at %s, raised %s, first %s", first.Began(), first.Raised, first.First)
+	}
+	if _, err := k.Clear(ctx, "machine.ace.silent", "heard again"); err != nil {
+		t.Fatal(err)
+	}
+	c.pass(time.Minute)
+	again, err := k.Observe(ctx, silent("ace"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !again.Raised.After(first.Raised) || !again.Began().Equal(first.Raised) {
+		t.Fatalf("reopened: raised %s, began %s; first raised %s", again.Raised, again.Began(), first.Raised)
+	}
+	// Through a restarted controller, reading the clearing from the history.
+	if _, err := k.Clear(ctx, "machine.ace.silent", "heard again"); err != nil {
+		t.Fatal(err)
+	}
+	settled(t, told, 4)
+	k.Close(context.Background())
+	next := NewKeeper(ctx, Options{Store: store, History: store, Now: c.now})
+	defer next.Close(context.Background())
+	c.pass(time.Minute)
+	third, err := next.Observe(ctx, silent("ace"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !third.Began().Equal(first.Raised) {
+		t.Fatalf("after a restart the reopening began at %s, not %s", third.Began(), first.Raised)
+	}
+	if _, err := next.Clear(ctx, "machine.ace.silent", "heard again"); err != nil {
+		t.Fatal(err)
+	}
+	c.pass(ReopenWithin + time.Minute)
+	fourth, err := next.Observe(ctx, silent("ace"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !fourth.Began().Equal(fourth.Raised) {
+		t.Fatalf("past the window the fault began at %s, raised %s", fourth.Began(), fourth.Raised)
+	}
+}