fix(tmux): confirm delivery by draft transition, not by prompt glyph (#1257)

send-message.sh located the REPL input box with grep -E '❯|^>|│ >'. That set is
Claude Code's box. A pi seat renders a bare U+2500 rule with no glyph, so on every
idle pi seat the capture succeeded, the grep matched nothing, status stayed
"unconfirmed", and the tool exited 2 "may be UNDELIVERED" with the paste and the
Enter both landed. The stderr tells the operator to retry, and that retry is the
duplicate delivery reported against the same tool.

Confirmation is now runtime-agnostic: our message tail sits on the input line
(located by cursor row, no glyph) before Enter and has left it after. That
transition is positive proof of submission.

Absence still proves nothing, which is the guard the 2026-08 fix was reaching for
and got backwards. Two positive checks keep it:

  - a prompt box that IS locatable and still carries our tail => draft, exit 2.
    This covers the cursor-row blind spot: a cooked pane whose foreground process
    never reads stdin echoes the paste through the kernel line discipline and
    moves the cursor off it on Enter, which by cursor row alone is indistinguishable
    from a real submit.
  - no draft ever observed on the input line => unconfirmed, non-zero.

Tests, both red-first against the shipping blob d397907:

  test-send-message-glyph-agnostic.sh (new, 6 fixtures)  4/6 -> 6/6
  test-send-message-verdict.sh (fixture 2 reshaped, 2b added)  3/4 -> 4/4

Fixture 2 of the verdict suite asserted exit 2 for a glyphless pane that submits
and was labelled "false-positive FIXED". A pi seat is that fixture, so the suite
was locking the bug in. It is reshaped deliberately, and the guard it was credited
with moves to new fixture 2b (glyphless AND non-submitting, raw/no-echo) so the
"never infer delivered from absence" property is tested positively rather than as
a side effect.

Measured on tmux 3.7b (sb-it-1-dt), 3.5a (fomo-lin), and dragon-lin.

Co-authored-by: scooby <[email protected]>

.woodpecker/ci.yml

@@ -30,19 +30,6 @@ steps:
       # the baked pnpm store.
       - pnpm install --frozen-lockfile --prefer-offline
 
-  # ---------------------------------------------------------------------------
-  # The steps below (sanitization, upgrade-guard, typecheck, lint, format,
-  # test) are the COMPLETE mandatory verification set. SDLC-D-034 mirrors them
-  # one-for-one in the canonical terminal verification command — root
-  # `pnpm verify:release` (scripts/verify-release.mjs) — which the publish
-  # pipeline (.woodpecker/publish.yml `verify` step) runs before ANY publish
-  # effect. These lines stay direct (not routed through the runner) because the
-  # #1017 test-enumeration guard audits framework tool paths through THIS
-  # surface; scripts/verify-release.test.mjs enforces that the runner's stage
-  # table keeps matching these commands exactly, so the two cannot drift.
-  # ---------------------------------------------------------------------------
-
-  # Canonical verify:release stage `sanitization`.
   # Blocking gate: public framework package must contain no operator-specific
   # personal data or private $HOME defaults. Runs early (no node_modules needed).
   sanitization:
@@ -60,7 +47,6 @@ steps:
       # with everything it guards; this direct line keeps one instrument running.
       - bash packages/mosaic/framework/tools/quality/scripts/check-test-enumeration.sh
 
-  # Canonical verify:release stage `upgrade-guard`.
   # Blocking gate (#791): a framework upgrade must never write or delete an
   # operator-owned path. The HARD GATE proves an unanticipated operator sentinel
   # survives a keep-mode reseed byte-identical (with rsync present AND absent —
@@ -82,8 +68,6 @@ steps:
       - bash packages/mosaic/framework/tools/quality/scripts/test-upgrade-durable-snapshot.sh
       - bash packages/mosaic/framework/tools/quality/scripts/test-install-migration.sh
 
-  # Canonical verify:release stage `typecheck` — the same `pnpm typecheck`
-  # invocation (which runs the checkout preflight first, then turbo).
   typecheck:
     image: *node_image
     commands:
@@ -94,8 +78,7 @@ steps:
       - sanitization
       - upgrade-guard
 
-  # lint, format, and test are independent — run in parallel after typecheck.
+  # lint, format, and test are independent — run in parallel after typecheck
-  # Each runs exactly its canonical verify:release stage command.
   lint:
     image: *node_image
     commands:
@@ -112,12 +95,6 @@ steps:
     depends_on:
       - typecheck
 
-  # Canonical verify:release stage `test` — the `pnpm test` line below is the
-  # shared command; everything else in this step is PIPELINE-LEVEL
-  # prerequisite the canonical command expects its caller to provide (SDLC-D-034):
-  # the ci-postgres service + pg_isready wait + db:migrate (postgres path),
-  # `apk add openssl`, and the pinned pi install. None of those can move into
-  # the runner (it must also work locally on the PGlite path with no database).
   test:
     image: *node_image
     environment:

.woodpecker/publish.yml

@@ -1,19 +1,5 @@
 # Build, publish npm packages, and push Docker images
 # Runs on main for stable publishes and on next for integration-line prereleases/images
-#
-# SDLC-D-034 publish gate: every publish effect (publish-npm, publish-next-npm,
-# and every image build/push step) depends DIRECTLY on the `verify` step below.
-# `verify` (a) asserts the provider's commit identity matches the actual
-# checkout (CI_COMMIT_SHA == git rev-parse HEAD, fail closed on mismatch or
-# emptiness) and (b) runs the canonical terminal verification command
-# (`pnpm verify:release`), which mirrors the PR CI pipeline's complete
-# mandatory set (sanitization, upgrade-guard, preflight+typecheck, lint,
-# format:check, test, build) — see scripts/verify-release.mjs. A missing,
-# failed, skipped, cancelled, or inconclusive verification therefore skips the
-# dependent publish effects (fail closed). Path-filtered short-circuits may
-# skip publish EFFECTS (e.g. docs-only merges) but never bypass `verify` for a
-# publish that does run: `verify` itself carries no path filter.
-# scripts/verify-release.test.mjs enforces this DAG invariant at checkout time.
 
 variables:
   # Pre-baked CI base (see .woodpecker/ci-image.yml): node:24-alpine +
@@ -62,45 +48,6 @@ steps:
       # Resolve from the baked pnpm store instead of a cold network fetch.
       - pnpm install --frozen-lockfile --prefer-offline
 
-  # SDLC-D-034 exact-commit publish gate. No `when`/path filter on purpose: it
-  # runs for every event this pipeline serves so no publish effect can ever
-  # start without it. Fails closed on commit-identity mismatch (or either SHA
-  # being empty) and on any incomplete verification.
-  verify:
-    image: *node_image
-    commands:
-      - *enable_pnpm
-      # (a) Commit identity: the provider's claimed SHA must equal the actual
-      # checkout HEAD — verification of anything else must never authorize a
-      # publish of this commit.
-      - |
-        if [ -z "$CI_COMMIT_SHA" ]; then
-          echo "[verify] FATAL: CI_COMMIT_SHA is empty — cannot certify commit identity" >&2
-          exit 1
-        fi
-        CHECKOUT_SHA="$(git rev-parse HEAD 2>/dev/null || true)"
-        if [ -z "$CHECKOUT_SHA" ]; then
-          echo "[verify] FATAL: git rev-parse HEAD returned nothing — cannot certify commit identity" >&2
-          exit 1
-        fi
-        if [ "$CI_COMMIT_SHA" != "$CHECKOUT_SHA" ]; then
-          echo "[verify] FATAL: provider commit ($CI_COMMIT_SHA) != checkout HEAD ($CHECKOUT_SHA)" >&2
-          exit 1
-        fi
-        echo "[verify] commit identity confirmed: $CHECKOUT_SHA"
-      # (b) Canonical terminal verification. Caller-provided prerequisites the
-      # runner expects (see .woodpecker/ci.yml comments): bash/rsync for the
-      # guard stages, openssl + the pinned pi binary for the test stage. git is
-      # baked into ci-base but re-asserted here so the identity check above can
-      # never silently depend on a stale baked image. DATABASE_URL is
-      # deliberately NOT set: the canonical command must hold on the PGlite
-      # path too and never sets or requires a database itself.
-      - apk add --no-cache bash rsync openssl git
-      - npm install -g @earendil-works/[email protected]
-      - pnpm verify:release
-    depends_on:
-      - install
-
   build:
     image: *node_image
     commands:
@@ -108,7 +55,6 @@ steps:
       - pnpm build
     depends_on:
       - install
-      - verify
 
   publish-npm:
     image: *node_image
@@ -168,7 +114,6 @@ steps:
         exit 1
     depends_on:
       - build
-      - verify
 
   publish-next-npm:
     image: *node_image
@@ -247,7 +192,6 @@ steps:
         echo "[publish-next] @mosaicstack/mosaic@next resolves to $RESOLVED_VERSION"
     depends_on:
       - build
-      - verify
 
   # TODO: Uncomment when ready to publish to npmjs.org
   # publish-npmjs:
@@ -261,7 +205,6 @@ steps:
   #     - bash scripts/publish-npmjs.sh
   #   depends_on:
   #     - build
-  #     - verify
   #   when:
   #     - event: [tag]
 
@@ -299,7 +242,6 @@ steps:
         /kaniko/executor --context . --dockerfile docker/gateway.Dockerfile $DESTINATIONS
     depends_on:
       - build
-      - verify
 
   build-appservice:
     image: gcr.io/kaniko-project/executor:debug
@@ -326,7 +268,6 @@ steps:
         /kaniko/executor --context . --dockerfile docker/appservice.Dockerfile $DESTINATIONS
     depends_on:
       - build
-      - verify
 
   build-web:
     image: gcr.io/kaniko-project/executor:debug
@@ -353,4 +294,3 @@ steps:
         /kaniko/executor --context . --dockerfile docker/web.Dockerfile $DESTINATIONS
     depends_on:
       - build
-      - verify

package.json

@@ -9,7 +9,6 @@
     "preflight": "node scripts/preflight.mjs",
     "clean:generated": "node scripts/clean-generated.mjs",
     "typecheck": "pnpm preflight && turbo run typecheck",
-    "verify:release": "node scripts/verify-release.mjs",
     "test:checkout": "node --test scripts/*.test.mjs",
     "test": "pnpm test:checkout && turbo run test && pnpm run test:installer",
     "test:installer": "bash tools/install-next-lane.test.sh",

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

@@ -97,13 +97,34 @@ printf '%s' "$MSG" | "${tmux_cmd[@]}" load-buffer -b "$BUF" -
 #   would otherwise accumulate forever.
 sleep 0.5
 
-# 2) Submit, then POSITIVELY confirm submission; flush with another Enter if it is
+# 2) Submit, then POSITIVELY confirm submission by DRAFT TRANSITION, not by prompt
-#    still a draft. Success requires positive evidence — the queued banner, OR the
+#    glyph. The historical bug was treating ABSENCE of a draft as delivery; the
-#    REPL input box located AND clear of our message tail. The historical bug was
+#    2026-08 fix over-corrected to glyph inference (grep '❯|^>|│ >'), which locates
-#    treating ABSENCE of a draft as delivery: if the prompt glyph was never matched
+#    only Claude Code's box and false-NEGATIVES every glyphless REPL (pi renders a
-#    (wrong pane / prompt-glyph drift), an unsubmitted message read as "delivered"
+#    U+2500 rule, no glyph) — a delivered message reported "UNDELIVERED", driving a
-#    and worker->lead relays stalled silently. We now default to UNCONFIRMED and only
+#    retry that duplicates it. Runtime-agnostic evidence: our message tail sits on
-#    upgrade to delivered on positive evidence; anything we cannot confirm fails loud.
+#    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
+  printf '%s' "$(_cursor_line)" | grep -qF "$snippet"
+}
+
+# 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
@@ -113,20 +134,26 @@ for attempt in $(seq 1 $((RETRIES + 1))); do
   if printf '%s' "$pane" | grep -qF "$QUEUED_RE"; then
     status="queued"; break
   fi
