fix(triage): exonerate the reducer for the stuck-Send + clear input on Start-over (PP-4846) (#1318)

PP-4846 (repro-first): after Discard → pick a different category → type, the Send
arrow intermittently stayed disabled. It did not reproduce deterministically.

Pinned the REDUCER side of that flow — the source of truth the Send button's
`disabled` predicate reads (`!isFollowUpStep && inputText.trimmed.isEmpty`).
`StuckSendReproTests` drives Discard → re-category → type and proves inputText is
set and the step is a composition step, i.e. Send is enabled at the reducer
level. So the intermittent field report is localized to the SwiftUI TextField
binding (consistent with the "UIKit gesture-timeout" log + the non-determinism),
NOT the state machine.

Writing that test surfaced a real, separate latent bug: `.userTappedStartOver`
returned to `.awaitingCategory` but did NOT clear `inputText`, so a half-typed
composer survived "start fresh" — unlike Discard, which lands empty. In practice
Start-over is reached with inputText already empty (post-submit), but the two
reset paths should have identical composer semantics. Now both clear it.

Verified: TriageBotCore reducer suites green (StuckSendReproTests +
CategoryChipDebounce + StructuredEscalation, 13/13).

**Scope:** the Start-over reset clears inputText; reducer-level tests for both
reset paths. No SwiftUI change.

**Not done:** the intermittent SwiftUI TextField(axis:.vertical) binding
re-sync itself — reducer is exonerated; recommended fix is the local-@State
mirror pattern already used by TicketPreviewCard, but it can't be verified
without a deterministic repro, so it is not shipped blind here.

**Deferred:** a simdrive repro harness for the SwiftUI race (needs a dedicated
run; the field bug is intermittent).

Co-authored-by: t <t@t.io>

Author: mauricecarrier7

Palace/Packages/PalaceTriageBot/Sources/TriageBotCore/Reducer/ConversationReducer.swift

@@ -635,6 +635,11 @@ public struct ConversationReducer: Sendable {
 
         case .userTappedStartOver:
             next.step = .awaitingCategory
+            // "Start fresh" means a clean composer: drop any half-typed input so
+            // the next description begins empty (PP-4846). Mirrors Discard, which
+            // also returns to .awaitingCategory with no carried-over text — the
+            // two reset paths now have identical composer semantics.
+            next.inputText = ""
             next.messages.append(.init(
                 sender: .bot,
                 kind: .text("OK — let's start fresh. What's happening?")

Palace/Packages/PalaceTriageBot/Tests/TriageBotCoreTests/StuckSendReproTests.swift

@@ -0,0 +1,86 @@
+import XCTest
+@testable import TriageBotCore
+
+/// PP-4846: after Discard → pick a different category → type, the Send arrow
+/// intermittently stayed disabled. The report is "repro-first" — it did not
+/// reproduce deterministically in the regression pass.
+///
+/// This suite pins the **reducer** side of that flow, which is the source of
+/// truth the Send button's `disabled` predicate reads
+/// (`!isFollowUpStep && state.inputText.trimmed.isEmpty`). If the reducer ever
+/// left `inputText` empty or the step wrong after Discard→re-category→type, the
+/// button would be legitimately (not racily) stuck — this proves it does not, so
+/// the intermittent field report is localized to the SwiftUI TextField binding,
+/// not the state machine.
+final class StuckSendReproTests: XCTestCase {
+
+    private func reducer() -> ConversationReducer {
+        // An entry with NO escalationFollowUp → an escalating match drafts a
+        // ticket directly (reaching the .drafting/preview step we then Discard).
+        let entry = KBEntry(id: "KI-DRAFT", category: .audiobook, status: .open,
+                            symptomKeywords: ["glitchy audio"],
+                            userFacingWorkaround: "Please try re-downloading the title.",
+                            confidenceThreshold: 0.1)
+        return ConversationReducer(knowledgeBase: KnowledgeBase(
+            catalog: KBCatalog(version: "test", updatedAt: "2026-07-20", entries: [entry])))
+    }
+
+    /// Send-enabled == the UI predicate: a non-follow-up composition step with a
+    /// non-empty trimmed input.
+    private func sendWouldBeEnabled(_ state: ConversationState) -> Bool {
+        let composing: Bool
+        switch state.step {
+        case .awaitingDescription, .awaitingCategory, .awaitingFollowUp: composing = true
+        default: composing = false
+        }
+        return composing && !state.inputText.trimmingCharacters(in: .whitespaces).isEmpty
+    }
+
+    func testDiscardThenNewCategoryThenType_leavesSendEnabled() {
+        let r = reducer()
+
+        // Drive to a ticket preview (drafting).
+        var (s, _) = r.reduce(state: ConversationState(), action: .start)
+        (s, _) = r.reduce(state: s, action: .userTappedCategory(.audiobook))
+        (s, _) = r.reduce(state: s, action: .inputChanged("my glitchy audio problem"))
+        (s, _) = r.reduce(state: s, action: .userSubmittedDescription)
+        guard case .drafting = s.step else {
+            return XCTFail("expected a ticket preview (.drafting); got \(s.step)")
+        }
+
+        // Discard the preview.
+        (s, _) = r.reduce(state: s, action: .userCancelledTicketSubmit)
+        XCTAssertEqual(s.step, .awaitingCategory, "Discard must return to the category chooser")
+        XCTAssertTrue(s.inputText.isEmpty, "Discard must leave the composer empty")
+        XCTAssertFalse(sendWouldBeEnabled(s), "no text yet → Send stays disabled (correct)")
+
+        // Pick a DIFFERENT category.
+        (s, _) = r.reduce(state: s, action: .userTappedCategory(.reader))
+        guard case .awaitingDescription(let category) = s.step else {
+            return XCTFail("re-selecting a category must open a fresh description step; got \(s.step)")
+        }
+        XCTAssertEqual(category, .reader, "the newly tapped category must win")
+
+        // Type a new description — Send MUST re-enable.
+        (s, _) = r.reduce(state: s, action: .inputChanged("a totally different reader issue"))
+        XCTAssertEqual(s.inputText, "a totally different reader issue",
+                       "typing after Discard→re-category must update inputText")
+        XCTAssertTrue(sendWouldBeEnabled(s),
+                      "PP-4846: after Discard→new category→type, Send must be enabled at the reducer level")
+    }
+
+    /// Also guard the Start-over reset path (the other way back to the chooser).
+    func testStartOverThenCategoryThenType_leavesSendEnabled() {
+        let r = reducer()
+        var (s, _) = r.reduce(state: ConversationState(), action: .start)
+        (s, _) = r.reduce(state: s, action: .userTappedCategory(.audiobook))
+        (s, _) = r.reduce(state: s, action: .inputChanged("stale text that should be cleared"))
+        (s, _) = r.reduce(state: s, action: .userTappedStartOver)
+        XCTAssertEqual(s.step, .awaitingCategory)
+        XCTAssertTrue(s.inputText.isEmpty, "Start-over must clear any half-typed input")
+
+        (s, _) = r.reduce(state: s, action: .userTappedCategory(.signin))
+        (s, _) = r.reduce(state: s, action: .inputChanged("new signin question"))
+        XCTAssertTrue(sendWouldBeEnabled(s), "Send must re-enable after Start-over→category→type")
+    }
+}