@zerwiz/ymir 0.1.3 → 0.1.5

package/.agents/tests/fm-send-inbox-doorbell-live-e2e.test.sh

@@ -0,0 +1,206 @@
+#!/usr/bin/env bash
+# tests/fm-send-inbox-doorbell-live-e2e.test.sh - the live doorbell guard
+# (live-harness-optin family).
+#
+# The steering inbox's one behavioral assumption is that a real worker agent
+# follows the constant self-describing doorbell line: list the inbox, read and
+# act on its records in numeric order, then mv each into handled/. A stub can
+# only confirm the assumption already
+# written into the stub, so per .agents/skills/firstmate-coding-guidelines
+# this is proven against every INSTALLED verified harness: each is launched
+# idle in an isolated tmux server, steered through the REAL fm-send (durable
+# record + doorbell), and must both ACT on the instruction (create a named
+# file) and ACKNOWLEDGE it (the mv into handled/), failing loudly with the
+# harness name and version.
+#
+# Run explicitly with FM_SEND_INBOX_LIVE_E2E=1. This test spends a small
+# number of real model tokens per installed harness (one short turn each) -
+# authorized by the harness-dependent-checks rule. An absent harness is
+# reported explicitly and skipped; a run that verified nothing fails rather
+# than passing vacuously. Restrict with
+# FM_SEND_INBOX_LIVE_HARNESSES="claude codex ..." when needed, and tune the
+# per-harness wait with FM_SEND_INBOX_LIVE_TIMEOUT (seconds, default 240).
+# Record the dated per-harness result in
+# docs/verification/runtime-backends.md ("Steering-inbox doorbell").
+#
+# Folder trust: harnesses launch with the repo root as cwd, which the
+# operator's machine has normally already trusted; a trust dialog is a real
+# unready state and correctly fails that harness's check.
+set -u
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+if [ "${FM_SEND_INBOX_LIVE_E2E:-0}" != 1 ]; then
+  echo "skip: set FM_SEND_INBOX_LIVE_E2E=1 to run the live steering-inbox doorbell guard"
+  exit 0
+fi
+
+command -v tmux >/dev/null 2>&1 || { echo "not ok - FM_SEND_INBOX_LIVE_E2E=1 but tmux is not installed" >&2; exit 1; }
+unset NO_MISTAKES_GATE
+
+SOCKET="fm-inbox-live-$$"
+SESSION="inboxlive"
+LAB=$(mktemp -d "${TMPDIR:-/tmp}/fm-inbox-live.XXXXXX")
+LAB=$(cd "$LAB" && pwd)
+TIMEOUT=${FM_SEND_INBOX_LIVE_TIMEOUT:-240}
+CHECKED=0
+FAILED=0
+
+pass() { printf 'ok - %s\n' "$1"; }
+note() { printf '# %s\n' "$1"; }
+
+cleanup() {
+  tmux -L "$SOCKET" kill-server 2>/dev/null || true
+  rm -rf "$LAB"
+}
+trap cleanup EXIT
+
+# fm-send and the composer readiness read both reach tmux through bare `tmux`
+# calls, so a PATH shim pins them to the private socket.
+SHIM_DIR="$LAB/shim"
+mkdir -p "$SHIM_DIR"
+REAL_TMUX=$(command -v tmux)
+cat > "$SHIM_DIR/tmux" <<SH
+#!/usr/bin/env bash
+exec "$REAL_TMUX" -L "$SOCKET" "\$@"
+SH
+chmod +x "$SHIM_DIR/tmux"
+PATH="$SHIM_DIR:$PATH"
+# shellcheck source=/dev/null
+. "$ROOT/bin/fm-tmux-lib.sh"
+# shellcheck source=/dev/null
+. "$ROOT/bin/fm-task-inbox-lib.sh"
+
+tmux -L "$SOCKET" new-session -d -s "$SESSION" -x 220 -y 50 -c "$ROOT"
+
+harness_version() {  # <binary>
+  "$1" --version 2>/dev/null | head -1 || printf 'version-unknown'
+}
+
+# Launch <name> idle with its unattended-autonomy flags (the same posture
+# bin/fm-spawn.sh uses), so the doorbell-triggered shell actions need no
+# interactive approval.
+launch_cmd() {  # <name>
+  case "$1" in
+    claude) printf '%s' 'CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION=false claude --dangerously-skip-permissions' ;;
+    codex) printf '%s' 'codex --dangerously-bypass-approvals-and-sandbox' ;;
+    opencode) printf '%s' "OPENCODE_CONFIG_CONTENT='{\"permission\":{\"*\":\"allow\"}}' opencode" ;;
+    pi|pi-signed) printf '%s' "$1" ;;
+    grok) printf '%s' 'grok --always-approve' ;;
+    kimi) printf '%s' 'kimi --auto' ;;
+    muse) printf '%s' 'MUSE_EXPERIMENTAL_FOREIGN_PERSONAL_CONTEXT_KILL=on muse --yolo' ;;
+    *) return 1 ;;
+  esac
+}
+
+# Wait for the harness to look steerable. 0 = the composer classified a
+# proven empty; 2 = the readiness budget expired without an empty verdict but
+# also without a pending one. The caller proceeds on 2 with a note, because
+# that mirrors production exactly: the send path's composer check is ADVISORY
+# and skips only on visibly pending text, so a harness whose idle screen the
+# classifier cannot positively identify still gets its doorbell (the composer
+# matrix guard, not this one, owns re-proving the classifier per release).
+wait_ready() {  # <window>
+  local win=$1 i=0 budget=60 verdict dismissed=0 screen
+  while [ "$i" -lt "$budget" ]; do
+    verdict=$(fm_tmux_composer_state "$SESSION:$win")
+    [ "$verdict" = empty ] && return 0
+    i=$((i + 1))
+    # Dismiss one non-trust startup modal (update prompts), as the composer
+    # matrix guard does; never Enter, which could accept an upgrade.
+    if [ "$dismissed" -eq 0 ] && [ "$i" -ge $((budget / 3)) ]; then
+      screen=$(tmux -L "$SOCKET" capture-pane -p -t "$SESSION:$win" 2>/dev/null || true)
+      if ! printf '%s\n' "$screen" | grep -qi 'trust'; then
+        tmux -L "$SOCKET" send-keys -t "$SESSION:$win" Escape 2>/dev/null || true
+      fi
+      dismissed=1
+    fi
+    sleep 1
+  done
+  case "$verdict" in
+    pending) return 1 ;;
+  esac
+  return 2
+}
+
+check_harness_doorbell() {  # <name>
+  local name=$1 version cmd win="hx-$1" home task acted rec handled i ready_rc
+  version=$(harness_version "$name")
+  cmd=$(launch_cmd "$name") || { note "no launch recipe for $name"; return 0; }
+  home="$LAB/$name-home"
+  mkdir -p "$home/state"
+  task="live-$name"
+  acted="$LAB/acted-$name"
+  tmux -L "$SOCKET" new-window -d -t "$SESSION:" -n "$win" -c "$ROOT" \
+    -- bash -lc "$cmd" \
+    || { FAILED=1; printf 'not ok - %s (%s): could not launch in the isolated tmux server\n' "$name" "$version" >&2; return 0; }
+  wait_ready "$win"; ready_rc=$?
+  if [ "$ready_rc" -eq 1 ]; then
+    FAILED=1
+    printf 'not ok - %s (%s): composer stayed visibly pending; the pane is not steerable\n' "$name" "$version" >&2
+    tmux -L "$SOCKET" capture-pane -p -t "$SESSION:$win" 2>/dev/null | grep '[^[:space:]]' | tail -6 | sed 's/^/#   /' >&2
+    tmux -L "$SOCKET" kill-window -t "$SESSION:$win" 2>/dev/null || true
+    return 0
+  fi
+  [ "$ready_rc" -eq 0 ] || note "$name ($version): idle composer never classified empty; proceeding as production does (advisory check skips only on pending)"
+  printf 'window=%s:%s\nkind=ship\nharness=%s\n' "$SESSION" "$win" "$name" > "$home/state/$task.meta"
+  if ! FM_HOME="$home" FM_ROOT_OVERRIDE="$home" "$ROOT/bin/fm-send.sh" "$task" \
+    "Firstmate live check: run exactly this shell command now: touch $acted - then follow the mv instruction you were given for this message. Reply with one short line." \
+    >/dev/null 2>&1; then
+    FAILED=1
+    printf 'not ok - %s (%s): fm-send refused the live steer\n' "$name" "$version" >&2
+    tmux -L "$SOCKET" kill-window -t "$SESSION:$win" 2>/dev/null || true
+    return 0
+  fi
+  rec="$home/state/$task.inbox/001.msg"
+  handled="$home/state/$task.inbox/handled/001.msg"
+  [ -f "$rec" ] || {
+    FAILED=1
+    printf 'not ok - %s (%s): fm-send left no durable inbox record\n' "$name" "$version" >&2
+    tmux -L "$SOCKET" kill-window -t "$SESSION:$win" 2>/dev/null || true
+    return 0
+  }
+  i=0
+  while [ "$i" -lt "$TIMEOUT" ]; do
+    [ -f "$handled" ] && [ -e "$acted" ] && break
+    # Halfway through, play the watcher's role once: re-ring an unacknowledged
+    # message so a doorbell swallowed by a startup or update modal recovers
+    # exactly as the production re-ring ladder recovers it.
+    if [ "$i" -eq $((TIMEOUT / 2)) ] && [ -f "$rec" ]; then
+      fm_task_inbox_ring tmux "$SESSION:$win" "$rec" || true
+      note "$name ($version): re-rang the doorbell once (watcher's role) at ${i}s"
+    fi
+    sleep 1
+    i=$((i + 1))
+  done
+  if [ -f "$handled" ] && [ -e "$acted" ]; then
+    CHECKED=$((CHECKED + 1))
+    pass "$name ($version): the doorbell reached a real worker, which acted and acked with the mv"
+  else
+    FAILED=1
+    printf 'not ok - %s (%s): doorbell not honored within %ss (acted=%s acked=%s)\n' \
+      "$name" "$version" "$TIMEOUT" "$([ -e "$acted" ] && echo yes || echo no)" \
+      "$([ -f "$handled" ] && echo yes || echo no)" >&2
+    tmux -L "$SOCKET" capture-pane -p -t "$SESSION:$win" 2>/dev/null | grep '[^[:space:]]' | tail -10 | sed 's/^/#   /' >&2
+  fi
+  tmux -L "$SOCKET" kill-window -t "$SESSION:$win" 2>/dev/null || true
+}
+
+HARNESSES=${FM_SEND_INBOX_LIVE_HARNESSES:-'claude codex opencode pi grok kimi muse'}
+for h in $HARNESSES; do
+  if command -v "$h" >/dev/null 2>&1; then
+    check_harness_doorbell "$h"
+  else
+    note "harness absent, not verified here: $h"
+  fi
+done
+
+if [ "$FAILED" -ne 0 ]; then
+  printf 'not ok - live steering-inbox doorbell guard found failures above\n' >&2
+  exit 1
+fi
+if [ "$CHECKED" -eq 0 ]; then
+  printf 'not ok - live steering-inbox doorbell guard verified nothing (no harness installed?)\n' >&2
+  exit 1
+fi
+pass "live steering-inbox doorbell guard: $CHECKED harness(es) honored the doorbell contract"