-  # Locate the REPL input box (prompt glyph). If we cannot see it, we have NO
+  # POSITIVE draft evidence from a located prompt box, when one exists. This is the
-  # evidence of submission state — stay UNCONFIRMED and retry; never infer delivery.
+  # cursor-row check's blind spot: 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, which is indistinguishable from
+  # a real submit by cursor row alone. If a prompt box IS locatable and still carries
+  # our tail, that is affirmative proof the message was not consumed. Absence of a
+  # glyph is still never used for anything — that inference is the original E7 bug.
   promptline=$(printf '%s' "$pane" | grep -E '❯|^>|│ >' | tail -1)
-  if [ -z "$promptline" ]; then
+  if [ -n "$promptline" ] && [ -n "$snippet" ] && printf '%s' "$promptline" | grep -qF "$snippet"; then
-    status="unconfirmed"; continue
-  fi
-  # Input box located AND still carrying our tail => unsubmitted draft. Flush + retry.
-  # (Submitted messages scroll up into history; a draft stays on the ❯ line.)
-  if [ -n "$snippet" ] && printf '%s' "$promptline" | grep -qF "$snippet"; then
     status="draft"; continue
   fi
-  # Input box located AND clear of our tail => positively submitted. This is the
+  if [ "$saw_draft" = 1 ]; then
-  # only path to success besides the queued banner.
+    if _draft_on_input; then
-  status="delivered"; break
+      status="draft"; continue      # still on the input line => not submitted; flush + retry
+    fi
+    status="delivered"; break        # left the input line => positively submitted
+  fi
+  # 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 "---"; }

