@zerwiz/ymir 0.1.3 → 0.1.5

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

@@ -0,0 +1,241 @@
+#!/usr/bin/env bash
+# fm-send strict target resolution and key delivery reporting.
+#
+# A send that cannot be tied to a recorded task/lane or to an explicit
+# well-formed backend target must fail loudly. These tests pin the historical
+# silent-fallback failures: missing FM_HOME, unresolved selectors, prefixless
+# herdr pane ids, dead explicit endpoints, and the healthy exact/fm-id paths.
+# They also verify that a key send reports whether delivery actually succeeded.
+set -u
+
+# shellcheck source=tests/lib.sh
+. "$(dirname "${BASH_SOURCE[0]}")/lib.sh"
+
+SEND="$ROOT/bin/fm-send.sh"
+TMP_ROOT=$(fm_test_tmproot fm-send-strict)
+
+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
+    target=
+    while [ $# -gt 0 ]; do
+      case "$1" in
+        -t) target=$2; shift 2 ;;
+        -l) literal=1; shift ;;
+        *) break ;;
+      esac
+    done
+    printf 'send-keys target=%s literal=%s arg=%s\n' "$target" "$literal" "${1:-}" >> "$FM_TMUX_LOG"
+    # FM_FAKE_TMUX_SEND_KEY_FAIL names one key whose delivery fails, so the
+    # --key exit contract can be driven both ways from the same stub.
+    if [ "$literal" = 0 ] && [ -n "${FM_FAKE_TMUX_SEND_KEY_FAIL:-}" ] \
+      && [ "${1:-}" = "$FM_FAKE_TMUX_SEND_KEY_FAIL" ]; then
+      exit 1
+    fi
+    exit 0 ;;
+  display-message)
+    target=
+    cursor=0
+    while [ $# -gt 0 ]; do
+      case "$1" in
+        -t) target=$2; shift 2 ;;
+        *cursor_y*) cursor=1; shift ;;
+        *) shift ;;
+      esac
+    done
+    if [ -n "${FM_FAKE_TMUX_DEAD_TARGET:-}" ] && [ "$target" = "$FM_FAKE_TMUX_DEAD_TARGET" ]; then
+      exit 1
+    fi
+    [ "$cursor" = 1 ] && { printf '1\n'; exit 0; }
+    printf '%%1\n'
+    exit 0 ;;
+  capture-pane)
+    printf '╭────╮\n│    │\n╰────╯\n'
+    exit 0 ;;
+  list-windows)
+    printf 'foreign:%s\n' "${FM_FAKE_TMUX_WINDOW:-fm-lost}"
+    exit 0 ;;
+esac
+exit 0
+SH
+  chmod +x "$fb/tmux"
+  cat > "$fb/herdr" <<'SH'
+#!/usr/bin/env bash
+set -u
+printf '%s\n' "$*" >> "$FM_HERDR_LOG"
+case "${1:-} ${2:-}" in
+  "status --json") printf '{"client":{"version":"0.7.5","protocol":16},"server":{"running":true}}\n' ;;
+  "pane get") printf '{"result":{"pane":{"pane_id":"%s"}}}\n' "${3:-}" ;;
+  "pane send-keys") : ;;
+esac
+SH
+  chmod +x "$fb/herdr"
+  cat > "$fb/sleep" <<'SH'
+#!/usr/bin/env bash
+exit 0
+SH
+  chmod +x "$fb/sleep"
+  printf '%s\n' "$fb"
+}
+
+setup_home() {  # <name> -> echoes home dir
+  local home="$TMP_ROOT/$1-$RANDOM"
+  mkdir -p "$home/state"
+  printf '%s\n' "$home"
+}
+
+test_exact_lane_id_send_still_works() {
+  local dir fb home err log rc got
+  dir="$TMP_ROOT/exact"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); home=$(setup_home exact); err="$dir/send.err"; log="$dir/tmux.log"; : > "$log"
+  fm_write_meta "$home/state/mpf-lane-m8.meta" "window=sess:fm-mpf-lane-m8" "kind=ship"
+
+  PATH="$fb:$PATH" FM_HOME="$home" FM_ROOT_OVERRIDE="$home" FM_TMUX_LOG="$log" FM_SEND_SETTLE=0 \
+    "$SEND" mpf-lane-m8 "lost dispatch" >/dev/null 2>"$err"; rc=$?
+  expect_code 0 "$rc" "exact task id send should succeed when metadata exists"
+  got=$(cat "$log")
+  assert_contains "$got" "target=sess:fm-mpf-lane-m8 literal=1 arg=Firstmate instruction waiting" \
+    "exact id should ring the doorbell at the meta target"
+  assert_contains "$got" "target=sess:fm-mpf-lane-m8 literal=0 arg=Enter" "exact id should submit the doorbell with Enter"
+  grep -qF 'lost dispatch' "$home/state/mpf-lane-m8.inbox/001.msg" \
+    || fail "exact id should record the steer in the task inbox"
+  pass "fm-send strict: exact task/lane ids resolve through home metadata"
+}
+
+test_unset_fm_home_fails() {
+  local dir fb err log rc
+  dir="$TMP_ROOT/nohome"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); err="$dir/send.err"; log="$dir/tmux.log"; : > "$log"
+
+  env -u FM_HOME PATH="$fb:$PATH" FM_ROOT_OVERRIDE="$dir" FM_TMUX_LOG="$log" FM_SEND_SETTLE=0 \
+    "$SEND" sess:win "hello" >/dev/null 2>"$err"; rc=$?
+  [ "$rc" -ne 0 ] || fail "unset FM_HOME should fail"
+  assert_contains "$(cat "$err")" "FM_HOME is not set" "unset FM_HOME diagnostic should be explicit"
+  [ ! -s "$log" ] || fail "unset FM_HOME still attempted a send"$'\n'"$(cat "$log")"
+  pass "fm-send strict: unset FM_HOME fails before target resolution"
+}
+
+test_unresolvable_target_does_not_tmux_fallback() {
+  local dir fb home err log rc
+  dir="$TMP_ROOT/unresolved"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); home=$(setup_home unresolved); err="$dir/send.err"; log="$dir/tmux.log"; : > "$log"
+
+  PATH="$fb:$PATH" FM_HOME="$home" FM_ROOT_OVERRIDE="$home" FM_TMUX_LOG="$log" FM_FAKE_TMUX_WINDOW=lost-target FM_SEND_SETTLE=0 \
+    "$SEND" lost-target "hello" >/dev/null 2>"$err"; rc=$?
+  [ "$rc" -ne 0 ] || fail "unresolvable target should fail"
+  assert_contains "$(cat "$err")" "not resolvable" "unresolvable diagnostic should be loud"
+  assert_contains "$(cat "$err")" "metadata window/terminal lookup" "unresolvable diagnostic should name the attempted lookup"
+  assert_contains "$(cat "$err")" "backend=none" "unresolvable diagnostic should name that no backend was assumed"
+  [ ! -s "$log" ] || fail "unresolvable target fell through to tmux send"$'\n'"$(cat "$log")"
+  pass "fm-send strict: unresolvable selectors do not fall back to tmux"
+}
+
+test_prefixless_herdr_pane_id_fails() {
+  local dir fb home err log rc
+  dir="$TMP_ROOT/herdr-pane"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); home=$(setup_home herdr); err="$dir/send.err"; log="$dir/tmux.log"; : > "$log"
+  fm_write_meta "$home/state/nudge.meta" \
+    "window=default:wB:p2" "backend=herdr" "herdr_session=default" "herdr_pane_id=wB:p2" "kind=ship"
+
+  PATH="$fb:$PATH" FM_HOME="$home" FM_ROOT_OVERRIDE="$home" FM_TMUX_LOG="$log" FM_SEND_SETTLE=0 \
+    "$SEND" wB:p2 "nudge" >/dev/null 2>"$err"; rc=$?
+  [ "$rc" -ne 0 ] || fail "prefixless herdr pane id should fail"
+  assert_contains "$(cat "$err")" "matches herdr_pane_id" "herdr pane diagnostic should name the meta match"
+  assert_contains "$(cat "$err")" "expected <herdr-session>:<pane-id>" "herdr pane diagnostic should show expected shape"
+  assert_contains "$(cat "$err")" "default:wB:p2" "herdr pane diagnostic should show the canonical target"
+  [ ! -s "$log" ] || fail "prefixless herdr pane id fell through to tmux send"$'\n'"$(cat "$log")"
+  pass "fm-send strict: prefixless herdr pane ids are rejected before tmux fallback"
+}
+
+test_unmatched_single_colon_target_must_exist() {
+  local dir fb home err log rc
+  dir="$TMP_ROOT/dead-explicit"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); home=$(setup_home deadexplicit); err="$dir/send.err"; log="$dir/tmux.log"; : > "$log"
+
+  PATH="$fb:$PATH" FM_HOME="$home" FM_ROOT_OVERRIDE="$home" FM_TMUX_LOG="$log" FM_FAKE_TMUX_DEAD_TARGET=sess:missing FM_SEND_SETTLE=0 \
+    "$SEND" sess:missing "hello" >/dev/null 2>"$err"; rc=$?
+  [ "$rc" -ne 0 ] || fail "dead explicit tmux-shaped target should fail"
+  assert_contains "$(cat "$err")" "not a live tmux endpoint" "dead explicit target diagnostic should name the assumed backend"
+  assert_contains "$(cat "$err")" "backend=tmux" "dead explicit target diagnostic should name the tried backend"
+  [ ! -s "$log" ] || fail "dead explicit target still attempted a send"$'\n'"$(cat "$log")"
+  pass "fm-send strict: unmatched single-colon explicit targets must verify live before sending"
+}
+
+test_fm_prefixed_herdr_session_is_an_explicit_target() {
+  local dir fb home err log herdr_log rc
+  dir="$TMP_ROOT/fm-remote-explicit"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); home=$(setup_home fmremote); err="$dir/send.err"; log="$dir/tmux.log"; herdr_log="$dir/herdr.log"
+  : > "$log"
+  : > "$herdr_log"
+
+  PATH="$fb:$PATH" FM_HOME="$home" FM_ROOT_OVERRIDE="$home" FM_TMUX_LOG="$log" FM_HERDR_LOG="$herdr_log" FM_SEND_SETTLE=0 \
+    "$SEND" fm-remote:w1:p2 --key Enter >/dev/null 2>"$err"; rc=$?
+  expect_code 0 "$rc" "an fm-prefixed Herdr session target should be accepted as explicit"
+  assert_grep 'pane get w1:p2 --session fm-remote' "$herdr_log" "fm-prefixed Herdr target was not verified in its session"
+  assert_grep 'pane send-keys w1:p2 enter --session fm-remote' "$herdr_log" "fm-prefixed Herdr target was not sent its key in its session"
+  assert_no_grep '--session default' "$herdr_log" "fm-prefixed Herdr target fell back to the default session"
+  pass "fm-send strict: fm-prefixed Herdr sessions remain explicit backend targets"
+}
+
+test_healthy_fm_id_send_still_works() {
+  local dir fb home err log rc got
+  dir="$TMP_ROOT/healthy"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); home=$(setup_home healthy); err="$dir/send.err"; log="$dir/tmux.log"; : > "$log"
+  fm_write_meta "$home/state/lane-ok.meta" "window=sess:fm-lane-ok" "kind=ship" "harness=codex"
+
+  PATH="$fb:$PATH" FM_HOME="$home" FM_ROOT_OVERRIDE="$home" FM_TMUX_LOG="$log" FM_SEND_SETTLE=0 \
+    "$SEND" fm-lane-ok "hello captain" >/dev/null 2>"$err"; rc=$?
+  expect_code 0 "$rc" "healthy fm-id send should succeed"
+  got=$(cat "$log")
+  assert_contains "$got" "target=sess:fm-lane-ok literal=1 arg=Firstmate instruction waiting" \
+    "healthy send should ring the doorbell at the meta target"
+  assert_contains "$got" "target=sess:fm-lane-ok literal=0 arg=Enter" "healthy send should submit the doorbell with Enter"
+  grep -qF 'hello captain' "$home/state/lane-ok.inbox/001.msg" \
+    || fail "healthy send should record the steer in the task inbox"
+  assert_contains "$(cat "$err")" "requested message WILL still be sent" "fm-send guard banner should keep send-specific continuation wording"
+  pass "fm-send strict: healthy fm-<id> sends record the steer and ring once"
+}
+
+# A --key send is how firstmate interrupts a worker, so its exit status is the
+# only signal that the interrupt actually landed.
+# Reporting success for a key that was never delivered would leave supervision
+# believing a runaway worker had been stopped, so the failing case must exit
+# nonzero and name the key.
+# Both directions are asserted from one stub so the failing case cannot go
+# quietly vacuous if the key ever stops being delivered at all.
+test_key_send_exit_status_follows_delivery() {
+  local dir fb home err log rc
+  dir="$TMP_ROOT/key-exit"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir"); home=$(setup_home keyexit); err="$dir/send.err"; log="$dir/tmux.log"; : > "$log"
+  fm_write_meta "$home/state/lane-key.meta" "window=sess:fm-lane-key" "kind=ship"
+
+  PATH="$fb:$PATH" FM_HOME="$home" FM_ROOT_OVERRIDE="$home" FM_TMUX_LOG="$log" FM_SEND_SETTLE=0 \
+    "$SEND" lane-key --key Escape >/dev/null 2>"$err"; rc=$?
+  expect_code 0 "$rc" "a delivered --key interrupt should report success"
+  assert_contains "$(cat "$log")" "target=sess:fm-lane-key literal=0 arg=Escape" "the delivered case should send the named key"
+
+  : > "$log"
+  PATH="$fb:$PATH" FM_HOME="$home" FM_ROOT_OVERRIDE="$home" FM_TMUX_LOG="$log" FM_SEND_SETTLE=0 \
+    FM_FAKE_TMUX_SEND_KEY_FAIL=Escape \
+    "$SEND" lane-key --key Escape >/dev/null 2>"$err"; rc=$?
+  [ "$rc" -ne 0 ] || fail "an undelivered --key interrupt reported success"
+  assert_contains "$(cat "$err")" "key 'Escape' not sent" "the undelivered case should name the key that failed"
+  assert_contains "$(cat "$log")" "target=sess:fm-lane-key literal=0 arg=Escape" "the undelivered case should still have attempted the send"
+  pass "fm-send --key: exit status follows delivery, and an undelivered key never reports success"
+}
+
+test_exact_lane_id_send_still_works
+test_key_send_exit_status_follows_delivery
+test_unset_fm_home_fails
+test_unresolvable_target_does_not_tmux_fallback
+test_prefixless_herdr_pane_id_fails
+test_unmatched_single_colon_target_must_exist
+test_fm_prefixed_herdr_session_is_an_explicit_target
+test_healthy_fm_id_send_still_works

