diff --git a/bin/fm-capability-lib.sh b/bin/fm-capability-lib.sh
index a80c5ec76b..ad87b329a5 100755
--- a/bin/fm-capability-lib.sh
+++ b/bin/fm-capability-lib.sh
@@ -6,9 +6,25 @@
 # This header owns the wire format and selection contracts:
 #   - Log path: $FM_HOME/data/capability-outcomes.log (override: FM_CAPABILITY_LOG).
 #   - One append-only line per finished ship/scout teardown:
-#       <unix-epoch>|<task-type>|<harness>|<model>|<effort>|<outcome>
+#       <unix-epoch>|<task-type>|<harness>|<model>|<effort>|<outcome>[|<fix-rounds>[|<steers>]]
 #     Fields never contain '|' or newlines; invalid fields refuse the append.
-#   - Outcomes: green (normal landed teardown) or discarded (--force).
+#     The trailing counts are written only when derivable, each as one
+#     non-negative integer: fix-rounds is the number of earlier recorded
+#     pipeline attempts for the task's branch before its final attempt, and
+#     steers is the confirmed supervisor send count from state/<id>.steers.
+#     An absent fix-rounds count retains an empty field when steers is present;
+#     otherwise absent trailing counts are omitted, never guessed. Older
+#     six-field lines without them stay valid forever.
+#   - Outcomes (green means exactly what it claims):
+#       green     validation passed on the first recorded pipeline attempt
+#                 (fix-rounds 0)
+#       fixed     validation passed only after earlier recorded attempts
+#       failed    validation ran but its newest recorded attempt never
+#                 completed
+#       unknown   no validation result was derivable at teardown (scout
+#                 reports, direct-PR/local-only delivery, or unavailable run
+#                 records)
+#       discarded work was discarded by an approved --force teardown
 #   - Secondmate teardowns are not recorded (not a worker capability sample).
 #   - task-type is a free-form slug from meta task_type= when present, else kind
 #     (ship|scout). Firstmate should pass a stable slug at spawn for finer bins.
@@ -17,9 +33,10 @@
 #     cost-filtered profile set; this lib never invents a harness outside it and
 #     never bypasses third-party-model / crew-dispatch guards.
 #   - select=capability-recent ranks allowed profiles by green density
-#     (green / (green+discarded)) in the window; a sampled profile outranks an
-#     earlier unsampled one only when density > 0; all-zero or absent evidence
-#     keeps input (configured) order; no samples for a task-type keep the first.
+#     (first-try greens / all samples) in the window; a sampled profile
+#     outranks an earlier unsampled one only when density > 0; all-zero or
+#     absent evidence keeps input (configured) order; no samples for a
+#     task-type keep the first.
 #   - Scout tax (~10%): advisory CAPABILITY_SCOUT_TAX stderr suggestion of a
 #     different allowed profile; never changes the selected stdout profile.
 #     FM_CAPABILITY_SCOUT_TAX=0 disables; =1 forces; otherwise a roll
@@ -68,45 +85,102 @@ fm_capability_field_ok() {
 }
 
 # Append one outcome line. Args: task-type harness model effort outcome
+#   [fix-rounds] [steers]
+# Each count is optional: a non-empty value must be a non-negative integer.
+# An empty fix-rounds value retains its positional field when steers is present.
 # Best-effort: creates data/ as needed; returns non-zero on invalid fields or
 # write failure but never blocks teardown callers that ignore the status.
 fm_capability_log_append() {
   local task_type=$1 harness=$2 model=$3 effort=$4 outcome=$5
-  local log_path ts dir
+  local fix_rounds=${6:-} steers=${7:-}
+  local log_path ts dir line
   case "$outcome" in
-    green|discarded) ;;
+    green|fixed|failed|unknown|discarded) ;;
     *) return 1 ;;
   esac
   fm_capability_field_ok "$task_type" || return 1
   fm_capability_field_ok "$harness" || return 1
   fm_capability_field_ok "$model" || return 1
   fm_capability_field_ok "$effort" || return 1
+  case "$fix_rounds" in
+    '') ;;
+    *[!0-9]*) return 1 ;;
+  esac
+  case "$steers" in
+    '') ;;
+    *[!0-9]*) return 1 ;;
+  esac
   log_path=$(fm_capability_log_path)
   dir=$(dirname "$log_path")
   mkdir -p "$dir" || return 1
   ts=$(fm_capability_now)
   fm_capability_field_ok "$ts" || return 1
-  printf '%s|%s|%s|%s|%s|%s\n' "$ts" "$task_type" "$harness" "$model" "$effort" "$outcome" >> "$log_path"
+  line="$ts|$task_type|$harness|$model|$effort|$outcome"
+  case "$fix_rounds:$steers" in :) ;; *) line="$line|$fix_rounds" ;; esac
+  case "$steers" in '') ;; *) line="$line|$steers" ;; esac
+  printf '%s\n' "$line" >> "$log_path"
+}
+
+# Derive the teardown capability outcome from captured `no-mistakes runs` text.
+# Args: branch runs-output (empty when unavailable). Rows are newest-first,
+# whitespace-separated: <status> <branch> <sha> <date> <time> [url]; only
+# completed/failed/cancelled rows for the branch are samples. Prints
+# "<outcome>|<fix-rounds>" where fix-rounds is empty when not derivable:
+#   - no row for the branch            -> unknown|      (never guessed)
+#   - newest attempt completed, first  -> green|0       (first try)
+#   - newest attempt completed, later  -> fixed|<earlier-attempt-count>
+#   - newest attempt not completed     -> failed|
+fm_capability_outcome_from_runs() {
+  local branch=$1 runs=$2
+  [ -n "$branch" ] || { printf 'unknown|\n'; return 0; }
+  printf '%s\n' "$runs" | awk -v want="$branch" '
+    ($1 == "completed" || $1 == "failed" || $1 == "cancelled") && $2 == want {
+      if (seen != 1) { first = $1; seen = 1 }
+      total++
+    }
+    END {
+      if (total == 0) { printf "unknown|\n"; exit }
+      if (first == "completed") {
+        if (total == 1) { printf "green|0\n" }
+        else { printf "fixed|%d\n", total - 1 }
+      } else {
+        printf "failed|\n"
+      }
+    }
+  '
 }
 