packages/mosaic/framework/tools/tmux/test-send-message-glyph-agnostic.sh

@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+# Red-first regression test for E7 (#1017 task 2): the confirm-check must bind
+# "delivered" to WHETHER THE MESSAGE WAS SUBMITTED, not to which runtime's prompt
+# glyph is present. A pi seat renders a U+2500 rule input box with no ❯/^>/│ >
+# glyph; send-message.sh:118 locates the box only by glyph, so a genuinely
+# delivered message on a glyphless REPL falsely reports exit 2 "may be UNDELIVERED",
+# and the operator's rc=2-driven retry duplicates it.
+#
+# Parameterized on $SEND: RED against the shipping blob (B and D fail), GREEN
+# against a candidate patch. No pi; no fake HOME; hermetic throwaway socket.
+#
+# Submission counting is EXACT and terminal-echo-independent: the fixture message
+# is `echo <tok> >>SINK`; each real submission appends one line. wc -l SINK ==
+# number of times the REPL actually executed the send. This does not depend on how
+# many times the marker string is painted on screen.
+set -u
+SEND="${SEND:?set SEND=/path/to/send-message.sh}"
+SOCKET="glyphagnostic-$$"
+TMP="$(mktemp -d)"
+tmux() { command tmux -L "$SOCKET" "$@"; }
+cleanup() { command tmux -L "$SOCKET" kill-server 2>/dev/null; rm -rf "$TMP"; }
+trap cleanup EXIT
+pass=0; fail=0
+ok() { printf 'ok   %s\n' "$1"; pass=$((pass+1)); }
+no() { printf 'FAIL %s -- %s\n' "$1" "$2"; fail=$((fail+1)); }
+
+mk() { tmux new-session -d -s "$1" -x 120 -y 40 -c "$TMP" "PS1='$2' exec bash --noprofile --norc -i"; sleep 0.5; }
+subs() { [ -f "$1" ] && wc -l <"$1" | tr -d ' ' || echo 0; }  # exact submission count
+
+echo "SEND=$SEND    tmux $(command tmux -V | awk '{print $2}')"
+
+# --- A (control): glyph box (❯) that submits => exit 0, exactly one submission.
+mk ctl '❯ '
+SINK="$TMP/sink.ctl"
+out=$("$SEND" -L "$SOCKET" -t ctl -m "echo x >>'$SINK'" 2>"$TMP/e.ctl"); rc=$?; sleep 0.4
+if [ "$rc" = 0 ] && [ "$(subs "$SINK")" = 1 ]; then
+  ok "control: ❯-box submits => exit 0, exactly one submission"
+else no "control: ❯-box submits => exit 0, one submission" "rc=$rc subs=$(subs "$SINK") err=[$(cat "$TMP/e.ctl")]"; fi
+
+# --- B (THE false-rc regression): glyphless U+2500 box that SUBMITS. Message lands
+#     (subs==1) yet shipping reports exit 2. Must be exit 0.
+mk sub $'──────── \n'
+SINK="$TMP/sink.sub"
+out=$("$SEND" -L "$SOCKET" -t sub -m "echo x >>'$SINK'" 2>"$TMP/e.sub"); rc=$?; sleep 0.4
+if [ "$rc" = 0 ] && [ "$(subs "$SINK")" = 1 ]; then
+  ok "glyphless: U+2500 box that submits => exit 0 (delivered, not 'UNDELIVERED')"
+else no "glyphless: U+2500 box that submits => exit 0" \
+        "rc=$rc subs=$(subs "$SINK")(delivered=$([ "$(subs "$SINK")" -ge 1 ] && echo yes||echo no)) err=[$(cat "$TMP/e.sub")]"; fi
+
+# --- D (duplicate arm): operator follows the rc=2 stderr and retries once. On the
+#     glyphless box, shipping => two submissions (the reported duplicate). The
+#     property: one logical send => exactly one submission. Same fix closes it.
+mk dup $'──────── \n'
+SINK="$TMP/sink.dup"
+tries=0
+for attempt in 1 2; do
+  tries=$((tries+1))
+  out=$("$SEND" -L "$SOCKET" -t dup -m "echo x >>'$SINK'" 2>/dev/null); rc=$?
+  sleep 0.4
+  [ "$rc" = 0 ] && break   # operator stops retrying only when told delivered
+done
+if [ "$(subs "$SINK")" = 1 ]; then
+  ok "duplicate: one logical send (rc-driven retry) => exactly one submission (tries=$tries)"
+else no "duplicate: one logical send => exactly one submission" "submissions=$(subs "$SINK") tries=$tries"; fi
+
+# --- E (faithful hung managed TUI, NOT a cooked shell): raw/no-echo, paints nothing.
+#     A cooked `sleep infinity` echoes the paste via the kernel line discipline and
+#     false-passes a cursor-row fix that is correct on real seats (measured). So: raw.
+mk_rawstuck() { tmux new-session -d -s "$1" -x 120 -y 40 -c "$TMP" \
+  "bash --noprofile --norc -c 'stty -echo -icanon min 1 time 0 2>/dev/null; exec sleep infinity'"; sleep 0.5; }
+mk_rawstuck estuck
+SINK="$TMP/sink.estuck"
+out=$("$SEND" -L "$SOCKET" -t estuck -r 1 -m "this stuck draft was never submitted" 2>/dev/null); rc=$?
+sleep 0.3
+if [ "$rc" != 0 ] && [ "$(subs "$SINK")" = 0 ]; then
+  ok "raw/no-echo stuck TUI (not submitted) => non-zero (no false delivered)"
+else no "raw stuck TUI must NOT report delivered" "rc=$rc subs=$(subs "$SINK")"; fi
+
+# --- F (busy/queued branch, your BUSY-not-runtime finding): glyphless pane rendering the
+#     queued banner, never consuming. QUEUED_RE :113 fires before the glyph grep => rc=0.
+mk_busy() { tmux new-session -d -s "$1" -x 120 -y 40 -c "$TMP" \
+  "bash --noprofile --norc -c 'printf \"Press up to edit queued messages\n\"; exec sleep infinity'"; sleep 0.5; }
+mk_busy ebusy
+SINK="$TMP/sink.ebusy"
+out=$("$SEND" -L "$SOCKET" -t ebusy -m "echo x >>'$SINK'" 2>/dev/null); rc=$?; sleep 0.3
+if [ "$rc" = 0 ]; then
+  ok "busy/queued-banner glyphless => exit 0 (queued is delivery; runtime owns custody)"
+else no "busy/queued-banner must report delivered" "rc=$rc"; fi
+
+# --- C (historical-bug guard): unresolvable target. No pane ever carried our draft
+#     => must fail, never infer delivered from absence of a glyph/snippet.
+if out=$("$SEND" -L "$SOCKET" -t "nonexistent-$$" -m "echo x >>'$TMP/sink.wrong'" 2>/dev/null); then
+  no "wrong-pane: unresolvable target must NOT report success" "expected non-zero, got 0"
+else ok "wrong-pane: unresolvable target => non-zero (no false delivered)"; fi
+
+echo "---"; echo "pass=$pass fail=$fail"
+[ "$fail" = 0 ]

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

