@zerwiz/ymir 0.1.4 → 0.1.5

package/.agents/tests/fm-send-secondmate-marker-herdr-e2e.test.sh

@@ -0,0 +1,187 @@
+#!/usr/bin/env bash
+# Real Pi/Herdr regression for exact-id secondmate marker delivery.
+#
+# This is opt-in because it launches a real interactive Pi process and a real
+# isolated Herdr lab session.
+# It exercises the end-user command shape against metadata written by a real
+# fm-spawn.sh --secondmate launch, captures Pi's before_agent_start prompt bytes,
+# and proves both sides of the routing boundary:
+#   - exact task id through explicit FM_HOME receives exactly one marker;
+#   - direct terminal input remains unmarked.
+#
+# Every Herdr call, including calls made inside the production backend adapter,
+# is routed through bin/fm-herdr-lab.sh. The PATH shim strips only the adapter's
+# already-validated trailing --session pair, then delegates to the lab helper,
+# which appends its own required trailing --session before invoking real Herdr.
+set -u
+
+# shellcheck source=tests/lib.sh
+. "$(dirname "${BASH_SOURCE[0]}")/lib.sh"
+# shellcheck source=/dev/null
+. "$ROOT/bin/fm-marker-lib.sh"
+# shellcheck source=/dev/null
+. "$ROOT/bin/fm-backend.sh"
+
+if [ "${FM_SEND_MARKER_HERDR_E2E:-0}" != 1 ]; then
+  echo "skip: set FM_SEND_MARKER_HERDR_E2E=1 to run the real Pi/Herdr secondmate-marker regression"
+  exit 0
+fi
+
+for tool in git herdr jq pi; do
+  command -v "$tool" >/dev/null 2>&1 || { echo "skip: $tool not found"; exit 0; }
+done
+
+LAB_HELPER=${HERDR_LAB_HELPER:-$ROOT/bin/fm-herdr-lab.sh}
+SESSION=$("$LAB_HELPER" name fm-send-secondmate-marker-v7)
+TMP_ROOT=$(mktemp -d "${TMPDIR:-/tmp}/fm-send-marker-herdr-e2e.XXXXXX")
+SENDER_HOME="$TMP_ROOT/sender-home"
+SECOND_HOME="$TMP_ROOT/secondmate-home"
+CAPTURE="$TMP_ROOT/pi-before-agent.jsonl"
+FAKEBIN="$TMP_ROOT/fakebin"
+ORIGINAL_PATH=$PATH
+REAL_PI=$(command -v pi)
+ID='marker-pi-sm'
+REQUEST='FM_MARKER_HERDR_E2E exact-id request'
+DIRECT='FM_MARKER_HERDR_DIRECT captain input'
+
+cleanup() {
+  local rc=$?
+  trap - EXIT
+  if ! "$LAB_HELPER" teardown "$SESSION"; then
+    rc=1
+  fi
+  rm -rf "$TMP_ROOT"
+  exit "$rc"
+}
+trap cleanup EXIT
+
+mkdir -p "$SENDER_HOME/state" "$SENDER_HOME/data" "$SENDER_HOME/config" "$SENDER_HOME/projects" "$FAKEBIN"
+
+# Route production adapter invocations through the same guarded helper as every
+# explicit E2E probe. The helper itself runs with the original PATH, preventing
+# recursion into this shim.
+cat > "$FAKEBIN/herdr" <<EOF
+#!/usr/bin/env bash
+set -euo pipefail
+helper='$LAB_HELPER'
+session='$SESSION'
+real_path='$ORIGINAL_PATH'
+args=("\$@")
+n=\${#args[@]}
+if [ "\$n" -ge 2 ] && [ "\${args[\$((n-2))]}" = --session ]; then
+  [ "\${args[\$((n-1))]}" = "\$session" ] || { echo "wrapper refused foreign session" >&2; exit 97; }
+  args=("\${args[@]:0:\$((n-2))}")
+else
+  [ "\${HERDR_SESSION:-}" = "\$session" ] || { echo "wrapper requires the isolated lab session" >&2; exit 98; }
+  for arg in "\${args[@]}"; do
+    case "\$arg" in
+      --session|--session=*) echo "wrapper refused non-trailing session flag" >&2; exit 99 ;;
+    esac
+  done
+fi
+PATH="\$real_path" exec "\$helper" run "\$session" "\${args[@]}"
+EOF
+chmod +x "$FAKEBIN/herdr"
+
+git clone -q --no-hardlinks "$ROOT" "$SECOND_HOME"
+git -C "$SECOND_HOME" checkout -q --detach HEAD
+mkdir -p "$SECOND_HOME/state" "$SECOND_HOME/data" "$SECOND_HOME/config" "$SECOND_HOME/projects"
+printf '%s\n' "$ID" > "$SECOND_HOME/.fm-secondmate-home"
+cat > "$SECOND_HOME/data/charter.md" <<'EOF'
+# Isolated marker capture secondmate
+
+You are a task-local secondmate used only for the marker transport regression.
+Stay idle and do not initiate work.
+EOF
+
+# A separate explicit Pi extension grants session-only project trust, records
+# before_agent_start prompt bytes, and aborts before any provider request.
+# The PATH wrapper adds only that test resource while preserving the production
+# secondmate launch and its own extension arguments unchanged.
+CAPTURE_JSON=$(printf '%s' "$CAPTURE" | jq -Rs .)
+CAPTURE_EXTENSION="$TMP_ROOT/fm-send-marker-capture.ts"
+cat > "$CAPTURE_EXTENSION" <<EOF
+import { appendFileSync } from "node:fs";
+const capturePath = $CAPTURE_JSON;
+export default function (pi: any) {
+  pi.on("project_trust", () => ({ trusted: "yes", remember: false }));
+  pi.on("before_agent_start", (event, ctx) => {
+    appendFileSync(capturePath, \`\${JSON.stringify({ prompt: event.prompt, hex: Buffer.from(event.prompt, "utf8").toString("hex") })}\\n\`);
+    ctx.abort();
+  });
+}
+EOF
+printf '#!/usr/bin/env bash\nexec %q -e %q "$@"\n' "$REAL_PI" "$CAPTURE_EXTENSION" > "$FAKEBIN/pi"
+chmod +x "$FAKEBIN/pi"
+
+"$LAB_HELPER" provision "$SESSION"
+PATH="$FAKEBIN:$ORIGINAL_PATH" FM_GATE_REFUSE_BYPASS=1 FM_HOME="$SENDER_HOME" HERDR_SESSION="$SESSION" \
+  "$ROOT/bin/fm-spawn.sh" "$ID" "$SECOND_HOME" --secondmate --harness pi --backend herdr >/dev/null
+
+META="$SENDER_HOME/state/$ID.meta"
+[ -f "$META" ] || fail "real secondmate spawn did not write exact-id metadata"
+[ "$(fm_meta_get "$META" kind)" = secondmate ] || fail "real secondmate metadata did not record kind=secondmate"
+TARGET=$(fm_backend_target_of_meta "$META")
+PANE=${TARGET#*:}
+case "$TARGET" in
+  "$SESSION":w*:p*) : ;;
+  *) fail "real secondmate metadata recorded an unexpected Herdr target: $TARGET" ;;
+esac
+
+wait_for_prompt() { # <needle>
+  local needle=$1 _
+  for _ in $(seq 1 240); do
+    if [ -s "$CAPTURE" ] && jq -e --arg needle "$needle" 'select(.prompt | contains($needle))' "$CAPTURE" >/dev/null 2>&1; then
+      return 0
+    fi
+    sleep 0.25
+  done
+  return 1
+}
+
+wait_for_idle() {
+  local status _ stable=0
+  for _ in $(seq 1 240); do
+    status=$("$LAB_HELPER" run "$SESSION" agent get "$PANE" 2>/dev/null \
+      | jq -r '.result.agent.agent_status // empty' 2>/dev/null || true)
+    case "$status" in
+      idle|done)
+        stable=$((stable + 1))
+        [ "$stable" -ge 4 ] && return 0
+        ;;
+      *) stable=0 ;;
+    esac
+    sleep 0.25
+  done
+  return 1
+}
+
+# The startup charter proves the CLI extension loaded. Wait until ctx.abort()
+# has remained idle long enough for the Pi composer to fully settle before
+# exercising it. A single native idle sample can precede Pi's final redraw.
+wait_for_prompt 'Isolated marker capture secondmate' \
+  || fail "real Pi before_agent_start capture did not load for the startup charter"
+wait_for_idle || fail "real Pi did not become idle after the startup capture"
+
+PATH="$FAKEBIN:$ORIGINAL_PATH" FM_GATE_REFUSE_BYPASS=1 FM_HOME="$SENDER_HOME" \
+  "$ROOT/bin/fm-send.sh" "$ID" "$REQUEST" >/dev/null
+wait_for_prompt "$REQUEST" || fail "real Pi did not receive the exact-id fm-send request"
+GOT=$(jq -r --arg needle "$REQUEST" 'select(.prompt | contains($needle)) | .prompt' "$CAPTURE" | tail -1)
+[ "$GOT" = "${FM_FROMFIRST_MARK}${REQUEST}" ] \
+  || fail "real Pi exact-id prompt did not contain exactly one terminal-safe marker"$'\n'"--- bytes ---"$'\n'"$(printf '%s' "$GOT" | od -An -tx1)"
+printf 'evidence: exact-id received-hex=%s\n' "$(printf '%s' "$GOT" | od -An -tx1 | tr -d ' \n')"
+pass "real Pi/Herdr: exact-id FM_HOME send delivers exactly one from-firstmate marker"
+wait_for_idle || fail "real Pi did not become idle after the exact-id capture"
+
+# Direct terminal input bypasses fm-send's metadata-routed transformation and
+# therefore remains conversational captain input.
+"$LAB_HELPER" run "$SESSION" pane send-text "$PANE" "$DIRECT" >/dev/null
+"$LAB_HELPER" run "$SESSION" pane send-keys "$PANE" enter >/dev/null
+wait_for_prompt "$DIRECT" || fail "real Pi did not receive direct terminal input"
+GOT=$(jq -r --arg needle "$DIRECT" 'select(.prompt | contains($needle)) | .prompt' "$CAPTURE" | tail -1)
+[ "$GOT" = "$DIRECT" ] || fail "direct captain input was changed or marked"$'\n'"--- bytes ---"$'\n'"$(printf '%s' "$GOT" | od -An -tx1)"
+if fm_message_from_firstmate "$GOT"; then
+  fail "direct captain input was classified as from-firstmate"
+fi
+printf 'evidence: direct-input received-hex=%s\n' "$(printf '%s' "$GOT" | od -An -tx1 | tr -d ' \n')"
+pass "real Pi/Herdr: direct captain terminal input stays unmarked"

package/.agents/tests/fm-send-secondmate-marker.test.sh

@@ -0,0 +1,278 @@
+#!/usr/bin/env bash
+# fm-send from-firstmate marker for secondmate targets.
+#
+# A secondmate is itself a firstmate, so a request relayed to it lands in its own
+# chat - which the main firstmate never reads (the only channel back is the terse
+# status file). fm-send therefore prepends a from-firstmate marker
+# (bin/fm-marker-lib.sh) when, and only when, the resolved target is a task
+# selector whose meta records kind=secondmate, so the secondmate can recognize
+# the request and route its reply via the status path. The marker now travels
+# inside the durable inbox record's body (the payload is never typed; only the
+# doorbell is). These tests pin that behavior hermetically (stubbed tmux, no
+# real agent):
+#   1. Exact-id and stable-label kind=secondmate selectors prepend the marker
+#      to the recorded steer, never to the typed doorbell.
+#   2. Exact-id and stable-label ordinary crewmate selectors stay unmarked.
+#   3. Explicit endpoints stay unmarked and typed, with or without local meta.
+#   4. The --key path never carries the marker and never enqueues a record.
+#   5. Direct captain text stays unmarked, and already-marked text is idempotent.
+#   6. The marker is the label plus terminal-safe U+2063 INVISIBLE SEPARATOR.
+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-marker)
+
+# A fake tmux that (a) records the literal text of every `send-keys -l` to
+# FM_SEND_LOG and (b) lets fm-send's submit path reach a clean "empty" verdict.
+# display-message yields a numeric cursor_y; capture-pane returns an empty
+# bordered composer so fm_tmux_composer_state reads "empty" (submit landed) on the
+# first Enter. Only the literal (-l) text is logged; Enter retries and --key sends
+# are not, so the log holds exactly what was typed into the composer.
+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)
+    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' "${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) printf '╭────╮\n│    │\n╰────╯\n'; 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"
+}
+
+# run_send <fakebin> <home> <send-log> -- <fm-send args...>
+# Runs fm-send.sh with the stubs on PATH against the given home (which holds
+# state/<id>.meta). FM_ROOT_OVERRIDE points at the same non-repo home so
+# fm-guard's tangle check stays silent; guard noise goes to stderr (discarded).
+# FM_SEND_SETTLE=0 keeps the run fast. Truncates the log first; returns fm-send's
+# exit code.
+run_send() {
+  local fb=$1 home=$2 log=$3; shift 3
+  : > "$log"
+  env PATH="$fb:$PATH" \
+    FM_ROOT_OVERRIDE="$home" FM_HOME="$home" FM_SEND_LOG="$log" FM_SEND_SETTLE=0 \
+    "$SEND" "$@" 2>/dev/null
+}
+
+# setup_home <name> -> echoes a fresh home dir with an empty state/.
+setup_home() {
+  local home="$TMP_ROOT/$1-$RANDOM"
+  mkdir -p "$home/state"
+  printf '%s\n' "$home"
+}
+
+# The exact enqueued text of one inbox record, read through the production
+# owner (bin/fm-task-inbox-lib.sh). Command substitution strips trailing
+# newlines, so byte-exact trailing assertions read the raw record instead.
+record_body() {  # <record-path>
+  bash -c '. "$1"; fm_task_inbox_body "$2"' _ "$ROOT/bin/fm-task-inbox-lib.sh" "$1"
+}
+
+test_secondmate_target_is_marked() {
+  local dir fb log home rc got corr
+  dir="$TMP_ROOT/sm"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); log="$dir/send.log"
+  home=$(setup_home sm)
+  fm_write_secondmate_meta "$home/state/domain.meta" "$home" "sess:fm-domain"
+  run_send "$fb" "$home" "$log" "fm-domain" "audit the build"; rc=$?
+  expect_code 0 "$rc" "send to a secondmate target should succeed"
+  got=$(record_body "$home/state/domain.inbox/001.msg")
+  case "$got" in
+    "$FM_FROMFIRST_MARK"corr=[a-f0-9][a-f0-9]*) : ;;
+    *) fail "secondmate send: the recorded steer should be marker+corr+text"$'\n'"--- bytes ---"$'\n'"$(printf '%s' "$got" | od -An -c)" ;;
+  esac
+  case "$got" in
+    *audit\ the\ build) : ;;
+    *) fail "secondmate send lost the request body"$'\n'"$got" ;;
+  esac
+  case "$(cat "$log")" in
+    *"$FM_FROMFIRST_MARK"*) fail "the marker must ride the record, never the typed doorbell" ;;
+  esac
+  # shellcheck source=/dev/null
+  . "$ROOT/bin/fm-pending-reply-lib.sh"
+  corr=$(fm_pending_reply_extract_corr "$got")
+  [ -f "$(fm_pending_reply_path "$home/state" "$corr")" ] \
+    || fail "marked secondmate send should create a parent pending-reply record"
+  pass "fm-send: a kind=secondmate target gets the from-firstmate marker and corr prepended"
+}
+
+test_exact_secondmate_task_id_is_marked() {
+  local dir fb log home rc got already_marked corr
+  dir="$TMP_ROOT/sm-exact"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); log="$dir/send.log"
+  home=$(setup_home sm-exact)
+  fm_write_secondmate_meta "$home/state/domain.meta" "$home" "sess:fm-domain"
+  run_send "$fb" "$home" "$log" "domain" "audit the build"; rc=$?
+  expect_code 0 "$rc" "send to an exact secondmate task id should succeed"
+  got=$(record_body "$home/state/domain.inbox/001.msg")
+  case "$got" in
+    "$FM_FROMFIRST_MARK"corr=[a-f0-9]*) : ;;
+    *) fail "exact secondmate send: the recorded steer should be marker+corr+text"$'\n'"--- bytes ---"$'\n'"$(printf '%s' "$got" | od -An -c)" ;;
+  esac
+  # shellcheck source=/dev/null
+  . "$ROOT/bin/fm-pending-reply-lib.sh"
+  corr=$(fm_pending_reply_extract_corr "$got")
+  # Resend with the same corr already present: embed is idempotent for that corr.
+  already_marked="${FM_FROMFIRST_MARK}corr=${corr} already routed"
+  run_send "$fb" "$home" "$log" "domain" "$already_marked"; rc=$?
+  expect_code 0 "$rc" "send of already-marked exact-id content should succeed"
+  got=$(record_body "$home/state/domain.inbox/002.msg")
+  case "$got" in
+    "${FM_FROMFIRST_MARK}corr=${corr} already routed") : ;;
+    *) fail "exact secondmate send altered already-correlated content"$'\n'"--- bytes ---"$'\n'"$(printf '%s' "$got" | od -An -tx1)" ;;
+  esac
+  pass "fm-send: an exact kind=secondmate task id is marked with corr exactly once"
+}
+
+test_crewmate_target_is_not_marked() {
+  local dir fb log home rc got
+  dir="$TMP_ROOT/crew"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); log="$dir/send.log"
+  home=$(setup_home crew)
+  fm_write_meta "$home/state/build.meta" \
+    "window=sess:fm-build" "worktree=$home/wt" "project=$home/p" \
+    "harness=echo" "kind=ship" "mode=no-mistakes" "yolo=off"
+  run_send "$fb" "$home" "$log" "fm-build" "fix the test"; rc=$?
+  expect_code 0 "$rc" "send to a stable-label crewmate target should succeed"
+  got=$(record_body "$home/state/build.inbox/001.msg")
+  [ "$got" = "fix the test" ] \
+    || fail "stable-label crewmate send: expected bare recorded text, got marker or other"$'\n'"--- bytes ---"$'\n'"$(printf '%s' "$got" | od -An -c)"
+  run_send "$fb" "$home" "$log" "build" "fix the exact test"; rc=$?
+  expect_code 0 "$rc" "send to an exact-id crewmate target should succeed"
+  got=$(record_body "$home/state/build.inbox/002.msg")
+  [ "$got" = "fix the exact test" ] \
+    || fail "exact-id crewmate send: expected bare recorded text, got marker or other"$'\n'"--- bytes ---"$'\n'"$(printf '%s' "$got" | od -An -c)"
+  pass "fm-send: exact-id and stable-label kind=ship selectors are sent unmarked"
+}
+
+test_explicit_window_is_not_marked() {
+  local dir fb log home rc got
+  dir="$TMP_ROOT/explicit"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); log="$dir/send.log"
+  home=$(setup_home explicit)
+  # An explicit endpoint is not a task selector, so even matching secondmate
+  # metadata must not make fm-send guess the caller's intent and mark it.
+  fm_write_secondmate_meta "$home/state/win.meta" "$home" "other:win"
+  run_send "$fb" "$home" "$log" "other:win" "ping"; rc=$?
+  expect_code 0 "$rc" "send to an explicit window with matching meta should succeed"
+  got=$(cat "$log")
+  [ "$got" = "ping" ] \
+    || fail "explicit session:window send with meta: expected bare text, got marker"$'\n'"--- bytes ---"$'\n'"$(printf '%s' "$got" | od -An -c)"
+
+  home=$(setup_home explicit-no-meta)
+  run_send "$fb" "$home" "$log" "outside:window" "outside ping"; rc=$?
+  expect_code 0 "$rc" "send to an explicit window with no local meta should succeed"
+  got=$(cat "$log")
+  [ "$got" = "outside ping" ] \
+    || fail "explicit session:window send without meta: expected bare text, got marker"$'\n'"--- bytes ---"$'\n'"$(printf '%s' "$got" | od -An -c)"
+  pass "fm-send: explicit endpoints stay unmarked with or without local metadata"
+}
+
+test_key_path_is_not_marked() {
+  local dir fb log home rc
+  dir="$TMP_ROOT/key"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); log="$dir/send.log"
+  home=$(setup_home key)
+  fm_write_secondmate_meta "$home/state/domain.meta" "$home" "sess:fm-domain"
+  run_send "$fb" "$home" "$log" "fm-domain" --key Escape; rc=$?
+  expect_code 0 "$rc" "--key send to a secondmate should succeed"
+  [ ! -s "$log" ] \
+    || fail "--key path logged a literal send (marker leaked into a keypress)"$'\n'"--- bytes ---"$'\n'"$(od -An -c "$log")"
+  [ ! -d "$home/state/domain.inbox" ] \
+    || fail "--key path must never enqueue an inbox record"
+  pass "fm-send: the --key path carries no marker (no literal text is typed)"
+}
+
+test_marker_is_label_plus_invisible_separator() {
+  local separator hex
+  separator=$(printf '\342\201\243')
+  [ "$FM_FROMFIRST_MARK" = "[fm-from-firstmate]$separator" ] \
+    || fail "marker is not the expected label + U+2063 sequence"$'\n'"--- bytes ---"$'\n'"$(printf '%s' "$FM_FROMFIRST_MARK" | od -An -tx1)"
+  hex=$(printf '%s' "$FM_FROMFIRST_MARK" | od -An -tx1 | tr -d ' \n')
+  case "$hex" in
+    *e281a3) : ;;
+    *) fail "marker does not end in UTF-8 U+2063 bytes e2 81 a3; bytes were: $hex" ;;
+  esac
+  fm_message_from_firstmate "${FM_FROMFIRST_MARK}do the work" \
+    || fail "detector should recognize a marked message"
+  fm_message_from_firstmate "do the work" \
+    && fail "direct captain input must remain unmarked"
+  fm_message_from_firstmate "[fm-from-firstmate]do the work" \
+    && fail "detector must reject the label without U+2063"
+  pass "fm-send: the marker is '[fm-from-firstmate]' + terminal-safe U+2063, while direct captain text stays unmarked"
+}
+
+test_marker_transformation_is_idempotent() {
+  local once twice
+  fm_message_mark_from_firstmate "do the work" once
+  fm_message_mark_from_firstmate "$once" twice
+  [ "$once" = "$twice" ] \
+    || fail "already-marked content was double-prefixed"$'\n'"--- once ---"$'\n'"$(printf '%s' "$once" | od -An -tx1)"$'\n'"--- twice ---"$'\n'"$(printf '%s' "$twice" | od -An -tx1)"
+  [ "$once" = "${FM_FROMFIRST_MARK}do the work" ] \
+    || fail "marker transformation did not prefix bare content exactly once"
+  pass "fm-marker: from-firstmate transformation is idempotent"
+}
+
+test_marked_send_preserves_trailing_newlines() {
+  local dir fb log home rc payload corr expected actual expected_message
+  dir="$TMP_ROOT/sm-trailing-newlines"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); log="$dir/send.log"
+  home=$(setup_home sm-trailing-newlines)
+  fm_write_secondmate_meta "$home/state/domain.meta" "$home" "sess:fm-domain"
+  payload=$'audit the build\n\n'
+  run_send "$fb" "$home" "$log" "domain" "$payload"; rc=$?
+  expect_code 0 "$rc" "marked send with trailing newlines should succeed"
+  # shellcheck source=/dev/null
+  . "$ROOT/bin/fm-pending-reply-lib.sh"
+  corr=$(fm_pending_reply_extract_corr "$(record_body "$home/state/domain.inbox/001.msg")")
+  [ -n "$corr" ] || fail "marked send should embed a corr id"
+  fm_pending_reply_embed_corr "$payload" "$corr" expected_message
+  expected="$dir/expected.body"
+  actual="$dir/actual.body"
+  printf '%s' "$expected_message" > "$expected"
+  record_body "$home/state/domain.inbox/001.msg" > "$actual"
+  cmp -s "$expected" "$actual" \
+    || fail "the marked record did not preserve trailing newline bytes exactly"
+  pass "fm-send: marked secondmate payload preserves trailing newline bytes in its record"
+}
+
+test_secondmate_target_is_marked
+test_exact_secondmate_task_id_is_marked
+test_crewmate_target_is_not_marked
+test_explicit_window_is_not_marked
+test_key_path_is_not_marked
+test_marker_is_label_plus_invisible_separator
+test_marker_transformation_is_idempotent
+test_marked_send_preserves_trailing_newlines

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

@@ -0,0 +1,147 @@
+#!/usr/bin/env bash
+# fm-send typed-plane post-submit settle pause (FM_SEND_SETTLE).
+#
+# A typed-plane fm-send success only proves the composer cleared - the Enter
+# landed and the text was submitted. The harness then takes a beat to spin up the
+# turn before its busy footer appears, so an immediate peek after fm-send returns
+# would see the stale idle pane. fm-send therefore pauses FM_SEND_SETTLE seconds
+# (default 1, 0 disables) after a successful typed submit, so the receiving turn
+# has time to visibly start. These tests use an explicit backend target to stay on
+# that plane and pin the behavior hermetically (stubbed tmux + sleep, no real
+# agent):
+#   1. A successful typed text send pauses for the FM_SEND_SETTLE value (default 1).
+#   2. FM_SEND_SETTLE=0 produces no pause at all (sleep is never invoked for it).
+#   3. The pause is tunable (FM_SEND_SETTLE=7 pauses 7).
+#   4. The --key path never pauses (it bypasses the submit/settle path entirely).
+set -u
+
+# shellcheck source=tests/lib.sh
+. "$(dirname "${BASH_SOURCE[0]}")/lib.sh"
+# shellcheck source=/dev/null
+. "$ROOT/bin/fm-busy-lib.sh"
+
+SEND="$ROOT/bin/fm-send.sh"
+
+TMP_ROOT=$(fm_test_tmproot fm-send-settle)
+
+# A fake tmux that lets fm-send's submit path reach a clean "empty" verdict, plus a
+# fake sleep that records every requested duration (one per line) instead of
+# sleeping. send-keys always succeeds; display-message yields a numeric cursor_y;
+# capture-pane returns an empty bordered composer so fm_tmux_composer_state reads
+# "empty" (submit landed) on the first Enter. The sleep log path comes from
+# FM_SLEEP_LOG.
+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) 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) printf '╭────╮\n│    │\n╰────╯\n'; exit 0 ;;
+  list-windows) exit 0 ;;
+esac
+exit 0
+SH
+  chmod +x "$fb/tmux"
+  cat > "$fb/sleep" <<'SH'
+#!/usr/bin/env bash
+printf '%s\n' "${1:-}" >> "$FM_SLEEP_LOG"
+exit 0
+SH
+  chmod +x "$fb/sleep"
+  printf '%s\n' "$fb"
+}
+
+# run_send <fakebin> <sleep-log> [env-assignments...] -- <fm-send args...>
+# Runs fm-send.sh with the stubs on PATH. FM_ROOT_OVERRIDE points at a non-repo
+# temp dir so fm-guard's tangle check stays silent, and FM_HOME at an empty home so
+# no in-flight task is seen; guard noise goes to stderr (discarded). Echoes nothing;
+# returns fm-send's exit code.
+run_send() {
+  local fb=$1 log=$2 home; shift 2
+  home="$TMP_ROOT/home-$RANDOM"; mkdir -p "$home/state"
+  : > "$log"
+  env "$@" PATH="$fb:$PATH" \
+    FM_ROOT_OVERRIDE="$home" FM_HOME="$home" FM_SLEEP_LOG="$log" \
+    "$SEND" "sess:win" "hello captain" 2>/dev/null
+}
+
+test_default_send_pauses_one_second() {
+  local dir fb log rc last
+  dir="$TMP_ROOT/default"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); log="$dir/sleep.log"
+  run_send "$fb" "$log"; rc=$?
+  expect_code 0 "$rc" "default send should succeed"
+  last=$(tail -1 "$log")
+  [ "$last" = 1 ] || fail "default send: expected a trailing 1s settle pause, got '$last'"$'\n'"--- sleeps ---"$'\n'"$(cat "$log")"
+  pass "fm-send: a successful text send pauses the default 1s after submit"
+}
+
+test_zero_disables_pause() {
+  local dir fb log rc
+  dir="$TMP_ROOT/zero"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); log="$dir/sleep.log"
+  run_send "$fb" "$log" FM_SEND_SETTLE=0; rc=$?
+  expect_code 0 "$rc" "FM_SEND_SETTLE=0 send should succeed"
+  # The disable path must not invoke sleep with 0 at all - the only sleeps left are
+  # the submit core's own settle/enter waits, none of which is "0".
+  if grep -qx '0' "$log"; then
+    fail "FM_SEND_SETTLE=0 still paused (a sleep 0 was recorded)"$'\n'"--- sleeps ---"$'\n'"$(cat "$log")"
+  fi
+  pass "fm-send: FM_SEND_SETTLE=0 produces no settle pause"
+}
+
+test_pause_is_tunable() {
+  local dir fb log rc last
+  dir="$TMP_ROOT/tunable"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); log="$dir/sleep.log"
+  run_send "$fb" "$log" FM_SEND_SETTLE=7; rc=$?
+  expect_code 0 "$rc" "FM_SEND_SETTLE=7 send should succeed"
+  last=$(tail -1 "$log")
+  [ "$last" = 7 ] || fail "FM_SEND_SETTLE=7: expected a trailing 7s settle pause, got '$last'"$'\n'"--- sleeps ---"$'\n'"$(cat "$log")"
+  pass "fm-send: the settle pause is tunable via FM_SEND_SETTLE"
+}
+
+test_key_path_never_pauses() {
+  local dir fb log rc home
+  dir="$TMP_ROOT/key"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); log="$dir/sleep.log"
+  home="$dir/home"; mkdir -p "$home/state"
+  : > "$log"
+  env PATH="$fb:$PATH" FM_ROOT_OVERRIDE="$home" FM_HOME="$home" FM_SLEEP_LOG="$log" \
+    "$SEND" "sess:win" --key Escape 2>/dev/null; rc=$?
+  expect_code 0 "$rc" "--key send should succeed"
+  [ ! -s "$log" ] || fail "--key path paused but must not"$'\n'"--- sleeps ---"$'\n'"$(cat "$log")"
+  pass "fm-send: the --key path never pauses (settle scoped to text submit)"
+}
+
+test_claude_escape_records_interrupt_idle() {
+  local dir fb log rc home gen out
+  dir="$TMP_ROOT/claude-interrupt"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); log="$dir/sleep.log"
+  home="$dir/home"; mkdir -p "$home/state"
+  fm_write_meta "$home/state/task.meta" \
+    "window=sess:win" "worktree=$home/wt" "project=$home/project" \
+    "harness=claude" "kind=ship" "mode=no-mistakes" "yolo=off"
+  gen=$("$ROOT/bin/fm-busy-event.sh" arm "$home/state" task)
+  printf 'busy_gen=%s\n' "$gen" >> "$home/state/task.meta"
+  : > "$log"
+
+  env PATH="$fb:$PATH" FM_HOME="$home" FM_SLEEP_LOG="$log" \
+    "$SEND" task --key Escape 2>/dev/null; rc=$?
+  expect_code 0 "$rc" "Claude Escape send should succeed"
+  out=$(fm_busy_classify tmux sess:win claude task "$home/state")
+  [ "$out" = "idle fm-interrupt" ] \
+    || fail "Claude Escape must classify idle/fm-interrupt, got '$out'"
+  pass "fm-send: a successful Claude Escape records the interrupt lifecycle edge"
+}
+
+test_default_send_pauses_one_second
+test_zero_disables_pause
+test_pause_is_tunable
+test_key_path_never_pauses
+test_claude_escape_records_interrupt_idle