-# Record teardown evidence from already-loaded meta fields.
-# Args: kind force_flag harness model effort [task_type]
-# force_flag is "--force" or empty. No-ops for secondmate and missing harness.
+# Record teardown evidence from already-loaded meta fields plus the derived
+# validation outcome. Args: kind force_flag harness model effort task_type
+#   outcome fix_rounds steers
+# force_flag is "--force" or empty: a forced discard always records discarded
+# without counts, whatever was derived. outcome must be one of the wire
+# outcomes whenever recording happens (the caller derives it from recorded
+# validation evidence); fix_rounds/steers are numeric strings or empty.
+# Unreadable or missing inputs skip the record rather than guess. No-ops for
+# secondmate and missing harness, and this function never fails its caller.
 fm_capability_record_teardown() {
   local kind=$1 force=$2 harness=$3 model=$4 effort=$5 task_type=${6:-}
-  local outcome
+  local outcome=${7:-} fix_rounds=${8:-} steers=${9:-}
   [ "$kind" = secondmate ] && return 0
   [ -n "$harness" ] || return 0
+  if [ "$force" = "--force" ]; then
+    outcome=discarded
+    fix_rounds=
+    steers=
+  fi
+  case "$outcome" in
+    green|fixed|failed|unknown|discarded) ;;
+    *) return 0 ;;
+  esac
+  case "$fix_rounds" in ''|*[!0-9]*) fix_rounds= ;; esac
+  case "$steers" in ''|*[!0-9]*) steers= ;; esac
   [ -n "$model" ] || model=default
   [ -n "$effort" ] || effort=default
   [ -n "$task_type" ] || task_type=$kind
   [ -n "$task_type" ] || task_type=ship
-  if [ "$force" = "--force" ]; then
-    outcome=discarded
-  else
-    outcome=green
-  fi
-  fm_capability_log_append "$task_type" "$harness" "$model" "$effort" "$outcome" || true
+  fm_capability_log_append "$task_type" "$harness" "$model" "$effort" \
+    "$outcome" "$fix_rounds" "$steers" || true
 }
 
 # Print recent matching lines for a task-type (stdout), one wire line each.
@@ -127,7 +201,9 @@ fm_capability_recent_lines() {
 # Summarize green density per harness|model|effort for a task-type.
 # Prints lines: <harness>|<model>|<effort>|<green>|<total>|<density_percent>
 # sorted by density desc, then total desc, then key asc. Density is integer
-# percent (green*100/total). Args: task-type
+# percent (green*100/total); green counts first-try passes only, while fixed,
+# failed, unknown, and discarded samples still count toward total.
+# Args: task-type
 fm_capability_summarize() {
   local task_type=$1
   fm_capability_recent_lines "$task_type" | awk -F'|' '
diff --git a/bin/fm-send.sh b/bin/fm-send.sh
index 3b5db6e474..59dbaa744e 100755
--- a/bin/fm-send.sh
+++ b/bin/fm-send.sh
@@ -40,6 +40,12 @@
 # footer appears, so an immediate peek would otherwise see the stale idle pane.
 # The pause is fm-send-only; the shared submit core (used by the away-mode daemon,
 # which only needs "submitted") does not pay it, and the --key path is unaffected.
+#
+# Every confirmed text submit to a task-selector target appends one line to
+# state/<id>.steers, the per-task supervisor steer counter that teardown reads
+# for the capability outcome log and removes with the rest of the volatile
+# state. Best-effort only; explicit backend targets and the --key path never
+# write it.
 set -eu
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
@@ -292,6 +298,12 @@ else
       exit 1
       ;;
   esac
+  # Confirmed submit: record one steer line for task-selector targets so
+  # teardown can report how many supervisor sends the task received. The file
+  # lives with the task's other volatile state and is never read elsewhere.
+  if [ -n "$TARGET_SELECTOR" ]; then
+    printf 'steer\n' >> "$STATE/$(fm_send_id_from_meta "$TARGET_META").steers" 2>/dev/null || true
+  fi
   if [ -n "$PENDING_REPLY_CORR" ]; then
     if fm_pending_reply_confirm_delivery "$STATE" "$PENDING_REPLY_CORR"; then
       :
diff --git a/bin/fm-teardown.sh b/bin/fm-teardown.sh
index 1b86e1c199..c13d1db923 100755
--- a/bin/fm-teardown.sh
+++ b/bin/fm-teardown.sh
@@ -79,7 +79,11 @@
 # checks before any destructive return. Teardown output notes every wait, retry, and
 # removal so the operator can see what happened.
 # On successful ship/scout cleanup, teardown appends one capability outcome line to
-# data/capability-outcomes.log (bin/fm-capability-lib.sh owns the wire format).
+# data/capability-outcomes.log. green means the task's validation passed on the
+# first try: the outcome is derived from the repo-scoped no-mistakes run records
+# for the task branch (gathered before destructive cleanup), never from the
+# teardown mode, and anything not derivable records unknown. bin/fm-capability-lib.sh
+# owns the wire format and outcome rules.
 set -eu
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
@@ -110,6 +114,8 @@ SUB_HOME_MARKER=".fm-secondmate-home"
 . "$SCRIPT_DIR/fm-public-followup-lib.sh"
 # shellcheck source=bin/fm-capability-lib.sh
 . "$SCRIPT_DIR/fm-capability-lib.sh"
+# shellcheck source=bin/fm-timeout-lib.sh
+. "$SCRIPT_DIR/fm-timeout-lib.sh"
 # shellcheck source=bin/fm-worktree-lease-lib.sh
 . "$SCRIPT_DIR/fm-worktree-lease-lib.sh"
 # shellcheck source=bin/fm-secondmate-registry-lib.sh
@@ -156,6 +162,43 @@ HARNESS=$(grep '^harness=' "$META" | cut -d= -f2- || true)
 MODEL=$(grep '^model=' "$META" | cut -d= -f2- || true)
 EFFORT=$(grep '^effort=' "$META" | cut -d= -f2- || true)
 TASK_TYPE=$(grep '^task_type=' "$META" | cut -d= -f2- || true)
+# Capability evidence gathering, best-effort and read-only, BEFORE any
+# destructive step: the task branch from the still-present worktree and the
+# recorded pipeline history from the repo-scoped no-mistakes run table (the
+# same durable record fm-crew-state.sh treats as the coarse run authority;
+# bounded probe via bin/fm-timeout-lib.sh). The worktree is the correct
+# working directory for that repo-scoped query and disappears below. Anything
+# unavailable degrades to outcome=unknown - never guessed, never fatal
+# (bin/fm-capability-lib.sh owns the outcome rules). The bound keeps very long
+# run histories honest-but-bounded: only the newest 200 recorded attempts are
+# considered.
+CAP_OUTCOME=
+CAP_FIX_ROUNDS=
+CAP_STEERS=
+if [ "$KIND" != secondmate ] && [ -n "$HARNESS" ]; then
+  if [ "$FORCE" != "--force" ]; then
+    CAP_OUTCOME=unknown
+  fi
+  CAP_BRANCH=
+  if [ -d "$WT" ]; then
+    CAP_BRANCH=$(git -C "$WT" rev-parse --abbrev-ref HEAD 2>/dev/null || true)
+    case "$CAP_BRANCH" in
+      ''|HEAD) CAP_BRANCH= ;;
+    esac
+  fi
+  if [ -n "$CAP_BRANCH" ] && [ "$FORCE" != "--force" ]; then
+    CAP_RUNS=$( ( cd "$WT" && fm_run_timeout 20 no-mistakes runs --limit 200 ) 2>/dev/null || true )
+    CAP_EVIDENCE=$(fm_capability_outcome_from_runs "$CAP_BRANCH" "$CAP_RUNS")
+    case "$CAP_EVIDENCE" in
+      *\|*)
+        CAP_OUTCOME=${CAP_EVIDENCE%%|*}
+        CAP_FIX_ROUNDS=${CAP_EVIDENCE#*|}
+        case "$CAP_FIX_ROUNDS" in ''|*[!0-9]*) CAP_FIX_ROUNDS= ;; esac
+        ;;
+      *) CAP_OUTCOME=$CAP_EVIDENCE ;;
+    esac
+  fi
+fi
 PUBLIC_FOLLOWUP_HOME=$FM_HOME
 PUBLIC_FOLLOWUP_STATE=$STATE
 PUBLIC_FOLLOWUP_WORK_HOME=main