@@ -4,10 +4,13 @@
 #
 #   1. DELIVERED   — a REPL that renders a `❯ ` input box and submits on Enter
 #                    (text scrolls to history, box clears) => exit 0 "✓ delivered".
-#   2. UNCONFIRMED — a pane with NO locatable prompt glyph. This is the exact
+#   2. DELIVERED   — a pane with NO prompt glyph that DOES submit => exit 0. A pi
-#                    historical FALSE POSITIVE: pre-patch it printed "✓ delivered"
+#                    seat is this fixture (U+2500 rule, no glyph). Reshaped for
-#                    exit 0; post-patch it MUST fail loud (exit 2, stderr
+#                    #1257; see the note at the fixture for why the old exit-2
-#                    "could not confirm submission").
+#                    assertion was wrong.
+#   2b. UNCONFIRMED— a glyphless pane that never submits (raw/no-echo hung TUI)
+#                    => must fail loud. This carries the historical
+#                    false-positive guard that fixture 2 used to be credited with.
 #   3. DRAFT       — a `❯ `-prompt pane that never submits (message stays on the
 #                    input line) => exit 2, stderr "unsubmitted draft".
 set -uo pipefail
@@ -37,19 +40,44 @@ else
   no "delivered: ❯-prompt REPL that submits => exit 0 ✓ delivered" "rc=$rc out=[$out] err=[$(cat "$TMP/e1")]"
 fi
 
