@zerwiz/ymir 0.1.3 → 0.1.5

package/.agents/tests/fm-composer-matrix-live-e2e.test.sh

@@ -0,0 +1,220 @@
+#!/usr/bin/env bash
+# tests/fm-composer-matrix-live-e2e.test.sh - the live composer-matrix guard
+# (live-harness-optin family; task fm-composer-thin-adapter-refactor-r1).
+#
+# The shared composer classifier's shape catalogue (bin/fm-composer-lib.sh) is
+# built entirely from vendor-rendered signals, so per
+# .agents/skills/firstmate-coding-guidelines it must be proven against the
+# REAL harnesses: a stub can only confirm the assumption already written into
+# the stub. This guard launches every INSTALLED verified harness idle in an
+# isolated tmux server and requires the real fm_tmux_composer_state to reach
+# `empty`, failing loudly with the harness name and version. It also proves:
+#   - the strict blank-row posture live: a plain shell pane with a blank
+#     cursor row must classify unknown and defer injection;
+#   - the zellij false-positive regression live (when zellij is installed): a
+#     pane whose content changes for reasons unrelated to submission must NOT
+#     report a delivered send, and a real claude-in-zellij `dump-screen
+#     --ansi` capture must classify empty through the zellij thin adapter.
+#
+# Run explicitly with FM_COMPOSER_MATRIX_LIVE=1. No prompt is ever submitted
+# to any harness, so no model tokens are spent. An absent harness is reported
+# explicitly and skipped; a run that verified nothing fails rather than
+# passing vacuously. Refresh docs/verification/runtime-backends.md ("Composer
+# classification matrix") from this guard's output after any harness upgrade.
+#
+# Folder trust: harnesses are launched with the repo root as cwd, which the
+# operator's machine has normally already trusted; a trust dialog is a real
+# unreadable-composer state and correctly fails that harness's check.
+set -u
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+if [ "${FM_COMPOSER_MATRIX_LIVE:-0}" != 1 ]; then
+  echo "skip: set FM_COMPOSER_MATRIX_LIVE=1 to run the live composer-matrix guard"
+  exit 0
+fi
+
+command -v tmux >/dev/null 2>&1 || { echo "not ok - FM_COMPOSER_MATRIX_LIVE=1 but tmux is not installed" >&2; exit 1; }
+
+SOCKET="fm-cmx-live-$$"
+SESSION="cmxlive"
+ZELLIJ_SESSION="fm-cmx-live-zj-$$"
+CHECKED=0
+FAILED=0
+
+fail() { printf 'not ok - %s\n' "$1" >&2; cleanup; exit 1; }
+pass() { printf 'ok - %s\n' "$1"; }
+note() { printf '# %s\n' "$1"; }
+
+cleanup() {
+  tmux -L "$SOCKET" kill-server 2>/dev/null || true
+  [ -z "${ZJ_BG:-}" ] || kill "$ZJ_BG" 2>/dev/null || true
+  if command -v zellij >/dev/null 2>&1; then
+    zellij delete-session --force "$ZELLIJ_SESSION" >/dev/null 2>&1 || true
+  fi
+}
+trap cleanup EXIT
+
+# The library under test, driven against the private socket through a PATH
+# shim so its bare `tmux` calls stay isolated from any live fleet.
+SHIM_DIR=$(mktemp -d "${TMPDIR:-/tmp}/fm-cmx-live.XXXXXX")
+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"
+
+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'
+}
+
+check_harness_idle_empty() {  # <name> <launch-cmd...>
+  local name=$1 win="hx-$1" verdict='' i=0 budget=${FM_COMPOSER_MATRIX_LIVE_POLLS:-45} version dismissed=0 startup_screen
+  shift
+  version=$(harness_version "$1")
+  tmux -L "$SOCKET" new-window -d -t "$SESSION:" -n "$win" -c "$ROOT" -- "$@" \
+    || fail "$name ($version): could not launch in the isolated tmux server"
+  while [ "$i" -lt "$budget" ]; do
+    verdict=$(fm_tmux_composer_state "$SESSION:$win")
+    [ "$verdict" = empty ] && break
+    i=$((i + 1))
+    # A fresh harness may park on a vendor update-available modal (observed
+    # live: codex 0.146.0 and opencode 1.14.46), which the strict classifier
+    # correctly refuses to call a composer. Dismiss it once, mid-budget, with
+    # a single Escape - the one key that submits nothing anywhere and is how
+    # the audit declined the same prompts. Never Enter: on codex's dialog
+    # Enter would RUN the upgrade.
+    if [ "$dismissed" -eq 0 ] && [ "$i" -ge $((budget / 3)) ]; then
+      # Trust prompts also accept Escape, but there it exits the harness and
+      # erases the actionable failure surface. Preserve those prompts; only
+      # dismiss a non-trust startup modal.
+      startup_screen=$(tmux -L "$SOCKET" capture-pane -p -t "$SESSION:$win" 2>/dev/null || true)
+      if ! printf '%s\n' "$startup_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
+  if [ "$verdict" != empty ]; then
+    printf '# %s pane tail at failure:\n' "$name" >&2
+    tmux -L "$SOCKET" capture-pane -p -t "$SESSION:$win" 2>/dev/null \
+      | grep '[^[:space:]]' | tail -8 | sed 's/^/#   /' >&2
+    FAILED=1
+    printf 'not ok - %s (%s): idle composer never classified empty (last verdict: %s)\n' \
+      "$name" "$version" "${verdict:-unreadable}" >&2
+  else
+    CHECKED=$((CHECKED + 1))
+    pass "$name ($version): real idle composer classifies empty"
+  fi
+  tmux -L "$SOCKET" kill-window -t "$SESSION:$win" 2>/dev/null || true
+}
+
+# --- 1. Every installed verified harness must reach a proven-empty composer --
+for h in claude codex opencode pi grok kimi muse; do
+  if command -v "$h" >/dev/null 2>&1; then
+    check_harness_idle_empty "$h" "$h"
+  else
+    note "harness absent, not verified here: $h"
+  fi
+done
+
+# --- 2. The strict blank-row posture, live ----------------------------------
+# A plain shell pane parked on a blank line between two rules (the audit's
+# sleep-pane counterexample): the permissive rule read this empty; strict must
+# defer.
+tmux -L "$SOCKET" new-window -d -t "$SESSION:" -n strictblank -c "$ROOT" \
+  -- bash -c 'printf "────────────────────────\n\n"; printf "\033[A"; exec sleep 300'
+sleep 1
+verdict=$(fm_tmux_composer_state "$SESSION:strictblank")
+if [ "$verdict" = unknown ]; then
+  if fm_pane_input_pending "$SESSION:strictblank"; then
+    CHECKED=$((CHECKED + 1))
+    pass "strict posture live: a blank shell row classifies unknown and injection defers"
+  else
+    FAILED=1
+    printf 'not ok - strict posture live: pane_input_pending did not defer on an unknown verdict\n' >&2
+  fi
+else
+  FAILED=1
+  printf 'not ok - strict posture live: blank shell row classified %s, expected unknown\n' "${verdict:-unreadable}" >&2
+fi
+tmux -L "$SOCKET" kill-window -t "$SESSION:strictblank" 2>/dev/null || true
+
+# --- 3. zellij: real classifier + the false-positive regression -------------
+if command -v zellij >/dev/null 2>&1; then
+  zj_version=$(zellij --version 2>/dev/null | head -1)
+  [ -n "$zj_version" ] || zj_version='version-unknown'
+  export FM_ROOT_OVERRIDE="$ROOT"
+  # shellcheck source=/dev/null
+  . "$ROOT/bin/fm-backend.sh"
+  fm_backend_source zellij 2>/dev/null \
+    || fail "zellij ($zj_version): adapter source failed"
+
+  zellij delete-session --force "$ZELLIJ_SESSION" >/dev/null 2>&1 || true
+  zellij --session "$ZELLIJ_SESSION" options --default-shell bash >/dev/null 2>&1 &
+  ZJ_BG=$!
+  i=0
+  while [ "$i" -lt 10 ] && ! fm_backend_zellij_session_exists "$ZELLIJ_SESSION"; do
+    i=$((i + 1))
+    sleep 0.5
+  done
+  fm_backend_zellij_session_exists "$ZELLIJ_SESSION" \
+    || fail "zellij ($zj_version): probe session setup failed"
+  panes=$(fm_backend_zellij_cli "$ZELLIJ_SESSION" action list-panes --json 2>/dev/null) \
+    || fail "zellij ($zj_version): pane discovery command failed"
+  pane_id=$(printf '%s' "$panes" | jq -r '.[]? | select(.is_plugin == false) | .id' 2>/dev/null | head -1)
+  case "$pane_id" in
+    ''|*[!0-9]*) fail "zellij ($zj_version): pane discovery returned no terminal pane" ;;
+  esac
+  target="$ZELLIJ_SESSION:$pane_id"
+
+  fm_backend_zellij_send_literal "$target" 'while sleep 1; do date; done' \
+    || fail "zellij ($zj_version): clock probe setup write failed"
+  fm_backend_zellij_send_key "$target" Enter \
+    || fail "zellij ($zj_version): clock probe setup submit failed"
+  sleep 2
+  probe='# audit-probe-never-submitted'
+  fm_backend_zellij_send_literal "$target" "$probe" \
+    || fail "zellij ($zj_version): false-positive probe write failed"
+  sleep 0.5
+  probe_capture=$(fm_backend_zellij_capture "$target" 40 2>/dev/null) \
+    || fail "zellij ($zj_version): false-positive probe capture failed"
+  case "$probe_capture" in
+    *"$probe"*) ;;
+    *) fail "zellij ($zj_version): false-positive probe text was not visible after typing" ;;
+  esac
+  verdict=$(fm_composer_submit_retry_core fm_backend_zellij_send_key fm_backend_zellij_composer_state \
+    "$target" 2 0.5 2>/dev/null)
+  case "$verdict" in
+    pending|unknown)
+      CHECKED=$((CHECKED + 1))
+      pass "zellij ($zj_version): unrelated pane change never confirms delivery (verdict: $verdict)"
+      ;;
+    send-failed)
+      FAILED=1
+      printf 'not ok - zellij (%s): false-positive probe text was not typed (send-failed)\n' "$zj_version" >&2
+      ;;
+    *)
+      FAILED=1
+      printf 'not ok - zellij (%s): false-positive probe returned unexpected verdict %s (expected pending or unknown)\n' \
+        "$zj_version" "${verdict:-none}" >&2
+      ;;
+  esac
+  kill "$ZJ_BG" 2>/dev/null || true
+  ZJ_BG=
+  zellij delete-session --force "$ZELLIJ_SESSION" >/dev/null 2>&1 || true
+else
+  note "harness absent, not verified here: zellij (false-positive regression not exercised)"
+fi
+
+# --- refuse a vacuous pass ---------------------------------------------------
+[ "$FAILED" -eq 0 ] || fail "live composer-matrix guard observed failures above"
+[ "$CHECKED" -gt 0 ] || fail "live composer-matrix guard verified nothing (no harness installed?); refusing a vacuous pass"
+pass "live composer-matrix guard verified $CHECKED live surface(s)"