@@ -1437,9 +1480,17 @@ rm -rf "$STATE/browse/$ID"
 remove_pr_poll_artifacts "$STATE" "$ID" || exit 1
 fm_pending_reply_remove_task "$STATE" "$ID"
 # Record capability evidence before meta disappears (ship/scout only; best-effort).
-fm_capability_record_teardown "$KIND" "$FORCE" "$HARNESS" "$MODEL" "$EFFORT" "$TASK_TYPE"
+# The steer counter is a volatile state file read here and removed below.
+if [ -f "$STATE/$ID.steers" ]; then
+  CAP_STEERS=$(grep -c . "$STATE/$ID.steers" 2>/dev/null || true)
+  case "$CAP_STEERS" in
+    ''|*[!0-9]*) CAP_STEERS= ;;
+  esac
+fi
+fm_capability_record_teardown "$KIND" "$FORCE" "$HARNESS" "$MODEL" "$EFFORT" \
+  "$TASK_TYPE" "$CAP_OUTCOME" "$CAP_FIX_ROUNDS" "$CAP_STEERS"
 remove_captain_held_surfaced_markers "$STATE" "$ID" "$T"
-rm -f "$STATE/$ID.status" "$STATE/$ID.turn-ended" "$STATE/$ID.meta" "$STATE/$ID.pi-ext.ts" "$STATE/$ID.prime-ext.ts" "$STATE/$ID.grok-turnend-token"
+rm -f "$STATE/$ID.status" "$STATE/$ID.turn-ended" "$STATE/$ID.meta" "$STATE/$ID.pi-ext.ts" "$STATE/$ID.prime-ext.ts" "$STATE/$ID.grok-turnend-token" "$STATE/$ID.steers"
 rm -rf "$STATE/$ID.kimi-home" "$STATE/$ID.prime-agent-home"
 "$FM_ROOT/bin/fm-visible-status.sh" --all >/dev/null 2>&1 || true
 if [ "$KIND" != scout ] && [ "$KIND" != secondmate ] && [ "$MODE" != local-only ]; then
diff --git a/bin/fm-test-run.sh b/bin/fm-test-run.sh
index 058ed7f15e..ac3fd65049 100755
--- a/bin/fm-test-run.sh
+++ b/bin/fm-test-run.sh
@@ -361,6 +361,7 @@ tests/fm-gotmp.test.sh
 tests/fm-toolchain-drift.test.sh
 tests/fm-sessionstart-nudge.test.sh
 tests/fm-operational-input.test.sh
+tests/fm-send-steer-count.test.sh
 tests/fm-project-presentation.test.sh
 tests/fm-bearings-skill.test.sh
 tests/fm-kimi-worker.test.sh
diff --git a/docs/configuration.md b/docs/configuration.md
index 8fa10dedeb..14fdb6a9e9 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -310,24 +310,31 @@ Secondmate homes inherit this file from the primary, so a secondmate's own crewm
 ## Capability outcome log (data/capability-outcomes.log)
 
 Firstmate records how each harness/model/effort combination performs per task type so dispatch can consult recent evidence without replacing cost rules.