-# --- Fixture 2: NO prompt glyph (default bash PS1). THE regression: pre-patch this
+# --- Fixture 2: NO prompt glyph, and the pane DOES submit (interactive bash).
-#     was a silent false-positive "delivered"; post-patch it must be unconfirmed→exit 2.
+#     RESHAPED 2026-08-16 (#1257), deliberately. This fixture previously asserted
+#     exit 2 here and was labelled "false-positive FIXED". That assertion was wrong,
+#     and locking it in is what kept E7 alive: the pane submits, so "delivered" is
+#     the truth, and a pi seat — whose input box is a bare U+2500 rule with no glyph
+#     — IS this fixture. Reporting exit 2 for it told operators a delivered message
+#     may be undelivered, and the retry that advice invites is the duplicate.
+#
+#     The guard this fixture was reaching for is real and is NOT dropped: "never
+#     infer delivered from absence" is now enforced positively by fixture 2b below
+#     (glyphless AND not submitting => must fail) and by fixture 3 (locatable box
+#     still carrying our tail => draft). Absence alone decides nothing either way.
 tmux -L "$SOCKET" new-session -d -s noglyph -c "$TMP" \
   'PS1="sh-noglyph$ " exec bash --noprofile --norc -i'
 sleep 0.3
-if out=$("$SEND" -L "$SOCKET" -t "=noglyph" -m "verdict fixture two must fail loud" 2>"$TMP/e2"); then
+out=$("$SEND" -L "$SOCKET" -t "=noglyph" -m "verdict fixture two must fail loud" 2>"$TMP/e2"); rc=$?
-  no "unconfirmed: glyphless pane must NOT report success" "expected exit 2, got 0 (out=[$out])"
+if [ "$rc" -eq 0 ] && printf '%s' "$out" | grep -qF "✓ delivered"; then
+  ok "delivered: glyphless pane that submits => exit 0 (runtime-agnostic, E7 FIXED)"
+else
+  no "delivered: glyphless pane that submits => exit 0" "rc=$rc out=[$out] err=[$(cat "$TMP/e2")]"
+fi
+
+# --- Fixture 2b: NO prompt glyph AND never submits — a hung managed TUI holding the
+#     terminal in raw/no-echo, which is what a stuck agent seat actually is (measured
+#     on live pi: stty -echo -icanon). Nothing is echoed, nothing is consumed, so
+#     there is no positive evidence of submission and the tool MUST fail loud. This
+#     is the historical false-positive guard, kept as a positive test.
+tmux -L "$SOCKET" new-session -d -s rawstuck -c "$TMP" \
+  'bash --noprofile --norc -c "stty -echo -icanon min 1 time 0 2>/dev/null; exec sleep infinity"'
+sleep 0.3
+if out=$("$SEND" -L "$SOCKET" -t "=rawstuck" -r 1 -m "verdict fixture two-b never submitted" 2>"$TMP/e2b"); then
+  no "unconfirmed: glyphless hung TUI must NOT report success" "expected non-zero, got 0 (out=[$out])"
 else
   rc=$?
-  if [ "$rc" -eq 2 ] && grep -qF "could not confirm submission" "$TMP/e2"; then
+  if [ "$rc" -ne 0 ] && grep -qF "could not confirm submission" "$TMP/e2b"; then
-    ok "unconfirmed: glyphless pane => exit 2 + 'could not confirm submission' (false-positive FIXED)"
+    ok "unconfirmed: glyphless hung TUI (raw/no-echo) => non-zero + 'could not confirm submission'"
   else
-    no "unconfirmed: glyphless pane => exit 2 + stderr" "rc=$rc err=[$(cat "$TMP/e2")]"
+    no "unconfirmed: glyphless hung TUI => non-zero + stderr" "rc=$rc err=[$(cat "$TMP/e2b")]"
   fi
 fi
 

scripts/verify-release.mjs