package/.agents/tests/fm-session-lock-ancestry.test.sh

@@ -0,0 +1,365 @@
+#!/usr/bin/env bash
+# tests/fm-session-lock-ancestry.test.sh - session-lock harness identity
+# (bin/fm-session-lock-lib.sh).
+#
+# Two layers. The unit cases drive the library's own functions behind a
+# deterministic fake ps, so both platforms' reporting semantics are covered from
+# either host: macOS reports argv[0] in `ps -o comm=`, while procps on Linux
+# reports the kernel exec name and ignores argv[0] entirely. The end-to-end cases
+# run the REAL Stop auto-arm inside real process trees whose shapes differ only
+# in how the per-session process is named and what its parent is. Those trees are
+# orphaned before the hook fires, so the ancestry walk terminates inside the
+# fixture and can never escape into the session running this suite.
+# shellcheck disable=SC2016 # single quotes are deliberate: $FM_HOME and $$ expand inside the fixture child
+set -u
+
+# shellcheck source=tests/lib.sh
+. "$(dirname "${BASH_SOURCE[0]}")/lib.sh"
+
+TMP_ROOT=$(fm_test_tmproot fm-session-lock-ancestry)
+fm_git_identity fmtest fmtest@example.invalid
+
+LIB="$ROOT/bin/fm-session-lock-lib.sh"
+
+# Claude Code's native installer names the per-session executable by its version,
+# so the harness identity has to survive a basename that says nothing.
+CLAUDE_VERSION_DIR="$TMP_ROOT/claude-install/share/claude/versions"
+mkdir -p "$CLAUDE_VERSION_DIR"
+ln -s /bin/bash "$CLAUDE_VERSION_DIR/2.1.220"
+VERSIONED_CLAUDE="$CLAUDE_VERSION_DIR/2.1.220"
+
+FAKEBIN=$(fm_fakebin "$TMP_ROOT/harness-bin")
+ln -s /bin/bash "$FAKEBIN/claude"
+NAMED_CLAUDE="$FAKEBIN/claude"
+
+# --- unit layer: identity behind a deterministic process table ---------------
+
+# Run one library expression with <fakebin> shadowing ps. kill is stubbed so
+# liveness questions are decided by the process table alone.
+lib_eval() {  # <fakebin> <expression>
+  local fakebin=$1 expr=$2
+  PATH="$fakebin:$PATH" bash -c "
+    . \"\$0\"
+    kill() { return 0; }
+    $expr
+  " "$LIB"
+}
+
+test_version_named_session_is_identified_on_both_platforms() {
+  local dir fakebin shape got
+  dir="$TMP_ROOT/version-named"
+  fakebin=$(fm_fakebin "$dir")
+  mkdir -p "$dir/state"
+  cat > "$fakebin/ps" <<'SH'
+#!/usr/bin/env bash
+set -u
+field= pid=
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    -o) field=$2; shift 2 ;;
+    -p) pid=$2; shift 2 ;;
+    *) shift ;;
+  esac
+done
+case "$pid:$field:${FM_TEST_CLAUDE_SHAPE:-linux}" in
+  700:comm=:linux) printf '%s\n' '2.1.220' ;;
+  700:args=:linux) printf '%s\n' '/opt/claude/versions/2.1.220 --resume' ;;
+  700:comm=:macos) printf '%s\n' '/Users/u/.local/share/claude/versions/2.1.220' ;;
+  700:args=:macos) printf '%s\n' '/Users/u/.local/share/claude/versions/2.1.220 --resume' ;;
+  700:ppid=:*) printf '%s\n' 1 ;;
+  *:comm=:*) printf '%s\n' bash ;;
+  *:args=:*) printf '%s\n' 'bash /repo/bin/fm-claude-stop-autoarm.sh' ;;
+  *:ppid=:*) printf '%s\n' 700 ;;
+esac
+SH
+  chmod +x "$fakebin/ps"
+  printf '700\n' > "$dir/state/.lock"
+
+  for shape in linux macos; do
+    got=$(FM_TEST_CLAUDE_SHAPE="$shape" lib_eval "$fakebin" 'fm_harness_ancestry_pid') \
+      || fail "$shape: the version-named session was not found in the ancestry at all"
+    [ "$got" = 700 ] || fail "$shape: ancestry resolved '$got', expected the version-named session pid 700"
+    FM_TEST_CLAUDE_SHAPE="$shape" lib_eval "$fakebin" 'fm_harness_pid_alive 700' \
+      || fail "$shape: a live version-named session was not recognized as a harness"
+    FM_TEST_CLAUDE_SHAPE="$shape" lib_eval "$fakebin" "fm_session_lock_owned_by_self '$dir/state'" \
+      || fail "$shape: the session holding the lock did not recognize itself as the owner"
+  done
+  pass "session-lock: a version-named Claude Code session is identified from its install path and argv[0]"
+}
+
+test_ordinary_paths_are_never_harness_processes() {
+  local dir fakebin shape
+  dir="$TMP_ROOT/ordinary-paths"
+  fakebin=$(fm_fakebin "$dir")
+  mkdir -p "$dir/state"
+  cat > "$fakebin/ps" <<'SH'
+#!/usr/bin/env bash
+set -u
+field= pid=
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    -o) field=$2; shift 2 ;;
+    -p) pid=$2; shift 2 ;;
+    *) shift ;;
+  esac
+done
+case "$pid:$field:${FM_TEST_PATH_SHAPE:-hookdir}" in
+  810:comm=:hookdir) printf '%s\n' '/home/u/.claude/hooks/notify.sh' ;;
+  810:args=:hookdir) printf '%s\n' '/home/u/.claude/hooks/notify.sh --quiet' ;;
+  810:comm=:piprefix) printf '%s\n' '/opt/pipeline/bin/runner' ;;
+  810:args=:piprefix) printf '%s\n' '/opt/pipeline/bin/runner --once' ;;
+  810:ppid=:*) printf '%s\n' 1 ;;
+  *:comm=:*) printf '%s\n' bash ;;
+  *:args=:*) printf '%s\n' 'bash /repo/bin/fm-watch-arm.sh' ;;
+  *:ppid=:*) printf '%s\n' 810 ;;
+esac
+SH
+  chmod +x "$fakebin/ps"
+  printf '810\n' > "$dir/state/.lock"
+
+  # Identity may be read from an executable path, but only from whole path
+  # components: anything merely living under ~/.claude, and any component that
+  # merely starts with a harness name, must stay outside the harness identity.
+  for shape in hookdir piprefix; do
+    if FM_TEST_PATH_SHAPE="$shape" lib_eval "$fakebin" 'fm_harness_ancestry_pid'; then
+      fail "$shape: an ordinary script path was treated as a harness process"
+    fi
+    if FM_TEST_PATH_SHAPE="$shape" lib_eval "$fakebin" 'fm_harness_pid_alive 810'; then
+      fail "$shape: an ordinary script path passed the harness-liveness predicate"
+    fi
+    if FM_TEST_PATH_SHAPE="$shape" lib_eval "$fakebin" "fm_session_lock_owned_by_self '$dir/state'"; then
+      fail "$shape: an ordinary script path claimed the home's session lock"
+    fi
+  done
+  pass "session-lock: ordinary script paths under a harness directory are not harness processes"
+}
+
+test_harness_beyond_a_gap_never_owns_the_lock() {
+  local dir fakebin got
+  dir="$TMP_ROOT/gap"
+  fakebin=$(fm_fakebin "$dir")
+  mkdir -p "$dir/state"
+  cat > "$fakebin/ps" <<'SH'
+#!/usr/bin/env bash
+set -u
+field= pid=
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    -o) field=$2; shift 2 ;;
+    -p) pid=$2; shift 2 ;;
+    *) shift ;;
+  esac
+done
+case "$pid:$field" in
+  900:comm=) printf '%s\n' claude ;;
+  900:args=) printf '%s\n' 'claude' ;;
+  900:ppid=) printf '%s\n' 910 ;;
+  910:comm=) printf '%s\n' bash ;;
+  910:args=) printf '%s\n' 'bash tests/run.sh' ;;
+  910:ppid=) printf '%s\n' 920 ;;
+  920:comm=) printf '%s\n' claude ;;
+  920:args=) printf '%s\n' 'claude' ;;
+  920:ppid=) printf '%s\n' 1 ;;
+  *:comm=) printf '%s\n' bash ;;
+  *:args=) printf '%s\n' bash ;;
+  *:ppid=) printf '%s\n' 900 ;;
+esac
+SH
+  chmod +x "$fakebin/ps"
+
+  got=$(lib_eval "$fakebin" 'fm_harness_ancestry_pid') || fail "the contiguous harness run was not resolved"
+  [ "$got" = 900 ] || fail "ancestry crossed a non-harness gap, resolved '$got' instead of 900"
+  printf '920\n' > "$dir/state/.lock"
+  if lib_eval "$fakebin" "fm_session_lock_owned_by_self '$dir/state'"; then
+    fail "an unrelated harness beyond a non-harness gap was accepted as this session's lock owner"
+  fi
+  printf '900\n' > "$dir/state/.lock"
+  lib_eval "$fakebin" "fm_session_lock_owned_by_self '$dir/state'" \
+    || fail "the contiguous harness run did not recognize its own lock"
+  pass "session-lock: ownership stops at the first non-harness gap above the contiguous run"
+}
+
+test_competing_version_named_session_is_seen_as_live() {
+  local dir fakebin
+  dir="$TMP_ROOT/competing"
+  fakebin=$(fm_fakebin "$dir")
+  mkdir -p "$dir/state"
+  cat > "$fakebin/ps" <<'SH'
+#!/usr/bin/env bash
+set -u
+field= pid=
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    -o) field=$2; shift 2 ;;
+    -p) pid=$2; shift 2 ;;
+    *) shift ;;
+  esac
+done
+case "$pid:$field" in
+  600:comm=) printf '%s\n' '2.1.220' ;;
+  600:args=) printf '%s\n' '/opt/claude/versions/2.1.220' ;;
+  600:ppid=) printf '%s\n' 1 ;;
+  650:comm=) printf '%s\n' claude ;;
+  650:args=) printf '%s\n' claude ;;
+  650:ppid=) printf '%s\n' 1 ;;
+  *:comm=) printf '%s\n' bash ;;
+  *:args=) printf '%s\n' bash ;;
+  *:ppid=) printf '%s\n' 650 ;;
+esac
+SH
+  chmod +x "$fakebin/ps"
+  # pid 600 is a different live session that holds the lock; this process
+  # descends from 650 instead. Treating 600 as dead would let this session
+  # reclaim a live competitor's home.
+  printf '600\n' > "$dir/state/.lock"
+  if lib_eval "$fakebin" "fm_session_lock_owned_by_self '$dir/state'"; then
+    fail "a lock held outside this ancestry was claimed as this session's own"
+  fi
+  lib_eval "$fakebin" 'fm_harness_pid_alive 600' \
+    || fail "a live competing version-named session was classified as a dead lock owner"
+  pass "session-lock: a live version-named session holding the lock is not mistaken for a stale owner"
+}
+
+# --- end-to-end layer: the real Stop auto-arm in real process trees ----------
+
+install_autoarm_scripts() {
+  local dir=$1
+  mkdir -p "$dir/bin"
+  cp "$ROOT/bin/fm-claude-stop-autoarm.sh" "$dir/bin/fm-claude-stop-autoarm.sh"
+  cp "$ROOT/bin/fm-primary-scope-lib.sh" "$dir/bin/fm-primary-scope-lib.sh"
+  cp "$ROOT/bin/fm-supervision-lib.sh" "$dir/bin/fm-supervision-lib.sh"
+  cp "$ROOT/bin/fm-wake-lib.sh" "$dir/bin/fm-wake-lib.sh"
+  cp "$ROOT/bin/fm-session-lock-lib.sh" "$dir/bin/fm-session-lock-lib.sh"
+  cp "$ROOT/bin/fm-cursor-lib.sh" "$dir/bin/fm-cursor-lib.sh"
+  cp "$ROOT/bin/fm-hook-host-lib.sh" "$dir/bin/fm-hook-host-lib.sh"
+  cp "$ROOT/bin/fm-lock.sh" "$dir/bin/fm-lock.sh"
+  chmod +x "$dir/bin/fm-claude-stop-autoarm.sh" "$dir/bin/fm-lock.sh"
+  cat > "$dir/bin/fm-watch-arm.sh" <<'SH'
+#!/usr/bin/env bash
+echo "$$" >> "$FM_HOME/state/arm-ran"
+printf 'watcher: started pid=%s (beacon fresh)\n' "$$"
+printf 'stale: fixture-win actionable\n'
+exit 0
+SH
+  chmod +x "$dir/bin/fm-watch-arm.sh"
+}
+
+# A primary home with one task in flight, so the hook's scope and supervision-need
+# gates both pass and only identity decides the outcome.
+make_primary_home() {  # <dir>
+  local dir=$1
+  mkdir -p "$dir/state"
+  git init -q "$dir"
+  git -C "$dir" commit -q --allow-empty -m init
+  : > "$dir/AGENTS.md"
+  : > "$dir/state/task.meta"
+  install_autoarm_scripts "$dir"
+  # The process that fires the hook records its own pid as the session lock
+  # owner, exactly as a real session does at session start.
+  cat > "$dir/session.sh" <<'SH'
+#!/usr/bin/env bash
+if [ "${FM_FIXTURE_ORPHAN_HERE:-0}" = 1 ]; then
+  i=0
+  while [ "$i" -lt 200 ] && [ "$(ps -o ppid= -p $$ 2>/dev/null | tr -d ' ')" != 1 ]; do
+    sleep 0.05
+    i=$((i + 1))
+  done
+fi
+printf '%s\n' "$$" > "$FM_HOME/state/session-pid"
+printf '%s\n' "$$" > "$FM_HOME/state/.lock"
+"$FM_HOME/bin/fm-claude-stop-autoarm.sh" </dev/null > "$FM_HOME/state/hook.out" 2>&1
+printf '%s\n' "$?" > "$FM_HOME/state/hook.rc"
+SH
+  cat > "$dir/daemon.sh" <<'SH'
+#!/usr/bin/env bash
+i=0
+while [ "$i" -lt 200 ] && [ "$(ps -o ppid= -p $$ 2>/dev/null | tr -d ' ')" != 1 ]; do
+  sleep 0.05
+  i=$((i + 1))
+done
+printf '%s\n' "$$" > "$FM_HOME/state/daemon-pid"
+"$FM_SESSION_BIN" "$FM_HOME/session.sh"
+exit 0
+SH
+  chmod +x "$dir/session.sh" "$dir/daemon.sh"
+}
+
+# Start the fixture tree detached from this suite's own process tree: the
+# launcher exits immediately, so the tree is reparented to init and the ancestry
+# walk terminates inside the fixture. Returns once the hook has recorded its exit
+# code.
+run_fixture_tree() {  # <dir> <session-bin> [<daemon-bin>]
+  local dir=$1 session_bin=$2 daemon_bin=${3:-} i
+  if [ -n "$daemon_bin" ]; then
+    FM_HOME="$dir" FM_SESSION_BIN="$session_bin" FM_FIXTURE_ORPHAN_HERE=0 \
+      bash -c '"$0" "$1" &' "$daemon_bin" "$dir/daemon.sh"
+  else
+    FM_HOME="$dir" FM_FIXTURE_ORPHAN_HERE=1 \
+      bash -c '"$0" "$1" &' "$session_bin" "$dir/session.sh"
+  fi
+  i=0
+  while [ "$i" -lt 400 ] && [ ! -s "$dir/state/hook.rc" ]; do
+    sleep 0.05
+    i=$((i + 1))
+  done
+  [ -s "$dir/state/hook.rc" ] || fail "the fixture hook never finished"
+}
+
+hook_rc() {
+  tr -d '[:space:]' < "$1/state/hook.rc"
+}
+
+epoch_outcome() {
+  sed -n 's/^.*outcome=\([a-z][a-z]*\) .*$/\1/p' "$1/state/.claude-autoarm-epoch" 2>/dev/null || true
+}
+
+test_e2e_version_named_session_claims_the_home() {
+  local dir
+  dir="$TMP_ROOT/e2e-version-named"
+  make_primary_home "$dir"
+  run_fixture_tree "$dir" "$VERSIONED_CLAUDE"
+  expect_code 2 "$(hook_rc "$dir")" "a version-named session must claim its home and rewake"
+  [ -e "$dir/state/arm-ran" ] || fail "supervision never armed for a version-named session"
+  [ "$(epoch_outcome "$dir")" = rewake ] || fail "no claim was recorded, got: $(epoch_outcome "$dir")"
+  pass "session-lock e2e: a version-named session claims the home and arms supervision"
+}
+
+test_e2e_daemon_parented_session_claims_the_home() {
+  local dir session_pid daemon_pid lock_after
+  dir="$TMP_ROOT/e2e-daemon-parented"
+  make_primary_home "$dir"
+  run_fixture_tree "$dir" "$NAMED_CLAUDE" "$NAMED_CLAUDE"
+  session_pid=$(tr -d '[:space:]' < "$dir/state/session-pid")
+  daemon_pid=$(tr -d '[:space:]' < "$dir/state/daemon-pid")
+  [ -n "$session_pid" ] && [ "$session_pid" != "$daemon_pid" ] \
+    || fail "fixture did not produce a distinct daemon and session: session=$session_pid daemon=$daemon_pid"
+  lock_after=$(tr -d '[:space:]' < "$dir/state/.lock")
+  expect_code 2 "$(hook_rc "$dir")" "a session parented by a harness-named daemon must claim its home and rewake"
+  [ -e "$dir/state/arm-ran" ] || fail "supervision never armed for a daemon-parented session"
+  [ "$lock_after" = "$session_pid" ] || fail "the session lock moved off the session: expected $session_pid, got $lock_after"
+  pass "session-lock e2e: a session parented by a harness-named daemon claims the home and arms supervision"
+}
+
+test_e2e_daemon_parented_version_named_session_keeps_its_lock() {
+  local dir session_pid daemon_pid lock_after
+  dir="$TMP_ROOT/e2e-daemon-version-named"
+  make_primary_home "$dir"
+  run_fixture_tree "$dir" "$VERSIONED_CLAUDE" "$NAMED_CLAUDE"
+  session_pid=$(tr -d '[:space:]' < "$dir/state/session-pid")
+  daemon_pid=$(tr -d '[:space:]' < "$dir/state/daemon-pid")
+  lock_after=$(tr -d '[:space:]' < "$dir/state/.lock")
+  [ "$lock_after" != "$daemon_pid" ] \
+    || fail "the live session's lock was reclaimed as stale and rewritten to the shared daemon pid $daemon_pid"
+  [ "$lock_after" = "$session_pid" ] || fail "the session lock moved off the session: expected $session_pid, got $lock_after"
+  expect_code 2 "$(hook_rc "$dir")" "a version-named session under a daemon must claim its home and rewake"
+  [ -e "$dir/state/arm-ran" ] || fail "supervision never armed for a version-named daemon-parented session"
+  pass "session-lock e2e: a version-named session under a harness-named daemon keeps its own lock"
+}
+
+test_version_named_session_is_identified_on_both_platforms
+test_ordinary_paths_are_never_harness_processes
+test_harness_beyond_a_gap_never_owns_the_lock
+test_competing_version_named_session_is_seen_as_live
+test_e2e_version_named_session_claims_the_home
+test_e2e_daemon_parented_session_claims_the_home
+test_e2e_daemon_parented_version_named_session_keeps_its_lock