-`bin/fm-capability-lib.sh` owns the wire format, the 7-day recency window, ranking, and the advisory scout-tax suggestion.
-`bin/fm-teardown.sh` appends one line on successful ship or scout cleanup (not secondmate), and `bin/fm-dispatch-select.sh --task-type <slug>` surfaces the window for that slug.
+`bin/fm-capability-lib.sh` owns the wire format, the outcome rules, the 7-day recency window, ranking, and the advisory scout-tax suggestion.
+`bin/fm-teardown.sh` appends one line on ship or scout cleanup (not secondmate), and `bin/fm-dispatch-select.sh --task-type <slug>` surfaces the window for that slug.
 The log is a captain-inspectable plain-text file under the home's private `data/`; there is no new runtime dependency.
 
 Each append-only line is:
 
 ```text
-<unix-epoch>|<task-type>|<harness>|<model>|<effort>|<outcome>
+<unix-epoch>|<task-type>|<harness>|<model>|<effort>|<outcome>[|<fix-rounds>[|<steers>]]
 ```
 
-`outcome` is `green` for a normal landed teardown or `discarded` for `--force`.
+`outcome` is derived from the task's recorded validation result at teardown, never from the teardown mode.
+`green` means validation passed on the first try: exactly one pipeline attempt is recorded for the task branch.
+`fixed` means validation passed only after earlier recorded attempts, and its `fix-rounds` field counts those earlier attempts.
+`failed` means validation ran but its newest recorded attempt never completed.
+`unknown` means no validation result was derivable (scout reports, direct-PR or local-only delivery, or unavailable run records).
+`discarded` records an approved `--force` teardown.
+The trailing counts are written only when derivable: `steers` counts confirmed supervisor sends recorded per task by `bin/fm-send.sh`, and an empty `fix-rounds` slot is retained when only `steers` is known.
+Older six-field lines without trailing counts stay valid, and readers treat missing counts as absent rather than guessing them.
 `task-type` comes from meta `task_type=` when `fm-spawn.sh --task-type <slug>` recorded it, otherwise from `kind` (`ship` or `scout`).
 Fields never contain `|` or newlines.
 
 Cost rules in `config/crew-dispatch.json` always win: evidence only ranks or advises within the already cost-filtered `use` array and never bypasses the third-party-model guard.
 With `--task-type`, dispatch-select prints `CAPABILITY_EVIDENCE:` lines on stderr for firstmate.
 About 10% of those dispatches may also print one `CAPABILITY_SCOUT_TAX:` suggestion naming a different allowed profile; that suggestion is advisory and never changes the selected stdout profile.
-`select: capability-recent` makes ranking choose the best recent green density inside the allowed array; a sampled profile outranks an earlier unsampled one only when density is greater than 0, and absent or all-zero evidence keeps configured input order.
+`select: capability-recent` makes ranking choose the best recent green density inside the allowed array, where green strictly means first-try passes; a sampled profile outranks an earlier unsampled one only when density is greater than 0, and absent or all-zero evidence keeps configured input order.
 Overrides for tests and ops live under Environment variables (`FM_CAPABILITY_*`).
 
 ## Toolchain
diff --git a/docs/scripts.md b/docs/scripts.md
index c6eff94779..10da2303f6 100644
--- a/docs/scripts.md
+++ b/docs/scripts.md
@@ -58,7 +58,7 @@ The shared no-mistakes gate refusal for fleet lifecycle entrypoints is summarize
 | `fm-home-seed.sh`        | Transactionally provision a secondmate home and maintain `data/secondmates.md`       |
 | `fm-spawn.sh`            | Spawn crewmates, scouts, `id=repo` batches, and secondmates on the resolved harness and runtime backend |
 | `fm-dispatch-select.sh`  | Resolve a matched crew-dispatch rule to one concrete profile, owning `quota-balanced` and `capability-recent` selection plus capability evidence surfacing |
-| `fm-capability-lib.sh`   | Append-only capability outcome log, 7-day reader, ranking, and advisory scout-tax helpers |
+| `fm-capability-lib.sh`   | Append-only capability outcome log (green means first-try validation pass), 7-day reader, ranking, and advisory scout-tax helpers |
 | `fm-backend.sh`          | Runtime-backend selection, meta helpers, selector resolution, and operation dispatch |
 | `fm-backend-hometag-lib.sh` | Shared per-installation home-tag derivation for zellij tab and cmux workspace titles |
 | `fm-composer-lib.sh`     | Single fleet-wide owner of composer-content classification for all backends          |
diff --git a/fork-surface.conf b/fork-surface.conf
index 36aa420ae5..9761ed2367 100644
--- a/fork-surface.conf
+++ b/fork-surface.conf
@@ -329,13 +329,16 @@ status = active
 why = Dispatch can consider observed outcomes for a task type alongside configured cost rules.
 owns = bin/fm-capability-lib.sh
 owns = tests/fm-capability.test.sh
+owns = tests/fm-send-steer-count.test.sh
 modifies = bin/fm-dispatch-select.sh
+modifies = bin/fm-send.sh
 modifies = bin/fm-spawn.sh
 modifies = bin/fm-teardown.sh
 modifies = bin/fm-bootstrap.sh
 anchor = bin/fm-teardown.sh :: fm_capability_record_teardown
 anchor = bin/fm-dispatch-select.sh :: ^emit_capability_advisories\(\)
 proves = tests/fm-capability.test.sh
+proves = tests/fm-send-steer-count.test.sh
 assert = files+test
 commits = 52cad29 bb0867c
 topology = independent