@@ -1,166 +0,0 @@
-#!/usr/bin/env node
-// verify-release.mjs — the ONE canonical terminal verification command
-// (SDLC-D-034, `pnpm verify:release`).
-//
-// Publication (.woodpecker/publish.yml `verify` step) is bound to terminal
-// verification of the exact commit through this command, which is composed
-// from the SAME commands the PR CI pipeline (.woodpecker/ci.yml) runs — CI and
-// publish share one semantic checklist:
-//
-//   stage         | mirrors ci.yml step | commands
-//   --------------|---------------------|------------------------------------------
-//   sanitization  | sanitization        | verify-sanitized.sh, check-resident-
-//                |                     | budget.sh (--self-test + run),
-//                |                     | check-test-enumeration.sh
-//   upgrade-guard | upgrade-guard       | test-upgrade-manifest-guard.sh,
-//                |                     | test-upgrade-rollback.sh,
-//                |                     | test-upgrade-durable-snapshot.sh,
-//                |                     | test-install-migration.sh
-//   typecheck     | typecheck           | pnpm typecheck (runs the checkout
-//                |                     | preflight, then turbo typecheck)
-//   lint          | lint                | pnpm lint
-//   format        | format              | pnpm format:check
-//   test          | test                | pnpm test
-//   build         | publish.yml build   | pnpm build
-//
-// Caller-provided prerequisites (kept at the pipeline level — see the comments
-// in .woodpecker/ci.yml): `bash` + `rsync` for the guard stages, `openssl` and
-// the pinned @earendil-works/pi-coding-agent for the test stage, and — on the
-// postgres path only — the ci-postgres service plus
-// `pnpm --filter @mosaicstack/db run db:migrate` before the test stage.
-//
-// This command works with DATABASE_URL set (CI postgres path) or unset (local
-// PGlite path); it never sets, exports, or requires a database itself.
-//
-// scripts/verify-release.test.mjs enforces that this stage table keeps
-// matching .woodpecker/ci.yml step-for-step, so the two surfaces cannot drift
-// apart silently.
-
-import { spawnSync } from 'node:child_process';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-export const STAGES = [
-  {
-    name: 'sanitization',
-    // Mirror of the .woodpecker/ci.yml `sanitization` step (minus its
-    // `apk add` environment prep). Kept as direct command strings here: the
-    // #1017 test-enumeration guard audits these paths through the ci.yml
-    // surface, so indirection from ci.yml into this file is not possible.
-    commands: [
-      'bash packages/mosaic/framework/tools/quality/scripts/verify-sanitized.sh',
-      'bash packages/mosaic/framework/tools/quality/scripts/check-resident-budget.sh --self-test',
-      'bash packages/mosaic/framework/tools/quality/scripts/check-resident-budget.sh',
-      'bash packages/mosaic/framework/tools/quality/scripts/check-test-enumeration.sh',
-    ],
-  },
-  {
-    name: 'upgrade-guard',
-    // Mirror of the .woodpecker/ci.yml `upgrade-guard` step (minus its
-    // `apk add` environment prep).
-    commands: [
-      'bash packages/mosaic/framework/tools/quality/scripts/test-upgrade-manifest-guard.sh',
-      'bash packages/mosaic/framework/tools/quality/scripts/test-upgrade-rollback.sh',
-      'bash packages/mosaic/framework/tools/quality/scripts/test-upgrade-durable-snapshot.sh',
-      'bash packages/mosaic/framework/tools/quality/scripts/test-install-migration.sh',
-    ],
-  },
-  {
-    // `pnpm typecheck` is `pnpm preflight && turbo run typecheck`, so the
-    // checkout preflight (scripts/preflight.mjs) is part of this stage exactly
-    // as it is part of the ci.yml `typecheck` step.
-    name: 'typecheck',
-    commands: ['pnpm typecheck'],
-  },
-  {
-    name: 'lint',
-    commands: ['pnpm lint'],
-  },
-  {
-    name: 'format',
-    commands: ['pnpm format:check'],
-  },
-  {
-    // Requires `openssl` and the pinned `pi` binary on the pipeline path; see
-    // the caller-provided prerequisites above.
-    name: 'test',
-    commands: ['pnpm test'],
-  },
-  {
-    name: 'build',
-    commands: ['pnpm build'],
-  },
-];
-
-export function stageByName(name) {
-  return STAGES.find((stage) => stage.name === name);
-}
-
-function missingBinaries(bins) {
-  return bins.filter(
-    (bin) => spawnSync('sh', ['-c', `command -v ${bin} >/dev/null 2>&1`]).status !== 0,
-  );
-}
-
-function runCommand(command) {
-  const result = spawnSync(command, { shell: true, stdio: 'inherit' });
-  if (result.error) {
-    console.error(`[verify:release] failed to launch '${command}': ${result.error.message}`);
-    return false;
-  }
-  if (result.status !== 0) {
-    const reason = result.signal ? `terminated by ${result.signal}` : `exited ${result.status}`;
-    console.error(`[verify:release] command '${command}' ${reason}`);
-    return false;
-  }
-  return true;
-}
-
-// Runs the complete mandatory verification set (or, with --stage <name>, the
-// single named stage — used for wiring/smoke-testing, not for gating: only a
-// run of every stage is a terminal verification). Fails fast: the first
-// failing command aborts with a non-zero exit code. Returns the exit code.
-export function verifyRelease({ stages = STAGES } = {}) {
-  const missing = missingBinaries(['bash', 'rsync']);
-  if (missing.length > 0) {
-    console.error(
-      `[verify:release] FATAL: required binaries missing from PATH: ${missing.join(', ')}. ` +
-        'The caller provides them (ci-base bakes bash; pipelines apk add rsync).',
-    );
-    return 1;
-  }
-  for (const stage of stages) {
-    console.log(`\n[verify:release] === stage: ${stage.name} ===`);
-    for (const command of stage.commands) {
-      console.log(`[verify:release] $ ${command}`);
-      if (!runCommand(command)) {
-        console.error(
-          `[verify:release] FATAL: stage '${stage.name}' failed — verification inconclusive`,
-        );
-        return 1;
-      }
-    }
-  }
-  console.log(`\n[verify:release] all ${stages.length} stage(s) passed`);
-  return 0;
-}
-
-function main(argv) {
-  const stageFlagIndex = argv.indexOf('--stage');
-  if (stageFlagIndex !== -1) {
-    const name = argv[stageFlagIndex + 1];
-    const stage = stageByName(name);
-    if (!stage) {
-      console.error(
-        `[verify:release] unknown stage '${name ?? ''}' — expected one of: ${STAGES.map((entry) => entry.name).join(', ')}`,
-      );
-      process.exit(2);
-    }
-    process.exit(verifyRelease({ stages: [stage] }));
-  }
-  process.exit(verifyRelease());
-}
-
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  main(process.argv.slice(2));
-}