package/.agents/tests/fm-control-herdr-smoke.test.sh

@@ -0,0 +1,149 @@
+#!/usr/bin/env bash
+# tests/fm-control-herdr-smoke.test.sh - real-herdr smoke test for the agent
+# lifecycle control plane (bin/fm-control.sh).
+#
+# tmux is the control plane's reference backend and is covered hermetically in
+# tests/fm-control.test.sh. herdr is the OTHER backend whose recovery-grade
+# agent-state classifier the control plane is allowed to trust, so its
+# behavior is pinned here against the REAL binary rather than a stub: whether
+# an agent is running, and therefore whether a lifecycle verb may act at all,
+# comes from herdr's own agent registry.
+#
+# No real agent is launched. herdr's `pane report-agent` is the same registry
+# the adapter reads, so registering and not registering an agent on a plain
+# shell pane exercises exactly the classification the control plane gates on.
+#
+# Always runs on a private, named, throwaway lab session, never the default
+# one (tests/herdr-test-safety.sh; the 2026-07-02 incident). Skips cleanly
+# when herdr or jq is missing.
+set -u
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+fail() { printf 'not ok - %s\n' "$1" >&2; cleanup_all; exit 1; }
+pass() { printf 'ok - %s\n' "$1"; }
+
+command -v herdr >/dev/null 2>&1 || { echo "skip: herdr not found"; exit 0; }
+command -v jq >/dev/null 2>&1 || { echo "skip: jq not found (required by the herdr adapter)"; exit 0; }
+
+# shellcheck source=tests/herdr-test-safety.sh
+. "$ROOT/tests/herdr-test-safety.sh"
+herdr_forget_inherited_pane
+
+SESSION="fm-lab-control-smoke-$$"
+export HERDR_SESSION="$SESSION"
+SCRATCH=
+cleanup_all() {
+  [ -n "$SCRATCH" ] && rm -rf "$SCRATCH"
+  herdr_safe_stop_and_delete "$SESSION"
+}
+trap cleanup_all EXIT
+fm_herdr_lab_prepare "$SESSION" || fail "could not prepare isolated Herdr lab session"
+
+SCRATCH=$(mktemp -d "${TMPDIR:-/tmp}/fm-control-herdr.XXXXXX")
+SCRATCH=$(cd "$SCRATCH" && pwd)
+HOME_DIR="$SCRATCH/home"
+mkdir -p "$HOME_DIR/state" "$HOME_DIR/data/hsmoke"
+printf '# brief\n' > "$HOME_DIR/data/hsmoke/brief.md"
+
+# A real git worktree so the control plane's checkpoint has a real local copy.
+PROJ="$SCRATCH/proj"
+WT="$SCRATCH/wt"
+mkdir -p "$PROJ"
+git -C "$PROJ" init -q
+printf '# proj\n' > "$PROJ/README.md"
+git -C "$PROJ" add README.md
+git -C "$PROJ" -c user.name='Firstmate Tests' -c user.email='tests@example.invalid' commit -qm initial
+git -C "$PROJ" worktree add --quiet -b hsmoke "$WT"
+
+# shellcheck source=/dev/null
+. "$ROOT/bin/fm-backend.sh"
+fm_backend_source herdr || fail "fm_backend_source herdr failed"
+
+CONTAINER_RAW=$(fm_backend_herdr_container_ensure "$WT") || fail "container_ensure failed"
+CONTAINER=${CONTAINER_RAW%%$'\t'*}
+SEEDED_TAB_ID=${CONTAINER_RAW#*$'\t'}
+WORKSPACE_ID=${CONTAINER#*:}
+TASK_IDS=$(fm_backend_herdr_create_task "$CONTAINER" "fm-hsmoke" "$WT" "$SEEDED_TAB_ID") \
+  || fail "create_task failed"
+read -r TAB_ID PANE_ID <<EOF
+$TASK_IDS
+EOF
+[ -n "$TAB_ID" ] && [ -n "$PANE_ID" ] || fail "create_task did not return tab/pane ids"
+
+{
+  echo "window=$SESSION:$PANE_ID"
+  echo "endpoint_task_id=hsmoke"
+  echo "worktree=$WT"
+  echo "project=$PROJ"
+  echo "harness=claude"
+  echo "kind=ship"
+  echo "mode=no-mistakes"
+  echo "yolo=off"
+  echo "model=default"
+  echo "effort=default"
+  echo "backend=herdr"
+  echo "herdr_session=$SESSION"
+  echo "herdr_workspace_id=$WORKSPACE_ID"
+  echo "herdr_tab_id=$TAB_ID"
+  echo "herdr_pane_id=$PANE_ID"
+} > "$HOME_DIR/state/hsmoke.meta"
+
+run_control() {
+  env FM_HOME="$HOME_DIR" HERDR_SESSION="$SESSION" \
+    FM_CONTROL_POLL=0.2 FM_CONTROL_EXIT_WAIT=2 \
+    "$ROOT/bin/fm-control.sh" "$@" 2>&1
+}
+
+# --- no registered agent: the endpoint exists but hosts no agent ------------
+
+OUT=$(run_control hsmoke exit) || fail "exit against an agent-free herdr pane should be idempotent success: $OUT"
+case "$OUT" in
+  "already-stopped hsmoke"*) : ;;
+  *) fail "an agent-free herdr pane should report already-stopped, got: $OUT" ;;
+esac
+pass "real herdr: exit on a pane with no registered agent is idempotent success"
+
+if OUT=$(run_control hsmoke interrupt 2>&1); then
+  fail "interrupt should refuse when herdr reports no agent on the pane: $OUT"
+fi
+case "$OUT" in
+  *"nothing to interrupt"*) : ;;
+  *) fail "the interrupt refusal should say there is no agent, got: $OUT" ;;
+esac
+pass "real herdr: interrupt refuses when herdr's own agent registry reports no agent"
+
+# --- a registered agent: classification flips, and the verbs follow ---------
+
+herdr pane report-agent "$PANE_ID" --source fm-control-smoke --agent fm-control-smoke-agent \
+  --state idle --session "$SESSION" >/dev/null 2>&1 \
+  || fail "could not register a live agent on the task pane"
+
+STATE=$(fm_backend_agent_state herdr "$SESSION:$PANE_ID")
+[ "$STATE" = alive ] || fail "herdr should classify a registered agent as alive, got '$STATE'"
+
+OUT=$(run_control hsmoke interrupt) || fail "interrupt against a registered agent should succeed: $OUT"
+case "$OUT" in
+  *"interrupt-delivered hsmoke harness=claude backend=herdr verified=agent-alive cancel=unconfirmed"*) : ;;
+  *) fail "interrupt should report the agent-alive proof on herdr, got: $OUT" ;;
+esac
+pass "real herdr: interrupt delivers the harness's key and proves the agent survived it"
+
+herdr pane get "$PANE_ID" --session "$SESSION" >/dev/null 2>&1 \
+  || fail "the control plane must never remove the endpoint it was operating on"
+[ -d "$WT" ] || fail "the control plane must never remove the task's local copy"
+pass "real herdr: no control verb removed the endpoint or the task's local copy"
+
+# Last, because it deliberately types a harness command into a pane that hosts
+# a plain shell: the registered agent cannot actually be stopped that way, and
+# the control plane must say so rather than report a stop it did not achieve.
+if OUT=$(run_control hsmoke exit 2>&1); then
+  fail "exit should fail closed when the agent does not stop: $OUT"
+fi
+case "$OUT" in
+  *"did not stop"*) : ;;
+  *) fail "the exit failure should say the agent did not stop, got: $OUT" ;;
+esac
+pass "real herdr: an agent that does not stop fails closed instead of being reported as stopped"
+
+fm_backend_herdr_kill "$SESSION:$PANE_ID" 2>/dev/null || true