diff --git a/tests/fm-capability.test.sh b/tests/fm-capability.test.sh
index 5fac316912..5c65d834b6 100755
--- a/tests/fm-capability.test.sh
+++ b/tests/fm-capability.test.sh
@@ -59,19 +59,106 @@ test_summarize_green_density() {
 
 test_record_teardown_outcomes() {
   rm -f "$FM_CAPABILITY_LOG"
-  fm_capability_record_teardown ship '' cursor grok medium bugfix
-  fm_capability_record_teardown ship --force cursor grok medium bugfix
-  fm_capability_record_teardown secondmate '' claude sonnet high ''
+  # Truegreen contract: the caller derives the outcome from recorded validation
+  # evidence; counts ride along only when derivable.
+  fm_capability_record_teardown ship '' cursor grok medium bugfix green 0 3
+  fm_capability_record_teardown ship '' cursor grok medium bugfix fixed 2 ''
+  fm_capability_record_teardown ship '' cursor grok medium bugfix failed '' 1
+  fm_capability_record_teardown scout '' claude sonnet high report unknown '' ''
+  fm_capability_record_teardown ship --force cursor grok medium bugfix green 0 3
+  fm_capability_record_teardown secondmate '' claude sonnet high '' unknown '' ''
   local body
   body=$(cat "$FM_CAPABILITY_LOG")
-  assert_contains "$body" '|bugfix|cursor|grok|medium|green' \
-    "normal teardown should log green with task_type"
+  assert_contains "$body" '|bugfix|cursor|grok|medium|green|0|3' \
+    "first-try pass should log green with both counts"
+  assert_contains "$body" '|bugfix|cursor|grok|medium|fixed|2' \
+    "pass after fix rounds should log fixed with its fix-round count"
+  assert_contains "$body" '|bugfix|cursor|grok|medium|failed||1' \
+    "a steer-only record should retain the empty fix-rounds slot"
+  case "$body" in
+    *'|fixed|2|'*) fail "a fix-round-only record must omit the absent steer slot: $body" ;;
+  esac
+  assert_contains "$body" '|report|claude|sonnet|high|unknown' \
+    "underivable validation should log unknown without counts"
   assert_contains "$body" '|bugfix|cursor|grok|medium|discarded' \
-    "force teardown should log discarded"
+    "force teardown should still log discarded"
+  local discarded_line
+  discarded_line=$(grep discarded "$FM_CAPABILITY_LOG")
+  case "$discarded_line" in
+    *'|discarded|0|3') fail "force teardown must not carry derived counts: $discarded_line" ;;
+  esac
   case "$body" in
-    *secondmate*|*'|claude|'*) fail "secondmate teardown must not write capability lines" ;;
+    *secondmate*|*'|claude|sonnet|high|green'*) fail "secondmate teardown must not write capability lines" ;;
   esac
