fix(#1257): confirm delivery by draft transition, not prompt detection (adopts #1262) (#1332)

Co-authored-by: code-infra-01 <[email protected]>

packages/mosaic/framework/tools/tmux/send-message.sh

@@ -33,8 +33,10 @@
 #   1  tmux target not found
 #   2  submission NOT confirmed — either still an unsubmitted draft, or the REPL
 #      input box could not be located to confirm the message actually landed.
-#      Locating the box is runtime-specific; see locate_input_box() below, and
-#      add a shape there before pointing this tool at a new runtime.
+#      Delivered verdicts are runtime-agnostic (cursor-row draft transition, or
+#      the queued banner); locate_input_box() below adds positive DRAFT evidence
+#      for panes that render a recognizable box, and never gates delivery on a
+#      runtime's rendering shape.
 #      Delivery is NEVER inferred from absence of evidence: if we cannot positively
 #      see the input box clear of the message (or the queued banner), we fail loud
 #      so the sender learns immediately instead of a silent worker->lead stall.
@@ -99,11 +101,33 @@ printf '%s' "$MSG" | "${tmux_cmd[@]}" load-buffer -b "$BUF" -
 #   would otherwise accumulate forever.
 sleep 0.5
 
+# 2) Submit, then POSITIVELY confirm submission by DRAFT TRANSITION, not by prompt
+#    glyph. The historical bug was treating ABSENCE of a draft as delivery; the
+#    2026-08 fix over-corrected to glyph inference (grep '❯|^>|│ >'), which locates
+#    only Claude Code's box and false-NEGATIVES every glyphless REPL (pi renders a
+#    U+2500 rule, no glyph) — a delivered message reported "UNDELIVERED", driving a
+#    retry that duplicates it. Runtime-agnostic evidence: our message tail sits on
+#    the INPUT line (located by the cursor row, not a glyph) BEFORE Enter, and has
+#    LEFT it AFTER — that transition is positive proof of submission and needs no
+#    glyph. Absence alone still never means delivered: if we never saw our draft on
+#    the input line we stay UNCONFIRMED (wrong/dead pane), and a draft that never
+#    leaves the input line stays a DRAFT (exit 2), preserving both historical guards.
+_cursor_line() { # echo the pane's current input (cursor) line, glyph-free
+  local cy line
+  cy=$("${tmux_cmd[@]}" display-message -p -t "$EFFECTIVE_TARGET" -F '#{cursor_y}' 2>/dev/null) || return 1
+  [ -n "$cy" ] || return 1
+  "${tmux_cmd[@]}" capture-pane -t "$EFFECTIVE_TARGET" -p 2>/dev/null | sed -n "$((cy + 1))p"
+}
+_draft_on_input() { # true iff our message tail is sitting on the input line now
+  [ -n "$snippet" ] || return 1
+  grep -qF "$snippet" <<<"$(_cursor_line)"
+}
+
 # Locate the REPL input box in a captured pane. Prints the box's contents on
-# stdout and returns 0 when the box was FOUND; returns 1 when it could not be
-# located at all. Found-but-empty is a real, distinct answer (an empty input box
-# is what a submitted message leaves behind), so the caller must branch on the
-# return code, never on whether the output is empty.
+# stdout and returns 0 when the box was FOUND; returns 1 when it could not
+# be located at all. Found-but-empty is a real, distinct answer (an empty input
+# box is what a submitted message leaves behind), so the caller must branch on
+# the return code, never on whether the output is empty.
 #
 # Two REPL shapes are recognised:
 #   * a prompt-glyph line — `❯`, a leading `>`, or `│ >`. Claude Code and most
@@ -113,10 +137,15 @@ sleep 0.5
 #     what makes it safe: agent output can contain its own rules, but nothing is
 #     drawn below the input box except the status line.
 #
-# Adding a runtime means adding its shape HERE. A shape that is missing does not
-# degrade gracefully: it turns every send to that runtime into a false
-# "may be UNDELIVERED", which is what #1362 measured on pi and #1257 on another
-# arm of the same probe.
+# Compose authority rule (#1332 O1): this function is POSITIVE DRAFT EVIDENCE
+# ONLY. A located box still carrying our tail is affirmative proof the message
+# was not consumed (the cursor-row check's blind spot: a redrawn TUI can park
+# the cursor off the input line, which the draft-transition anchor cannot see).
+# Its failure to find a box proves NOTHING and must never produce an
+# UNDELIVERED verdict: a shapeless-but-submitting pane delivers via the
+# cursor-row transition regardless (measured, scratch probe 2026-09-04;
+# shapeless REPL consumed the message while shape probing alone reported
+# "may be UNDELIVERED" — the exact #1257 regression this split prevents).
 locate_input_box() {
   local pane=$1 glyph_line rule_lines top bottom
   glyph_line=$(printf '%s\n' "$pane" | grep -E '❯|^>|│ >' | tail -1)
@@ -139,13 +168,12 @@ locate_input_box() {
   return 0
 }
 
-# 2) Submit, then POSITIVELY confirm submission; flush with another Enter if it is
-#    still a draft. Success requires positive evidence — the queued banner, OR the
-#    REPL input box located AND clear of our message tail. The historical bug was
-#    treating ABSENCE of a draft as delivery: if the input box was never located
-#    (wrong pane / prompt-glyph drift), an unsubmitted message read as "delivered"
-#    and worker->lead relays stalled silently. We now default to UNCONFIRMED and only
-#    upgrade to delivered on positive evidence; anything we cannot confirm fails loud.
+# Baseline: after the paste, our draft must be on the input line. This is positive
+# proof we are on the right pane and the paste landed — the anchor the transition
+# check measures against.
+saw_draft=0
+_draft_on_input && saw_draft=1
+
 status="unconfirmed"
 for attempt in $(seq 1 $((RETRIES + 1))); do
   "${tmux_cmd[@]}" send-keys -t "$EFFECTIVE_TARGET" Enter
@@ -155,19 +183,30 @@ for attempt in $(seq 1 $((RETRIES + 1))); do
   if grep -qF "$QUEUED_RE" <<<"$pane"; then
     status="queued"; break
   fi
-  # If we cannot see the input box, we have NO evidence of submission state —
-  # stay UNCONFIRMED and retry; never infer delivery.
-  if ! inputbox=$(locate_input_box "$pane"); then
-    status="unconfirmed"; continue
+  # POSITIVE draft evidence from a located input box, when one exists. This is
+  # the cursor-row check's blind spot: a redrawn TUI (pi's box) can park the
+  # cursor off the input line, which the draft-transition anchor cannot see,
+  # while a pane in COOKED mode (a plain shell whose foreground process never
+  # reads stdin) echoes our paste via the kernel line discipline and moves the
+  # cursor off it on Enter, indistinguishable from a real submit by cursor row
+  # alone. If a locatable box still carries our tail, that is affirmative proof
+  # the message was not consumed. Absence of a recognizable shape is never used
+  # for anything — that inference is the original E7 bug, and the delivered
+  # verdict stays with the runtime-agnostic cursor-row transition.
+  if inputbox=$(locate_input_box "$pane"); then
+    if [ -n "$snippet" ] && grep -qF "$snippet" <<<"$inputbox"; then
+      status="draft"; continue
+    fi
   fi
-  # Input box located AND still carrying our tail => unsubmitted draft. Flush + retry.
-  # (Submitted messages scroll up into history; a draft stays in the box.)
-  if [ -n "$snippet" ] && grep -qF "$snippet" <<<"$inputbox"; then
-    status="draft"; continue
+  if [ "$saw_draft" = 1 ]; then
+    if _draft_on_input; then
+      status="draft"; continue      # still on the input line => not submitted; flush + retry
+    fi
+    status="delivered"; break        # left the input line => positively submitted
   fi
-  # Input box located AND clear of our tail => positively submitted. This is the
-  # only path to success besides the queued banner.
-  status="delivered"; break
+  # No confirmed baseline yet: try to (re)acquire it; never infer delivery from absence.
+  if _draft_on_input; then saw_draft=1; status="draft"; continue; fi
+  status="unconfirmed"; continue
 done
 
 [ "$VERBOSE" = 1 ] && { echo "--- pane tail ($TARGET) ---"; printf '%s\n' "$pane" | tail -4; echo "---"; }
@@ -176,6 +215,6 @@ case "$status" in
   delivered)   echo "✓ delivered to $TARGET"; exit 0 ;;
   queued)      echo "✓ queued to $TARGET (agent busy — will process when it returns to prompt)"; exit 0 ;;
   draft)       echo "✗ still an unsubmitted draft on $TARGET after $RETRIES flush attempts" >&2; exit 2 ;;
-  unconfirmed) echo "✗ could not confirm submission on $TARGET: REPL input box not locatable after $((RETRIES + 1)) attempts — message may be UNDELIVERED (check target/pane, retry, or escalate)" >&2; exit 2 ;;
+  unconfirmed) echo "✗ could not confirm submission on $TARGET: REPL input prompt not locatable after $((RETRIES + 1)) attempts — message may be UNDELIVERED (check target/pane, retry, or escalate)" >&2; exit 2 ;;
   *)           echo "✗ could not confirm submission on $TARGET (unexpected state '$status')" >&2; exit 2 ;;
 esac