a re-ask names what the answer before it gave her (V-593)

After "на 9" and then "на завтра" she asked "Сейчас 02:34. Это утра или
вечера?" twice, byte for byte. Asking again is right — the half of the
day is still unsaid — but a reply with no trace of his turn in it is
indistinguishable from not having been heard, which is the failure mode
the V-558 family exists to remove.

whenKnownOf reads the three things he has to say about the time off the
same predicates whenGapOf reads. When his answer moved any of them
forward, the ask carries an acknowledgement of what it took, in his own
words and never a restatement: a 1.7B asked to say a Russian sentence
back is exactly where V-592 came from. When it moved nothing, there is
nothing to acknowledge and the question repeats honestly.

The clock still opens every time question, per the owner's ruling. The
acknowledgement goes between it and the question. Whether she should
state the clock on every ask of one flow is his call, not mine.

Also folds a fact's raw answer into the parked utterance (V-592): a fact
fills no Text slot, so "запиши" + "пил воду" confirmed as "запиши".

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

cmd/mavend/clarify.go

@@ -214,7 +214,7 @@ func (h *reactiveHandler) clarifyQuestion(dec router.Decision) (dialogue.Slot, s
 	if len(missing) == 0 {
 		return "", "", false
 	}
-	q, ok := h.questionFor(missing[0], 1, dec.Utterance, toDialogueSlots(dec.Slots))
+	q, ok := h.questionFor(missing[0], 1, dec.Utterance, toDialogueSlots(dec.Slots), "")
 	if !ok {
 		return "", "", false
 	}
@@ -225,11 +225,14 @@ func (h *reactiveHandler) clarifyQuestion(dec router.Decision) (dialogue.Slot, s
 // reads its deck by attempt; the time asks about whichever of the hour, the half
 // of the day and the day he has not said, and states the clock while it does
 // (V-579).
-func (h *reactiveHandler) questionFor(slot dialogue.Slot, attempt int, utterance string, s dialogue.Slots) (string, bool) {
+//
+// taken is the acknowledgement of what his last turn added, empty when it added
+// nothing and empty for a first ask, which has no turn behind it (V-593).
+func (h *reactiveHandler) questionFor(slot dialogue.Slot, attempt int, utterance string, s dialogue.Slots, taken string) (string, bool) {
 	if slot != dialogue.SlotTime {
 		return clarifyQuestionFor(slot, attempt)
 	}
-	return whenQuestion(whenGapOf(utterance, s.HasTime), attempt, h.now())
+	return whenQuestion(whenGapOf(utterance, s.HasTime), attempt, h.now(), taken)
 }
 
 // askClarify parks the request and returns the question to ask instead of the
@@ -384,18 +387,35 @@ func (h *reactiveHandler) resolveClarifyAnswer(ctx context.Context, text string)
 	// as the reminder payload — so a reminder clarified out of a bare "напомни"
 	// would fire at 11:00 saying "напомни" and nothing else.
 	q.Utterance = foldAnswerIntoUtterance(q.Utterance, merged.Text)
+	// A fact answers with a key and a value and fills no Text slot at all, so
+	// the fold above leaves the utterance at the bare "запиши" — and that is
+	// what the confirmation now reads back to him (V-592). His raw words are the
+	// only record of what he said, so they are what is folded. Never for a time
+	// question: what he says about when is kept apart in WhenText on purpose,
+	// or the reminder would read the day back at him when it fires.
+	if merged.Text == "" && !asksAboutTime(q.Missing) {
+		q.Utterance = foldAnswerIntoUtterance(q.Utterance, text)
+	}
 	// An answer about the time joins everything else he has said about the time,
 	// and the whole of it is re-read as one request (V-579). "завтра" names the
 	// day of an hour she is already holding, and read alone it names no hour at
 	// all, so the parser would have nothing and she would ask for ever.
+	// What he had already said about the time, read BEFORE this answer joins it.
+	// A re-ask that cannot tell the two apart is the one that repeats itself
+	// byte for byte (V-593).
+	var taken string
 	if asksAboutTime(q.Missing) {
+		before := whenKnownOf(whenTextOf(q), q.Slots.HasTime)
 		q.WhenText = strings.TrimSpace(q.WhenText + " " + text)
 		if t, ok := h.readWhen(ctx, intent, q, text); ok {
 			merged.Time, merged.HasTime = t, true
 		}
+		if before.movedForward(whenKnownOf(whenTextOf(q), merged.HasTime)) {
+			taken = whenTakenLine(text)
+		}
 	}
 	if stillOpen(q.Missing, whenTextOf(q), merged) {
-		return h.reaskOrGiveUp(ctx, q, merged, text), true
+		return h.reaskOrGiveUp(ctx, q, merged, text, taken), true
 	}
 	h.clarifyStore.Delete(dialogueIDOf(ctx))
 
@@ -496,7 +516,7 @@ func (h *reactiveHandler) askRemainingGap(ctx context.Context, q *dialogue.Pendi
 	}
 	// Attempts+1 is the question she is about to ask, and the budget is shared
 	// with the re-ask path, so the second gap is worded like a second try.
-	question, ok := h.questionFor(remaining[0], q.Attempts+1, whenTextOf(q), merged)
+	question, ok := h.questionFor(remaining[0], q.Attempts+1, whenTextOf(q), merged, "")
 	if !ok || !q.CanAsk() {
 		return "", false
 	}
@@ -518,10 +538,12 @@ func (h *reactiveHandler) askRemainingGap(ctx context.Context, q *dialogue.Pendi
 // reaskOrGiveUp handles an answer that left the gap open: ask the same question
 // again while she has attempts left, otherwise say she did not understand and
 // let the request go. Never returns "" — a mute give-up reads as "done".
-func (h *reactiveHandler) reaskOrGiveUp(ctx context.Context, q *dialogue.PendingQuestion, merged dialogue.Slots, text string) string {
+// taken is the acknowledgement of what this answer DID give, empty when it gave
+// nothing (V-593). The give-up line never carries it: it is not another ask.
+func (h *reactiveHandler) reaskOrGiveUp(ctx context.Context, q *dialogue.PendingQuestion, merged dialogue.Slots, text, taken string) string {
 	question := ""
 	if len(q.Missing) > 0 {
-		question, _ = h.questionFor(q.Missing[0], q.Attempts+1, whenTextOf(q), merged)
+		question, _ = h.questionFor(q.Missing[0], q.Attempts+1, whenTextOf(q), merged, taken)
 	}
 	if question == "" || !q.CanAsk() {
 		h.clarifyStore.Delete(dialogueIDOf(ctx))