-  pass "teardown recorder writes green/discarded and skips secondmate"
+  pass "teardown recorder writes derived outcomes with optional counts and skips secondmate"
+}
+
+test_outcome_derivation_from_runs_rows() {
+  local got runs
+  # Rows are newest-first, matching `no-mistakes runs` output exactly.
+  runs='  completed    fm/task-x1 c301eb14  2026-08-20 17:12  https://github.com/example/repo/pull/9'
+  got=$(fm_capability_outcome_from_runs fm/task-x1 "$runs")
+  [ "$got" = 'green|0' ] || fail "single completed attempt should be green|0, got: $got"
+
+  runs='  completed    fm/task-x1 c301eb14  2026-08-20 17:12  https://github.com/example/repo/pull/9
+  failed       fm/task-x1 d7bf67d7  2026-08-14 03:37'
+  got=$(fm_capability_outcome_from_runs fm/task-x1 "$runs")
+  [ "$got" = 'fixed|1' ] || fail "completed after one earlier attempt should be fixed|1, got: $got"
+
+  runs='  completed    fm/task-x1 c301eb14  2026-08-20 17:12
+  failed       fm/task-x1 d7bf67d7  2026-08-14 03:37
+  cancelled    fm/task-x1 365e7449  2026-08-12 01:12
+  cancelled    fm/other-task 99e19551  2026-08-11 21:58
+  (171 more runs, use --limit to see more)'
+  got=$(fm_capability_outcome_from_runs fm/task-x1 "$runs")
+  [ "$got" = 'fixed|2' ] || fail "other branches and footer rows must be ignored, got: $got"
+
+  runs='  cancelled    fm/task-x1 365e7449  2026-08-12 01:12
+  failed       fm/task-x1 d7bf67d7  2026-08-14 03:37'
+  got=$(fm_capability_outcome_from_runs fm/task-x1 "$runs")
+  [ "$got" = 'failed|' ] || fail "no completed attempt should be failed, got: $got"
+
+  got=$(fm_capability_outcome_from_runs fm/task-x1 '')
+  [ "$got" = 'unknown|' ] || fail "empty run records must be unknown, got: $got"
+  got=$(fm_capability_outcome_from_runs '' '  completed fm/task-x1 a b c')
+  [ "$got" = 'unknown|' ] || fail "missing branch must be unknown, got: $got"
+  got=$(fm_capability_outcome_from_runs fm/task-x1 '  completed    fm/other x 2026-08-20 17:12')
+  [ "$got" = 'unknown|' ] || fail "unmatched branch must be unknown, got: $got"
+  pass "run-table derivation yields first-try green, fixed, failed, or unknown"
+}
+
+test_reader_handles_old_and_new_lines() {
+  rm -f "$FM_CAPABILITY_LOG"
+  FM_CAPABILITY_NOW=1700000000
+  # Old six-field wire format written by pre-truegreen teardowns, alongside
+  # new seven- and eight-field lines.
+  printf '%s\n' \
+    '1699999000|legacy|claude|sonnet|high|green' \
+    '1699999100|truegreen|claude|sonnet|high|green|0|4' \
+    '1699999200|truegreen|claude|sonnet|high|fixed|2' \
+    >> "$FM_CAPABILITY_LOG"
+
+  local recent summary out
+  recent=$(fm_capability_recent_lines truegreen)
+  assert_contains "$recent" '|claude|sonnet|high|green|0|4' \
+    "reader should return new eight-field lines intact"
+  summary=$(fm_capability_summarize truegreen)
+  assert_contains "$summary" 'claude|sonnet|high|1|2|50' \
+    "density must count only first-try greens over all samples"
+  summary=$(fm_capability_summarize legacy)
+  assert_contains "$summary" 'claude|sonnet|high|1|1|100' \
+    "old six-field lines must still parse and rank"
+
+  local profiles
+  profiles='[{"harness":"codex","model":"gpt-5.5","effort":"high"},{"harness":"claude","model":"sonnet","effort":"high"}]'
+  fm_capability_log_append truegreen codex gpt-5.5 high green 0 0
+  out=$(FM_CAPABILITY_SCOUT_TAX=0 "$ROOT/bin/fm-dispatch-select.sh" \
+    --select capability-recent \
+    --task-type truegreen \
+    "$profiles" 2>/dev/null)
+  [ "$out" = '{"harness":"codex","model":"gpt-5.5","effort":"high"}' ] \
+    || fail "capability-recent should rank on true greens across mixed-format lines, got: $out"
+  pass "reader handles old and new wire lines side by side"
 }
 
 test_capability_recent_select_and_scout_tax_advisory() {
@@ -174,6 +261,8 @@ test_reject_pipe_in_fields() {
 test_log_append_and_recent_window
 test_summarize_green_density
 test_record_teardown_outcomes
+test_outcome_derivation_from_runs_rows
+test_reader_handles_old_and_new_lines
 test_capability_recent_select_and_scout_tax_advisory
 test_first_profile_unchanged_without_capability_select
 test_zero_green_sampled_does_not_beat_earlier_untried
diff --git a/tests/fm-gotmp.test.sh b/tests/fm-gotmp.test.sh
index 18df237d2a..a682232dc6 100755
--- a/tests/fm-gotmp.test.sh
+++ b/tests/fm-gotmp.test.sh
@@ -71,6 +71,8 @@ SH
   ln -s "$ROOT/bin/fm-x-lib.sh" "$fake/bin/fm-x-lib.sh"
   # fm-capability-lib.sh: teardown records capability outcomes before meta removal.
   ln -s "$ROOT/bin/fm-capability-lib.sh" "$fake/bin/fm-capability-lib.sh"
+  # fm-timeout-lib.sh: teardown bounds its capability run-record probe with it.
+  ln -s "$ROOT/bin/fm-timeout-lib.sh" "$fake/bin/fm-timeout-lib.sh"
   # fm-classify-lib.sh: the one owner of the captain-held one-shot marker paths
   # teardown removes alongside the task's other volatile state.
   ln -s "$ROOT/bin/fm-classify-lib.sh" "$fake/bin/fm-classify-lib.sh"
diff --git a/tests/fm-send-steer-count.test.sh b/tests/fm-send-steer-count.test.sh
new file mode 100755
index 0000000000..a691b9776d
--- /dev/null
+++ b/tests/fm-send-steer-count.test.sh
@@ -0,0 +1,135 @@
+#!/usr/bin/env bash
+# fm-send per-task supervisor steer counter (state/<id>.steers).
+#
+# Teardown's capability outcome log records how many supervisor steers a task
+# received, so every confirmed text submit to a task-selector target must
+# append exactly one line to that task's volatile counter file. These tests pin
+# that behavior hermetically (stubbed tmux, no real agent):
+#   1. Confirmed sends to an exact-id or stable-label task target count once each.
+#   2. Explicit backend targets never write a counter (no task identity).
+#   3. The --key path never counts.
+#   4. A swallowed Enter (pending verdict) is not a delivered steer and never counts.
+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-steer-count)
+
+# The same hermetic submit stub used across the fm-send suites: display-message
+# yields a numeric cursor_y; capture-pane's FM_STEER_COMPOSER value decides the
+# verdict - an empty bordered composer reads "empty" (submit landed), a bordered
+# composer with text reads "pending" (Enter swallowed).
+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 '0\n'; exit 0 ;; esac; done
+    printf 'fakepane\n'; exit 0 ;;
+  capture-pane) printf '%s\n' "${FM_STEER_COMPOSER:-$(printf '\xe2\x94\x82 \xe2\x94\x82')}"; exit 0 ;;
+  list-windows) exit 0 ;;
+esac
+exit 0
+SH
+  cat > "$fb/sleep" <<'SH'
+#!/usr/bin/env bash
+exit 0
+SH
+  chmod +x "$fb/tmux" "$fb/sleep"
+  printf '%s\n' "$fb"
+}
+
+setup_home() {  # <name> -> echoes home dir with a crewmate task meta
+  local home="$TMP_ROOT/$1-$RANDOM"
+  mkdir -p "$home/state"
+  fm_write_meta "$home/state/build.meta" \
+    "window=sess:fm-build" "worktree=$home/wt" "project=$home/p" \
+    "harness=claude" "kind=ship" "mode=no-mistakes" "yolo=off"
+  printf '%s\n' "$home"
+}
+
+run_send() {  # <fakebin> <home> <fm-send args...>
+  local fb=$1 home=$2; shift 2
+  # Extra caller environment (e.g. FM_STEER_COMPOSER) may prefix the call.
+  env PATH="$fb:$PATH" \
+    FM_ROOT_OVERRIDE="$home" FM_HOME="$home" FM_SEND_SETTLE=0 \
+    "$SEND" "$@" 2>/dev/null
+}
+
+test_confirmed_sends_count_once_each() {
+  local dir fb home rc
+  dir="$TMP_ROOT/count"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir")
+  home=$(setup_home count)
+  run_send "$fb" "$home" "fm-build" "fix the flaky test"; rc=$?
+  expect_code 0 "$rc" "first confirmed steer should succeed"
+  run_send "$fb" "$home" "build" "rerun the suite"; rc=$?
+  expect_code 0 "$rc" "second confirmed steer should succeed"
+  [ "$(wc -l < "$home/state/build.steers" | tr -d ' ')" = 2 ] \
+    || fail "two confirmed steers must append two counter lines"$'\n'"--- counter ---"$'\n'"$(cat "$home/state/build.steers")"
+  pass "fm-send appends one steer line per confirmed task-target submit"
+}
+
+test_explicit_target_never_counts() {
+  local dir fb home rc
+  dir="$TMP_ROOT/explicit"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir")
+  home=$(setup_home explicit)
+  run_send "$fb" "$home" "sess:win" "hello there"; rc=$?
+  expect_code 0 "$rc" "explicit-target send should succeed"
+  [ ! -e "$home/state/build.steers" ] \
+    || fail "an explicit backend target without task identity must not write a counter"
+  pass "explicit backend targets leave no steer counter"
+}
+
+test_explicit_recorded_target_never_counts() {
+  local dir fb home rc
+  dir="$TMP_ROOT/explicit-recorded"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir")
+  home=$(setup_home explicit-recorded)
+  run_send "$fb" "$home" "sess:fm-build" "hello recorded endpoint"; rc=$?
+  expect_code 0 "$rc" "explicit recorded-target send should succeed"
+  [ ! -e "$home/state/build.steers" ] \
+    || fail "an explicit backend target matching task metadata must not write a counter"
+  pass "explicit recorded backend targets leave no steer counter"
+}
+
+test_key_path_never_counts() {
+  local dir fb home rc
+  dir="$TMP_ROOT/keypath"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir")
+  home=$(setup_home keypath)
+  run_send "$fb" "$home" "build" --key Enter; rc=$?
+  expect_code 0 "$rc" "--key send should succeed"
+  [ ! -e "$home/state/build.steers" ] \
+    || fail "the --key path is not a steer and must not write a counter"
+  pass "the --key path leaves no steer counter"
+}
+
+test_swallowed_enter_never_counts() {
+  local dir fb home rc
+  dir="$TMP_ROOT/pending"; mkdir -p "$dir"
+  fb=$(make_stubs "$dir")
+  home=$(setup_home pending)
+  FM_STEER_COMPOSER="$(printf '\xe2\x94\x82 leftover \xe2\x94\x82')" \
+    run_send "$fb" "$home" "build" "this enter will be swallowed"; rc=$?
+  [ "$rc" -ne 0 ] || fail "a swallowed Enter must fail the send loudly, got exit 0"
+  [ ! -e "$home/state/build.steers" ] \
+    || fail "a submit firstmate could not confirm must not count as a steer"
+  pass "unconfirmed submits leave no steer counter"
+}
+
+test_confirmed_sends_count_once_each
+test_explicit_target_never_counts
+test_explicit_recorded_target_never_counts
+test_key_path_never_counts
+test_swallowed_enter_never_counts
+
+echo "# all fm-send-steer-count tests passed"
diff --git a/tests/fm-teardown.test.sh b/tests/fm-teardown.test.sh
index 7554995f19..3eac4f7c22 100755
--- a/tests/fm-teardown.test.sh
+++ b/tests/fm-teardown.test.sh
@@ -498,15 +498,33 @@ SH
 }
 
 # Run teardown with PATH mocking. Args: case_dir [extra args...]