scripts/verify-release.test.mjs

@@ -1,277 +0,0 @@
-import assert from 'node:assert/strict';
-import { readFile } from 'node:fs/promises';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import test from 'node:test';
-
-import { STAGES } from './verify-release.mjs';
-
-// SDLC-D-034 checkout invariant: publication in .woodpecker/publish.yml is
-// bound to exact-commit terminal verification. This suite parses the real
-// pipeline files and fails red when the gate is bypassed, weakened, or drifts
-// out of sync with the canonical `pnpm verify:release` command.
-
-// Reuse the monorepo's existing YAML parser (@mosaicstack/mosaic's direct
-// dependency) instead of adding a root dependency or vendoring a parser.
-const mosaicRequire = createRequire(
-  path.resolve(process.cwd(), 'packages', 'mosaic', 'package.json'),
-);
-const { parse: parseYaml } = mosaicRequire('yaml');
-
-const publishYmlPath = path.join(process.cwd(), '.woodpecker', 'publish.yml');
-const ciYmlPath = path.join(process.cwd(), '.woodpecker', 'ci.yml');
-
-async function readPublishPipeline() {
-  return parseYaml(await readFile(publishYmlPath, 'utf8'));
-}
-
-// A step has an external publication effect when its name starts with
-// `publish` or when any command pushes an image to a registry.
-function pushesImage(step) {
-  return (step.commands ?? []).some((command) =>
-    /(^|\s)(\/kaniko\/executor|docker push)\b|--destination/.test(command),
-  );
-}
-
-function publishEffectSteps(pipeline) {
-  return Object.entries(pipeline.steps ?? {})
-    .filter(([name, step]) => name.startsWith('publish') || pushesImage(step))
-    .map(([name]) => name);
-}
-
-// Transitive closure of a step's depends_on graph.
-function dependencyClosure(pipeline, stepName, seen = new Set()) {
-  const dependencies = pipeline.steps?.[stepName]?.depends_on ?? [];
-  for (const dependency of dependencies) {
-    if (seen.has(dependency)) continue;
-    seen.add(dependency);
-    dependencyClosure(pipeline, dependency, seen);
-  }
-  return seen;
-}
-
-function verifyCommands(pipeline) {
-  const verify = pipeline.steps?.verify;
-  assert.ok(verify, 'publish pipeline must define a `verify` step');
-  assert.ok(Array.isArray(verify.commands), '`verify` step must have commands');
-  return verify.commands;
-}
-
-function assertCommitIdentityAssertion(commands) {
-  const text = commands.join('\n');
-  assert.match(
-    text,
-    /CI_COMMIT_SHA/,
-    '`verify` must compare the provider commit identity (CI_COMMIT_SHA)',
-  );
-  assert.match(text, /git rev-parse HEAD/, '`verify` must compare against git rev-parse HEAD');
-  assert.match(
-    text,
-    /exit 1/,
-    '`verify` must fail closed (exit 1) on identity mismatch or emptiness',
-  );
-}
-
-function assertCanonicalCommand(commands) {
-  assert.ok(
-    commands.some((command) => /^pnpm verify:release\b/.test(command.trim())),
-    '`verify` must run the canonical terminal verification command `pnpm verify:release`',
-  );
-}
-
-function assertPublishGate(pipeline) {
-  assert.ok(pipeline.steps, 'publish pipeline must define steps');
-
-  const commands = verifyCommands(pipeline);
-  assertCommitIdentityAssertion(commands);
-  assertCanonicalCommand(commands);
-
-  const effects = publishEffectSteps(pipeline);
-  assert.ok(effects.length > 0, 'publish pipeline must contain publish effect steps to guard');
-
-  for (const stepName of effects) {
-    const step = pipeline.steps[stepName];
-    assert.ok(
-      Array.isArray(step.depends_on) && step.depends_on.includes('verify'),
-      `publish effect '${stepName}' must depend DIRECTLY on the verify step (SDLC-D-034: transitively through build is not enough)`,
-    );
-    assert.ok(
-      dependencyClosure(pipeline, stepName).has('verify'),
-      `publish effect '${stepName}' must depend on a chain that includes verify`,
-    );
-  }
-  return effects;
-}
-
-test('the publish pipeline gates every publish effect behind exact-commit verification', async () => {
-  const pipeline = await readPublishPipeline();
-  const effects = assertPublishGate(pipeline);
-  assert.deepEqual(effects.sort(), [
-    'build-appservice',
-    'build-gateway',
-    'build-web',
-    'publish-next-npm',
-    'publish-npm',
-  ]);
-});
-
-test('the verify step carries no path/event short-circuit of its own', async () => {
-  const pipeline = await readPublishPipeline();
-  // A `when` filter on `verify` would let a publish effect fire on an event
-  // class that skipped verification — the gate must be unconditional.
-  assert.equal(pipeline.steps.verify.when, undefined);
-});
-
-test('a publish step that bypasses verify fails the gate checker', () => {
-  // Negative fixture: a plausible publish pipeline where `publish-npm` hangs
-  // off `build` only and `build` never chains to `verify` — the exact bypass
-  // class SDLC-D-034 closes. The checker must go red on it.
-  const bypassingPipeline = `
-steps:
-  install:
-    image: node:24-alpine
-    commands:
-      - pnpm install --frozen-lockfile
-  verify:
-    image: node:24-alpine
-    commands:
-      - |
-        if [ -z "$CI_COMMIT_SHA" ] || [ "$CI_COMMIT_SHA" != "$(git rev-parse HEAD)" ]; then
-          echo "identity mismatch" >&2
-          exit 1
-        fi
-      - pnpm verify:release
-    depends_on:
-      - install
-  build:
-    image: node:24-alpine
-    commands:
-      - pnpm build
-    depends_on:
-      - install
-  publish-npm:
-    image: node:24-alpine
-    commands:
-      - pnpm publish
-    depends_on:
-      - build
-`;
-  assert.throws(
-    () => assertPublishGate(parseYaml(bypassingPipeline)),
-    /publish-npm.*DIRECTLY.*verify/s,
-  );
-});
-
-test('a publish step chained to verify only transitively fails the gate checker', () => {
-  // Negative fixture: `build` depends on verify but `publish-npm` does not
-  // carry the direct edge — weaker than SDLC-D-034 requires of the real DAG.
-  const transitiveOnlyPipeline = `
-steps:
-  install:
-    image: node:24-alpine
-    commands:
-      - pnpm install --frozen-lockfile
-  verify:
-    image: node:24-alpine
-    commands:
-      - |
-        if [ -z "$CI_COMMIT_SHA" ] || [ "$CI_COMMIT_SHA" != "$(git rev-parse HEAD)" ]; then
-          echo "identity mismatch" >&2
-          exit 1
-        fi
-      - pnpm verify:release
-    depends_on:
-      - install
-  build:
-    image: node:24-alpine
-    commands:
-      - pnpm build
-    depends_on:
-      - install
-      - verify
-  publish-npm:
-    image: node:24-alpine
-    commands:
-      - pnpm publish
-    depends_on:
-      - build
-`;
-  assert.throws(
-    () => assertPublishGate(parseYaml(transitiveOnlyPipeline)),
-    /publish-npm.*DIRECTLY.*verify/s,
-  );
-});
-
-test('a verify step without the commit-identity assertion fails the gate checker', () => {
-  const noIdentityPipeline = `
-steps:
-  verify:
-    image: node:24-alpine
-    commands:
-      - pnpm verify:release
-  publish-npm:
-    image: node:24-alpine
-    commands:
-      - pnpm publish
-    depends_on:
-      - verify
-`;
-  assert.throws(() => assertPublishGate(parseYaml(noIdentityPipeline)), /CI_COMMIT_SHA/);
-});
-
-test('the canonical verify:release stages mirror the PR CI pipeline one-for-one', async () => {
-  const ci = parseYaml(await readFile(ciYmlPath, 'utf8'));
-  const canonical = Object.fromEntries(STAGES.map((stage) => [stage.name, stage.commands]));
-
-  // The complete mandatory set, in gate order.
-  assert.deepEqual(
-    STAGES.map((stage) => stage.name),
-    ['sanitization', 'upgrade-guard', 'typecheck', 'lint', 'format', 'test', 'build'],
-  );
-
-  // Guard stages: ci.yml commands minus its `apk add` environment prep must be
-  // exactly the canonical stage commands (order included).
-  for (const stageName of ['sanitization', 'upgrade-guard']) {
-    assert.deepEqual(
-      ci.steps[stageName].commands.filter((command) => !command.startsWith('apk add')),
-      canonical[stageName],
-      `canonical '${stageName}' stage must match the ci.yml step`,
-    );
-  }
-
-  // pnpm stages: ci.yml commands minus `corepack enable` must be exactly the
-  // canonical stage commands.
-  for (const stepName of ['typecheck', 'lint', 'format']) {
-    assert.deepEqual(
-      ci.steps[stepName].commands.filter((command) => command !== 'corepack enable'),
-      canonical[stepName],
-      `canonical '${stepName}' stage must match the ci.yml step`,
-    );
-  }
-
-  // The test stage is shared, but ci.yml wraps it in pipeline-level
-  // prerequisites the canonical command expects its caller to provide
-  // (SDLC-D-034): the postgres service + readiness wait + db:migrate, openssl,
-  // and the pinned pi runtime. None of those may be dropped silently.
-  for (const command of canonical.test) {
-    assert.ok(
-      ci.steps.test.commands.includes(command),
-      `ci.yml test step must run the canonical test stage command '${command}'`,
-    );
-  }
-  for (const fragment of [
-    'pg_isready -h ci-postgres',
-    'pnpm --filter @mosaicstack/db run db:migrate',
-    'npm install -g @earendil-works/[email protected]',
-  ]) {
-    assert.ok(
-      ci.steps.test.commands.some((command) => command.includes(fragment)),
-      `ci.yml test step must keep its pipeline-level prerequisite '${fragment}'`,
-    );
-  }
-});
-
-test('the root package.json exposes verify:release as the canonical command', async () => {
-  const packageJson = JSON.parse(await readFile(path.join(process.cwd(), 'package.json'), 'utf8'));
-  assert.match(packageJson.scripts['verify:release'], /scripts\/verify-release\.mjs/);
-});