Count the rides a question takes, without the reset (V-663)

MaxSuspends did not move the number it was written for. Twenty-six of 140
turns carried a parked clarify tail before it landed and twenty-six after.

Two bounds rearm each other. An aside spends no attempt, so MaxAttempts
never reaches it. A turn reading as a failed answer zeroes Suspends, so
MaxSuspends never reaches the asides. Alternating them restores each bound
with the other's traffic. Measured on 2026-08-08: one question about a
reminder's day rode turns 7 to 13.

PendingQuestion.Rides is the same event counted without the resets. Set
once, incremented only in noteSuspended, carried across the re-park in
askRemainingGap, read by nothing that could lower it. MaxRides is 4, one
looser than MaxSuspends so the tighter statement about a run stays
reachable.

It ends the measured ride one turn early and no more. Most of that ride is
attempts, spent because classifyTurnRole reads "спасибо" and "привет" as
failed answers. Said so in the constant and in the design doc rather than
claiming a fix.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013ptwopxyo3Z2kwFckHkLvN

internal/dialogue/clarify.go

@@ -47,6 +47,11 @@ type PendingQuestion struct {
 	// charging it a retry is the V-554 shape. See CanResume for why it is
 	// counted at all.
 	Suspends int
+	// Rides counts every turn this question has ridden out on the end of
+	// someone else's reply, over the whole life of the request. Unlike Suspends
+	// it is never reset and never re-based, which is the only property that
+	// matters about it (V-663).
+	Rides int
 }
 
 // MaxSuspends — how many times one question may step aside and come back before
@@ -63,10 +68,52 @@ type PendingQuestion struct {
 // is that he has moved on and has not said so.
 const MaxSuspends = 3
 
+// MaxRides — how many turns one question may ride out on the end of an
+// unrelated reply, counted over its whole life (V-663).
+//
+// MaxSuspends did not move the measurement it was written for. Twenty-six of
+// 140 turns carried a tail before it landed and twenty-six carried one after.
+// Every bound on this question is rearmed by something ordinary:
+//
+//   - The TTL is an inactivity timer, and both noteSuspended and reaskOrGiveUp
+//     restart it, so it cannot arrive while he keeps talking.
+//   - Suspends is zeroed by any turn that reads as an answer, which is where
+//     "спасибо" and "привет" land. It resets before anything is known to have
+//     been filled.
+//   - askRemainingGap builds a fresh question for the second gap, so a reminder
+//     with two gaps gets a new allowance halfway through.
+//
+// So Suspends only bites on four strictly consecutive side queries with nothing
+// chat-like between them, which is not the shape real conversation has. Rides is
+// the same idea with the resets taken out: set once, incremented, carried
+// across a re-park, and read by nothing that could lower it.
+//
+// The shape it is aimed at is measured, not imagined. In the 2026-08-08 run one
+// question about a reminder's day rode turns 7 to 13 and ended only because
+// turn 14 was a new request. Three asides, then two turns that read as failed
+// answers, then two more asides. The asides spend no attempt and the answers
+// reset Suspends, so the two bounds take turns being rearmed by the other's
+// traffic.
+//
+// Four, not three. It has to be looser than MaxSuspends or that bound is dead
+// code, because Rides is never lower than Suspends and would always fire first.
+//
+// Do not read this as a fix for the whole ride. It ends the measured one a turn
+// early and no more. Most of that ride's length is attempts, spent by turns
+// like "спасибо" and "привет" being read as failed answers to a question about
+// a day. That is a defect in classifyTurnRole and not in any bound here.
+const MaxRides = 4
+
 // CanResume reports whether this question may step aside once more. False ⇒ the
 // caller lets the request go and says so; it must never simply stop resuming,
 // because a question dropped in silence reads as one that was answered.
-func (q *PendingQuestion) CanResume() bool { return q.Suspends < MaxSuspends }
+//
+// Two bounds, and they answer different questions. Suspends asks whether he has
+// walked away from this exchange in the last few turns. Rides asks whether this
+// question has been riding long enough that the answer is no regardless.
+func (q *PendingQuestion) CanResume() bool {
+	return q.Suspends < MaxSuspends && q.Rides < MaxRides
+}
 
 // Action reads the parked question as the typed action it is assembling
 // (pending.go). Derived rather than stored: the question's fields stay the one