+# FM_CAPABILITY_LOG is redirected into the case dir so capability outcome lines
+# land under test observation instead of any real home's data/ directory.
 run_teardown() {
   local case_dir=$1; shift
   FM_ROOT_OVERRIDE="$ROOT" \
   FM_STATE_OVERRIDE="$case_dir/state" \
   FM_CONFIG_OVERRIDE="$case_dir/config" \
+  FM_CAPABILITY_LOG="$case_dir/state/capability-outcomes.log" \
   PATH="$case_dir/fakebin:$PATH" \
     "$TEARDOWN" task-x1 "$@"
 }
 
+# Add a fake no-mistakes CLI whose `runs` subcommand prints the given rows file.
+# Anything else exits 0 silently. Args: case_dir rows_file
+add_no_mistakes_runs_fake() {
+  local case_dir=$1 rows=$2
+  cat > "$case_dir/fakebin/no-mistakes" <<SH
+#!/usr/bin/env bash
+if [ "\${1:-}" = runs ]; then
+  cat '$rows' 2>/dev/null || true
+  exit 0
+fi
+exit 0
+SH
+  chmod +x "$case_dir/fakebin/no-mistakes"
+}
+
 test_local_only_fork_remote_allows() {
   local case_dir rc
   case_dir=$(make_case fork-allow)
@@ -684,6 +702,168 @@ test_no_mistakes_origin_remote_allows() {
   pass "no-mistakes worktree with HEAD on origin is torn down (no regression)"
 }
 
+# Add capability-recording meta keys to the task meta. Args: case_dir
+add_capability_meta() {
+  local case_dir=$1
+  printf '%s\n' \
+    'harness=claude' \
+    'model=sonnet' \
+    'effort=high' \
+    'task_type=truegreen-e2e' >> "$case_dir/state/task-x1.meta"
+}
+
+test_teardown_records_truegreen_capability_line() {
+  local case_dir rc rows log_line
+  case_dir=$(make_case truegreen)
+  write_meta "$case_dir" no-mistakes ship
+  add_capability_meta "$case_dir"
+  wt_commit "$case_dir" "shippable work"
+  git -C "$case_dir/wt" push -q origin fm/task-x1
+  git -C "$case_dir/project" fetch -q origin
+  # Exactly one recorded pipeline attempt for this branch: first-try green.
+  rows="$case_dir/rows.txt"
+  printf '%s\n' \
+    '  completed    fm/task-x1 c301eb14  2026-08-20 17:12  https://github.com/example/repo/pull/9' \
+    > "$rows"
+  add_no_mistakes_runs_fake "$case_dir" "$rows"
+  printf 'steer\nsteer\nsteer\n' > "$case_dir/state/task-x1.steers"
+
+  set +e
+  run_teardown "$case_dir" > "$case_dir/stdout" 2> "$case_dir/stderr"
+  rc=$?
+  set -e
+
+  expect_code 0 "$rc" "truegreen: teardown should succeed for landed work"
+  log_line=$(grep -F '|truegreen-e2e|claude|sonnet|high|' "$case_dir/state/capability-outcomes.log")
+  case "$log_line" in
+    *'|green|0|3') : ;;
+    *) fail "first-try pass must record green with fix-rounds 0 and steer count 3, got: $log_line" ;;
+  esac
+  [ ! -e "$case_dir/state/task-x1.steers" ] \
+    || fail "teardown must remove the volatile steer counter file"
+  pass "teardown derives first-try green from recorded runs and consumes the steer counter"
+}
+
+test_teardown_records_fixed_after_fix_rounds_not_green() {
+  local case_dir rc rows body
+  case_dir=$(make_case fixed-green)
+  write_meta "$case_dir" no-mistakes ship
+  add_capability_meta "$case_dir"
+  wt_commit "$case_dir" "shippable work"
+  git -C "$case_dir/wt" push -q origin fm/task-x1
+  git -C "$case_dir/project" fetch -q origin
+  # A failed attempt before the completing one: landed, but NOT first try.
+  rows="$case_dir/rows.txt"
+  printf '%s\n' \
+    '  completed    fm/task-x1 c301eb14  2026-08-20 17:12' \
+    '  failed       fm/task-x1 d7bf67d7  2026-08-14 03:37' \
+    '  cancelled    fm/other-task 99e19551  2026-08-11 21:58' \
+    > "$rows"
+  add_no_mistakes_runs_fake "$case_dir" "$rows"
+
+  set +e
+  run_teardown "$case_dir" > "$case_dir/stdout" 2> "$case_dir/stderr"
+  rc=$?
+  set -e
+
+  expect_code 0 "$rc" "fixed-green: teardown should succeed for landed work"
+  body=$(cat "$case_dir/state/capability-outcomes.log")
+  case "$body" in
+    *'|fixed|1') : ;;
+    *) fail "landed-after-fix-rounds must record fixed|1, got: $body" ;;
+  esac
+  case "$body" in
+    *'|green'*) fail "a late pass must never be recorded green: $body" ;;
+  esac
+  pass "teardown records fixed after fix rounds and keeps green first-try only"
+}
+
+test_teardown_records_failed_when_validation_never_completed() {
+  local case_dir rc rows body
+  case_dir=$(make_case failed-cap)
+  write_meta "$case_dir" no-mistakes ship
+  add_capability_meta "$case_dir"
+  wt_commit "$case_dir" "shippable work"
+  git -C "$case_dir/wt" push -q origin fm/task-x1
+  git -C "$case_dir/project" fetch -q origin
+  rows="$case_dir/rows.txt"
+  printf '%s\n' \
+    '  cancelled    fm/task-x1 365e7449  2026-08-12 01:12' \
+    '  failed       fm/task-x1 d7bf67d7  2026-08-14 03:37' \
+    > "$rows"
+  add_no_mistakes_runs_fake "$case_dir" "$rows"
+
+  set +e
+  run_teardown "$case_dir" > "$case_dir/stdout" 2> "$case_dir/stderr"
+  rc=$?
+  set -e
+
+  expect_code 0 "$rc" "failed-cap: teardown should succeed for landed work"
+  body=$(cat "$case_dir/state/capability-outcomes.log")
+  case "$body" in
+    *'|failed'*) : ;;
+    *) fail "never-completed validation must record failed, got: $body" ;;
+  esac
+  case "$body" in
+    *'|green'*|*'|fixed'*) fail "failed validation must not read as success: $body" ;;
+  esac
+  pass "teardown records failed when no pipeline attempt completed"
+}
+
+test_teardown_records_unknown_without_run_records() {
+  local case_dir rc body
+  case_dir=$(make_case unknown-cap)
+  write_meta "$case_dir" no-mistakes ship
+  add_capability_meta "$case_dir"
+  wt_commit "$case_dir" "shippable work"
+  git -C "$case_dir/wt" push -q origin fm/task-x1
+  git -C "$case_dir/project" fetch -q origin
+  # The fake CLI answers runs with nothing at all: unavailable evidence.
+  rows="$case_dir/rows.txt"
+  : > "$rows"
+  add_no_mistakes_runs_fake "$case_dir" "$rows"
+
+  set +e
+  run_teardown "$case_dir" > "$case_dir/stdout" 2> "$case_dir/stderr"
+  rc=$?
+  set -e
+
+  expect_code 0 "$rc" "unknown-cap: teardown should succeed for landed work"
+  body=$(cat "$case_dir/state/capability-outcomes.log")
+  case "$body" in
+    *'|unknown'*) : ;;
+    *) fail "missing run records must record unknown rather than guess, got: $body" ;;
+  esac
+  case "$body" in
+    *'|green'*) fail "absent evidence must never be recorded green: $body" ;;
+  esac
+  pass "teardown records unknown when validation evidence is absent"
+}
+
+test_teardown_records_unknown_without_branch_name() {
+  local case_dir rc body
+  case_dir=$(make_case unknown-detached-cap)
+  write_meta "$case_dir" no-mistakes ship
+  add_capability_meta "$case_dir"
+  wt_commit "$case_dir" "shippable detached work"
+  git -C "$case_dir/wt" push -q origin fm/task-x1
+  git -C "$case_dir/project" fetch -q origin
+  git -C "$case_dir/wt" checkout -q --detach
+
+  set +e
+  run_teardown "$case_dir" > "$case_dir/stdout" 2> "$case_dir/stderr"
+  rc=$?
+  set -e
+
+  expect_code 0 "$rc" "unknown-detached-cap: teardown should succeed for landed work"
+  body=$(cat "$case_dir/state/capability-outcomes.log")
+  case "$body" in
+    *'|truegreen-e2e|claude|sonnet|high|unknown') : ;;
+    *) fail "an unavailable branch name must record unknown, got: $body" ;;
+  esac
+  pass "teardown records unknown when the branch name is unavailable"
+}
+
 test_no_mistakes_truly_unpushed_refuses() {
   local case_dir rc
   case_dir=$(make_case nm-unpushed)
@@ -1411,6 +1591,11 @@ test_teardown_manual_backend_prompts_hand_edit_even_when_tasks_axi_present
 test_local_only_truly_unpushed_refuses
 test_local_only_merged_to_local_main_allows
 test_no_mistakes_origin_remote_allows
+test_teardown_records_truegreen_capability_line
+test_teardown_records_fixed_after_fix_rounds_not_green
+test_teardown_records_failed_when_validation_never_completed
+test_teardown_records_unknown_without_run_records
+test_teardown_records_unknown_without_branch_name
 test_no_mistakes_truly_unpushed_refuses
 test_local_only_force_overrides_unpushed
 test_herdr_teardown_clears_escalation_marker