package/.agents/tests/fm-send-inbox.test.sh

@@ -0,0 +1,352 @@
+#!/usr/bin/env bash
+# tests/fm-send-inbox.test.sh - fm-send's inbox data plane.
+#
+# An ordinary text steer to a task recorded in this home no longer types its
+# payload: fm-send appends a durable sequenced record to state/<id>.inbox/ and
+# rings one constant self-describing doorbell line, best-effort. These tests
+# drive the real fm-send executable over a stubbed tmux and pin:
+#   1. The payload is durably recorded and never typed; only the doorbell
+#      crosses the terminal, and the send exits 0 at enqueue.
+#   2. Multi-line steers are legal and round-trip byte-exact.
+#   3. A re-send enqueues a NEW sequence and still never retypes a payload,
+#      so the terminal can never truncate, garble, or duplicate a steer.
+#   4. The composer pre-check is advisory: visibly pending text skips the ring
+#      with a notice, and the steer is still durably sent (exit 0).
+#   5. A failed doorbell is still a sent steer (exit 0, record durable): the
+#      watcher's re-ring ladder owns delivery from the record on.
+#   6. Carve-outs keep the typed plane: a leading "/" (any harness), a leading
+#      "$" to codex, an explicit backend target, and the --key path.
+#   7. A marked secondmate steer carries its marker + corr token in the record
+#      body, and the pending-reply expectation is marked delivered at enqueue.
+#   8. Pending-reply bookkeeping failure after enqueue never reports a
+#      retryable send failure that could duplicate the durable instruction.
+#   9. An unwritable inbox is a real local failure: nonzero exit, nothing
+#      typed, and a just-created pending-reply expectation is discarded.
+# Every case below that passes a literal `$...` message quotes it on purpose
+# (the point is sending an unexpanded `$` line), so SC2016 is disabled.
+# shellcheck disable=SC2016
+set -u
+
+# shellcheck source=tests/lib.sh
+. "$(dirname "${BASH_SOURCE[0]}")/lib.sh"
+# shellcheck source=/dev/null
+. "$ROOT/bin/fm-marker-lib.sh"
+
+SEND="$ROOT/bin/fm-send.sh"
+
+TMP_ROOT=$(fm_test_tmproot fm-send-inbox)
+TMP_ROOT=$(cd "$TMP_ROOT" && pwd)
+
+# Stub tmux: logs literal typed text to FM_SEND_LOG and lets the submit and
+# composer paths reach clean verdicts. FM_FAKE_TMUX_COMPOSER=pending renders a
+# composer visibly holding text; FM_FAKE_TMUX_SEND_FAIL=1 fails send-keys.
+make_stubs() {  # <dir> -> echoes fakebin dir
+  local dir=$1 fb="$1/fakebin"
+  mkdir -p "$fb"
+  cat > "$fb/tmux" <<'SH'
+#!/usr/bin/env bash
+set -u
+case "${1:-}" in
+  send-keys)
+    [ "${FM_FAKE_TMUX_SEND_FAIL:-0}" = 1 ] && exit 1
+    shift
+    literal=0
+    while [ $# -gt 0 ]; do
+      case "$1" in
+        -t) shift 2 ;;
+        -l) literal=1; shift ;;
+        *) break ;;
+      esac
+    done
+    if [ "$literal" = 1 ]; then
+      printf '%s\n' "${1:-}" >> "$FM_SEND_LOG"
+    fi
+    exit 0 ;;
+  display-message)
+    for a in "$@"; do case "$a" in *cursor_y*) printf '1\n'; exit 0 ;; esac; done
+    printf 'fakepane\n'; exit 0 ;;
+  capture-pane)
+    if [ "${FM_FAKE_TMUX_COMPOSER:-}" = pending ]; then
+      printf '╭──────────────╮\n│ leftover txt │\n╰──────────────╯\n'
+    else
+      printf '╭────╮\n│    │\n╰────╯\n'
+    fi
+    exit 0 ;;
+  list-windows) exit 0 ;;
+esac
+exit 0
+SH
+  chmod +x "$fb/tmux"
+  cat > "$fb/sleep" <<'SH'
+#!/usr/bin/env bash
+exit 0
+SH
+  chmod +x "$fb/sleep"
+  printf '%s\n' "$fb"
+}
+
+setup_case() {  # <name> [harness] -> echoes case dir with home/state + t1 meta
+  local name=$1 harness=${2:-claude} dir
+  dir="$TMP_ROOT/$name"
+  mkdir -p "$dir/home/state"
+  make_stubs "$dir" >/dev/null
+  fm_write_meta "$dir/home/state/t1.meta" "window=sess:fm-t1" "kind=ship" "harness=$harness"
+  printf '%s\n' "$dir"
+}
+
+run_send() {  # <case-dir> <err-file> [env...] -- <fm-send args...>
+  local dir=$1 err=$2
+  shift 2
+  local envs=()
+  while [ "$#" -gt 0 ] && [ "$1" != "--" ]; do
+    envs+=("$1")
+    shift
+  done
+  shift
+  : > "$dir/send.log"
+  env PATH="$dir/fakebin:$PATH" \
+    FM_ROOT_OVERRIDE="$dir/home" FM_HOME="$dir/home" FM_SEND_LOG="$dir/send.log" \
+    FM_SEND_SETTLE=0 ${envs[@]+"${envs[@]}"} \
+    "$SEND" "$@" >/dev/null 2>"$err"
+}
+
+record_body() {  # <record>
+  bash -c '. "$1"; fm_task_inbox_body "$2"' _ "$ROOT/bin/fm-task-inbox-lib.sh" "$2"
+}
+
+test_text_steer_rides_inbox() {
+  local dir err rc rec body typed
+  dir=$(setup_case rides); err="$dir/send.err"
+  run_send "$dir" "$err" -- t1 "please rebase onto main"; rc=$?
+  expect_code 0 "$rc" "an inbox-plane steer should exit 0 at enqueue"
+  rec="$dir/home/state/t1.inbox/001.msg"
+  [ -f "$rec" ] || fail "the steer was not durably recorded at $rec"
+  body=$(record_body _ "$rec")
+  [ "$body" = "please rebase onto main" ] || fail "the recorded body differs: $body"
+  typed=$(cat "$dir/send.log")
+  assert_contains "$typed" "Firstmate instruction waiting: list $dir/home/state/t1.inbox/*.msg" \
+    "the doorbell should direct the worker to drain the inbox"
+  case "$typed" in
+    *"please rebase onto main"*) fail "the payload must never be typed:"$'\n'"$typed" ;;
+  esac
+  pass "fm-send inbox: the payload is recorded durably and only the doorbell is typed"
+}
+
+test_multiline_steer_is_legal() {
+  local dir err rc body
+  dir=$(setup_case multiline); err="$dir/send.err"
+  run_send "$dir" "$err" -- t1 $'first line\nsecond line\nthird: with punctuation'; rc=$?
+  expect_code 0 "$rc" "a multi-line steer should succeed"
+  body=$(record_body _ "$dir/home/state/t1.inbox/001.msg")
+  [ "$body" = $'first line\nsecond line\nthird: with punctuation' ] \
+    || fail "the multi-line body did not round-trip:"$'\n'"$body"
+  case "$(cat "$dir/send.log")" in
+    *"second line"*) fail "a payload line leaked onto the typed channel" ;;
+  esac
+  pass "fm-send inbox: newlines are legal and the terminal can no longer truncate a steer"
+}
+
+test_resend_enqueues_new_sequence() {
+  local dir err doorbells typed
+  dir=$(setup_case resend); err="$dir/send.err"
+  run_send "$dir" "$err" -- t1 "check the CI result" || fail "first send failed"
+  run_send "$dir" "$err" -- t1 "check the CI result" || fail "second send failed"
+  [ -f "$dir/home/state/t1.inbox/001.msg" ] && [ -f "$dir/home/state/t1.inbox/002.msg" ] \
+    || fail "a re-send should enqueue a new sequence:"$'\n'"$(ls "$dir/home/state/t1.inbox")"
+  doorbells=$(grep -cF 'Firstmate instruction waiting' "$dir/send.log" || true)
+  [ "$doorbells" = 1 ] || fail "each send rings once (the log is truncated per send), got $doorbells"
+  typed=$(cat "$dir/send.log")
+  assert_contains "$typed" "numeric order" \
+    "a newer record's doorbell should preserve inbox sequence ordering"
+  case "$typed" in
+    *"check the CI result"*) fail "a re-send typed the payload" ;;
+  esac
+  pass "fm-send inbox: a re-send is a new durable record, never a retyped payload"
+}
+
+test_pending_composer_skips_ring_advisorily() {
+  local dir err rc
+  dir=$(setup_case pendingskip); err="$dir/send.err"
+  run_send "$dir" "$err" FM_FAKE_TMUX_COMPOSER=pending -- t1 "steer past a stuck composer"; rc=$?
+  expect_code 0 "$rc" "a skipped ring is still a sent steer"
+  [ -f "$dir/home/state/t1.inbox/001.msg" ] || fail "the steer was not recorded"
+  [ ! -s "$dir/send.log" ] || fail "a visibly pending composer should skip the ring:"$'\n'"$(cat "$dir/send.log")"
+  assert_contains "$(cat "$err")" "watcher will re-ring" \
+    "the skip notice should point at the re-ring"
+  pass "fm-send inbox: a visibly pending composer skips the ring, and the steer stays durably sent"
+}
+
+test_failed_ring_is_still_sent() {
+  local dir err rc
+  dir=$(setup_case ringfail); err="$dir/send.err"
+  run_send "$dir" "$err" FM_FAKE_TMUX_SEND_FAIL=1 -- t1 "steer into a dead pane"; rc=$?
+  expect_code 0 "$rc" "a failed doorbell must not fail the send"
+  [ -f "$dir/home/state/t1.inbox/001.msg" ] || fail "the steer was not recorded"
+  assert_contains "$(cat "$err")" "watcher will re-ring" \
+    "the failed-ring notice should point at the re-ring"
+  pass "fm-send inbox: a failed doorbell is still a durably sent steer"
+}
+
+test_harness_invocations_stay_typed() {
+  local dir err typed
+  # A slash command must reach the harness's own parser, on any harness.
+  dir=$(setup_case slash); err="$dir/send.err"
+  run_send "$dir" "$err" -- t1 "/no-mistakes" || fail "a slash send should succeed"
+  typed=$(cat "$dir/send.log")
+  assert_contains "$typed" "/no-mistakes" "the slash command should be typed literally"
+  [ ! -d "$dir/home/state/t1.inbox" ] || fail "a slash command must not be routed to the inbox"
+  # A codex `$<skill>` invocation likewise stays typed.
+  dir=$(setup_case codexskill codex); err="$dir/send.err"
+  run_send "$dir" "$err" -- t1 '$no-mistakes' || fail "a codex \$skill send should succeed"
+  assert_contains "$(cat "$dir/send.log")" '$no-mistakes' "the codex \$skill should be typed literally"
+  [ ! -d "$dir/home/state/t1.inbox" ] || fail "a codex \$skill must not be routed to the inbox"
+  # The same `$` message to a non-codex harness is plain text: inbox plane.
+  dir=$(setup_case dollartext claude); err="$dir/send.err"
+  run_send "$dir" "$err" -- t1 '$5/month is cheap' || fail "a claude \$-text send should succeed"
+  [ -f "$dir/home/state/t1.inbox/001.msg" ] || fail "a non-codex \$-message should ride the inbox"
+  case "$(cat "$dir/send.log")" in
+    *'$5/month'*) fail "a non-codex \$-message payload was typed" ;;
+  esac
+  pass "fm-send planes: slash and codex \$skill invocations stay typed; plain \$-text rides the inbox"
+}
+
+test_explicit_target_stays_typed() {
+  local dir err
+  dir=$(setup_case explicit); err="$dir/send.err"
+  run_send "$dir" "$err" -- sess:win "hello there" || fail "an explicit-target send should succeed"
+  assert_contains "$(cat "$dir/send.log")" "hello there" \
+    "an explicit backend target should receive the literal text"
+  [ -z "$(find "$dir/home/state" -maxdepth 1 -name '*.inbox' -print 2>/dev/null)" ] \
+    || fail "an explicit target has no task record here and must not grow an inbox"
+  pass "fm-send planes: an explicit backend target keeps the typed plane"
+}
+
+test_key_path_never_touches_inbox() {
+  local dir err
+  dir=$(setup_case keypath); err="$dir/send.err"
+  run_send "$dir" "$err" -- t1 --key Enter || fail "a --key send should succeed"
+  [ ! -d "$dir/home/state/t1.inbox" ] || fail "the --key path must never write an inbox record"
+  pass "fm-send planes: the --key lifecycle path never touches the inbox"
+}
+
+test_secondmate_marker_and_enqueue_delivery() {
+  local dir err body corr pr_rec delivered
+  dir=$(setup_case secondmate); err="$dir/send.err"
+  fm_write_secondmate_meta "$dir/home/state/domain.meta" "$dir/home" "sess:fm-domain"
+  run_send "$dir" "$err" -- fm-domain "please summarize fleet health" \
+    || fail "a secondmate steer should succeed"
+  body=$(record_body _ "$dir/home/state/domain.inbox/001.msg")
+  case "$body" in
+    "$FM_FROMFIRST_MARK"corr=*) : ;;
+    *) fail "the recorded body lost the from-firstmate marker/corr framing:"$'\n'"$body" ;;
+  esac
+  corr=$(printf '%s' "$body" | grep -oE 'corr=[a-f0-9]{16}' | head -1 | cut -d= -f2)
+  [ -n "$corr" ] || fail "no corr token in the recorded body"
+  pr_rec="$dir/home/state/pending-replies/$corr"
+  [ -f "$pr_rec" ] || fail "no pending-reply expectation was recorded at $pr_rec"
+  delivered=$(grep '^delivered_epoch=' "$pr_rec" | cut -d= -f2)
+  [ -n "$delivered" ] || fail "enqueue IS delivery: delivered_epoch should be set at enqueue time:"$'\n'"$(cat "$pr_rec")"
+  case "$(cat "$dir/send.log")" in
+    *"summarize fleet health"*) fail "the marked payload was typed" ;;
+  esac
+  pass "fm-send inbox: a secondmate steer records marker+corr in the body and is delivered at enqueue"
+}
+
+test_post_enqueue_bookkeeping_failure_is_not_retryable() {
+  local dir err rc rec body
+  dir=$(setup_case bookkeeping-failure); err="$dir/send.err"
+  fm_write_secondmate_meta "$dir/home/state/domain.meta" "$dir/home" "sess:fm-domain"
+  cat > "$dir/fakebin/mv" <<'SH'
+#!/usr/bin/env bash
+set -u
+source_arg=${@: -2:1}
+target_arg=${@: -1}
+if [ "${FM_FAIL_DELIVERY_CONFIRM:-0}" = 1 ] \
+  && grep -q '^confirmed=' "$source_arg" 2>/dev/null; then
+  # Simulate losing both the delivery commit and its prepared recovery marker.
+  rm -f "$target_arg"
+  exit 1
+fi
+exec /bin/mv "$@"
+SH
+  chmod +x "$dir/fakebin/mv"
+
+  run_send "$dir" "$err" FM_FAIL_DELIVERY_CONFIRM=1 -- domain "durable once"; rc=$?
+  # The durable record IS the delivery: even with the commit AND its recovery
+  # marker both lost, the steer was delivered, so fm-send must not signal a
+  # status that invites a resend (a nonzero would make automated callers
+  # enqueue the same instruction again under a new sequence). The degradation
+  # surfaces as its own distinct do-not-resend condition instead.
+  expect_code 0 "$rc" "a delivered steer must not report a resend-inviting failure over lost bookkeeping"
+  rec="$dir/home/state/domain.inbox/001.msg"
+  [ -f "$rec" ] || fail "bookkeeping failure test did not durably enqueue the steer"
+  [ "$(find "$dir/home/state/domain.inbox" -maxdepth 1 -name '*.msg' | wc -l | tr -d ' ')" = 1 ] \
+    || fail "the delivered steer was duplicated:"$'\n'"$(ls "$dir/home/state/domain.inbox")"
+  body=$(record_body _ "$rec")
+  case "$body" in
+    "$FM_FROMFIRST_MARK"corr=*) : ;;
+    *) fail "bookkeeping failure test lost the secondmate marker: $body" ;;
+  esac
+  assert_contains "$(cat "$err")" "reply-tracking-degraded" \
+    "lost bookkeeping should surface as its own distinct degraded condition"
+  assert_contains "$(cat "$err")" "do not resend" \
+    "the degraded condition should give explicit do-not-resend guidance"
+  assert_contains "$(cat "$err")" "durably recorded at" \
+    "the degraded condition should name the already-delivered record"
+  pass "fm-send inbox: lost reply bookkeeping never invites a resend, and the delivered steer is never duplicated"
+}
+
+test_meta_lock_contention_fails_bounded() {
+  local dir err rc holder marker lock i
+  dir=$(setup_case meta-lock); err="$dir/send.err"
+  marker="$dir/meta-lock-held"
+  lock="$dir/home/state/.meta-t1.lock"
+  bash -c '
+    . "$1"
+    fm_lock_acquire_wait "$2"
+    touch "$3"
+    sleep 30
+  ' _ "$ROOT/bin/fm-wake-lib.sh" "$lock" "$marker" &
+  holder=$!
+  i=0
+  while [ ! -e "$marker" ] && [ "$i" -lt 100 ]; do
+    sleep 0.05
+    i=$((i + 1))
+  done
+  [ -e "$marker" ] || { kill "$holder" 2>/dev/null; fail "the metadata lock holder did not start"; }
+  run_send "$dir" "$err" FM_TASK_INBOX_LOCK_WAIT_SECS=0 -- t1 "must not hang"; rc=$?
+  kill "$holder" 2>/dev/null; wait "$holder" 2>/dev/null
+  [ "$rc" -ne 0 ] || fail "metadata lock contention should fail after the bounded wait"
+  [ ! -d "$dir/home/state/t1.inbox" ] || fail "a lock refusal must not enqueue a record"
+  assert_contains "$(cat "$err")" "metadata could not be locked" \
+    "the bounded metadata lock refusal should be explicit"
+  pass "fm-send inbox: metadata lock contention fails bounded without enqueue"
+}
+
+test_unwritable_inbox_fails_loudly() {
+  local dir err rc
+  dir=$(setup_case unwritable); err="$dir/send.err"
+  fm_write_secondmate_meta "$dir/home/state/domain.meta" "$dir/home" "sess:fm-domain"
+  : > "$dir/home/state/domain.inbox"   # a FILE where the inbox dir must go
+  run_send "$dir" "$err" -- fm-domain "this cannot be recorded"; rc=$?
+  [ "$rc" -ne 0 ] || fail "an unwritable inbox must fail the send"
+  assert_contains "$(cat "$err")" "inbox record could not be written" \
+    "the failure should name the unwritable inbox"
+  [ ! -s "$dir/send.log" ] || fail "a failed enqueue still typed something:"$'\n'"$(cat "$dir/send.log")"
+  [ -z "$(find "$dir/home/state/pending-replies" -type f -not -name '.*' 2>/dev/null)" ] \
+    || fail "a failed enqueue should discard the just-created pending-reply expectation"
+  pass "fm-send inbox: an unwritable record is a loud local failure that leaves no false expectation"
+}
+
+test_text_steer_rides_inbox
+test_multiline_steer_is_legal
+test_resend_enqueues_new_sequence
+test_pending_composer_skips_ring_advisorily
+test_failed_ring_is_still_sent
+test_harness_invocations_stay_typed
+test_explicit_target_stays_typed
+test_key_path_never_touches_inbox
+test_secondmate_marker_and_enqueue_delivery
+test_post_enqueue_bookkeeping_failure_is_not_retryable
+test_meta_lock_contention_fails_bounded
+test_unwritable_inbox_fails_loudly