diff --git a/.agents/skills/harness-adapters/SKILL.md b/.agents/skills/harness-adapters/SKILL.md
index 86dbfd2ee5..8dae80da56 100644
--- a/.agents/skills/harness-adapters/SKILL.md
+++ b/.agents/skills/harness-adapters/SKILL.md
@@ -105,6 +105,7 @@ This preserves launch success instead of passing a known-bad value.
 
 Send the validation skill using the target harness's skill invocation form.
 Natural language is acceptable if uncertain.
+`fm-send` refuses a bare installed-skill token whose prefix conflicts with the resolved harness, and names the correct form instead of silently rewriting a caller bug.
 
 - claude: `/<skill>`, for example `/no-mistakes`.
 - codex: `$<skill>`, for example `$no-mistakes`; `/<skill>` is claude-only and codex rejects it as "Unrecognized command".
diff --git a/bin/fm-account-continuation.sh b/bin/fm-account-continuation.sh
index 103bf349f8..15d4d8f65f 100755
--- a/bin/fm-account-continuation.sh
+++ b/bin/fm-account-continuation.sh
@@ -245,6 +245,26 @@ cd "$WORKTREE_REAL" \
 exec 9< . \
   || { echo "error: continuation worktree cannot be pinned for $ID" >&2; exit 1; }
 cd "$ORIGINAL_CWD" || exit 1
+
+if [ "$KIND" = secondmate ]; then
+  BRIEF_SNAPSHOT_TMP=$(mktemp "$STATE/.continuation-brief-$ID.XXXXXX") \
+    || { echo "error: cannot stage original brief or charter for continuation of $ID" >&2; exit 1; }
+  if python3 "$SCRIPT_DIR/fm-contained-read.py" cat-optional-fd data/charter.md "$MAX_PACKET_BYTES" 3<&9 \
+    > "$BRIEF_SNAPSHOT_TMP" 2>/dev/null; then
+    [ -s "$BRIEF_SNAPSHOT_TMP" ] \
+      || { echo "error: secondmate charter is empty for continuation of $ID" >&2; exit 1; }
+  else
+    charter_status=$?
+    if [ "$charter_status" -eq 3 ]; then
+      rm -f "$BRIEF_SNAPSHOT_TMP"
+      BRIEF_SNAPSHOT_TMP=
+    else
+      echo "error: secondmate charter is present but unsafe for continuation of $ID" >&2
+      exit 1
+    fi
+  fi
+fi
+
 git_pinned() {
   python3 "$SCRIPT_DIR/fm-contained-read.py" git-fd "$@" 3<&9
 }
@@ -293,24 +313,7 @@ if ! node "$CONTAINED_READ" snapshot "$TASK_DIR" "$TASK_SNAPSHOT_DIR" 1048576 "$
   exit 1
 fi
 
-if [ "$KIND" = secondmate ]; then
-  BRIEF_SNAPSHOT_TMP=$(mktemp "$STATE/.continuation-brief-$ID.XXXXXX") \
-    || { echo "error: cannot stage original brief or charter for continuation of $ID" >&2; exit 1; }
-  if python3 "$SCRIPT_DIR/fm-contained-read.py" cat-optional-fd data/charter.md "$MAX_PACKET_BYTES" 3<&9 \
-    > "$BRIEF_SNAPSHOT_TMP" 2>/dev/null; then
-    [ -s "$BRIEF_SNAPSHOT_TMP" ] \
-      || { echo "error: secondmate charter is empty for continuation of $ID" >&2; exit 1; }
-  else
-    charter_status=$?
-    if [ "$charter_status" -eq 3 ]; then
-      rm -f "$BRIEF_SNAPSHOT_TMP"
-      BRIEF_SNAPSHOT_TMP="$TASK_SNAPSHOT_DIR/0.snapshot"
-    else
-      echo "error: secondmate charter is present but unsafe for continuation of $ID" >&2
-      exit 1
-    fi
-  fi
-else
+if [ "$KIND" != secondmate ] || [ -z "$BRIEF_SNAPSHOT_TMP" ]; then
   BRIEF_SNAPSHOT_TMP="$TASK_SNAPSHOT_DIR/0.snapshot"
 fi
 [ -s "$BRIEF_SNAPSHOT_TMP" ] \
diff --git a/bin/fm-account-directory.sh b/bin/fm-account-directory.sh
index 3ba66b5462..72b9732831 100755
--- a/bin/fm-account-directory.sh
+++ b/bin/fm-account-directory.sh
@@ -2,6 +2,7 @@
 # Select and prepare direct Claude or Codex account-directory launches.
 # Usage:
 #   fm-account-directory.sh select <claude|codex>
+#   fm-account-directory.sh check-credential <claude|codex> <account-home>
 #   fm-account-directory.sh install-herdr-hook <claude|codex> <account-home>
 #   fm-account-directory.sh prepare <claude|codex>
 #
@@ -21,8 +22,15 @@
 # selects the first real account directory in stable bytewise sort order.
 # Selection prints only the chosen absolute account home on stdout and logs
 # health, fallback, and choice diagnostics on stderr.
-# prepare selects the account and idempotently runs Herdr's own integration
-# installer with CODEX_HOME or CLAUDE_CONFIG_DIR set to the chosen home.
+# prepare selects the account, verifies a usable credential before endpoint
+# creation can begin, and idempotently runs Herdr's own integration installer
+# with CODEX_HOME or CLAUDE_CONFIG_DIR set to the chosen home.
+# Codex uses a cheap read-only auth.json credential-material check.
+# Claude has no sufficient on-disk credential marker on macOS, so it uses the
+# CLI's local `auth status --json` check, bounded to two seconds and never making
+# a model call.
+# A failed check names the selected account home and prints the exact scoped
+# provider login command a human can run.
 # It verifies the installed per-profile hook before printing the chosen home.
 #
 # Credential state is read-only.
@@ -34,7 +42,7 @@ set -u
 TEST_LAB_TOKEN=firstmate-account-directory-test-lab-v1
 
 usage() {
-  sed -n '2,32p' "$0" | sed 's/^# \{0,1\}//' >&2
+  sed -n '2,40p' "$0" | sed 's/^# \{0,1\}//' >&2
 }
 
 log() {
@@ -45,6 +53,12 @@ test_lab_enabled() {
   [ "${FM_ACCOUNT_DIRECTORY_TEST_LAB:-}" = "$TEST_LAB_TOKEN" ]
 }
 
+shell_quote() {
+  printf "'"
+  printf '%s' "$1" | sed "s/'/'\\\\''/g"
+  printf "'"
+}
+
 system_perl() {
   if test_lab_enabled && [ -n "${FM_ACCOUNT_DIRECTORY_PERL_BIN:-}" ]; then
     printf '%s\n' "$FM_ACCOUNT_DIRECTORY_PERL_BIN"
@@ -203,6 +217,108 @@ valid_account_home() { # <vendor-dir> <candidate>
   esac
 }
 
+provider_binary() { # <vendor> <account-home>
+  local vendor=$1 account_home=$2 override manifest binary install_path home perl_bin
+  if test_lab_enabled; then
+    case "$vendor" in
+      claude) override=${FM_ACCOUNT_DIRECTORY_CLAUDE_BIN:-} ;;
+      codex) override=${FM_ACCOUNT_DIRECTORY_CODEX_BIN:-} ;;
+      *) return 1 ;;
+    esac
+    if [ -n "$override" ]; then
+      [ -f "$override" ] && [ ! -L "$override" ] && [ -x "$override" ] || {
+        echo "error: test $vendor provider binary is not a real executable: $override" >&2
+        return 1
+      }
+      printf '%s\n' "$override"
+      return 0
+    fi
+  fi
+  manifest=$account_home/.agent-fleet-provider-binary.json
+  if [ -f "$manifest" ] && [ ! -L "$manifest" ]; then
+    binary=$(jq -er '.binary.resolved_path | select(type == "string" and startswith("/"))' "$manifest" 2>/dev/null) || binary=
+    if [ -n "$binary" ] && [ -f "$binary" ] && [ ! -L "$binary" ] && [ -x "$binary" ]; then
+      printf '%s\n' "$binary"
+      return 0
+    fi
+  fi
+  home=$(passwd_home) || return 1
+  install_path=$home/.local/bin/$vendor
+  perl_bin=$(system_perl) || return 1
+  # shellcheck disable=SC2016 # Perl source is intentionally single-quoted.
+  binary=$("$perl_bin" -MCwd=realpath -e '
+    my $path = realpath($ARGV[0]);
+    exit 1 unless defined $path && $path =~ m{^/} && $path !~ /[\x00-\x1f\x7f]/;
+    print $path;
+  ' "$install_path" 2>/dev/null) || binary=
+  if [ -n "$binary" ] && [ -f "$binary" ] && [ ! -L "$binary" ] && [ -x "$binary" ]; then
+    printf '%s\n' "$binary"
+    return 0
+  fi
+  echo "error: cannot resolve the $vendor provider binary for account credential verification at $account_home" >&2
+  return 1
+}
+
+credential_login_command() { # <vendor> <account-home> [provider-binary]
+  local vendor=$1 account_home=$2 provider_bin=${3:-$1}
+  case "$vendor" in
+    codex)
+      printf 'CODEX_HOME=%s %s login' "$(shell_quote "$account_home")" "$(shell_quote "$provider_bin")"
+      ;;
+    claude)
+      printf 'CLAUDE_CONFIG_DIR=%s %s auth login' "$(shell_quote "$account_home")" "$(shell_quote "$provider_bin")"
+      ;;
+  esac
+}
+
+check_codex_credential() { # <account-home>
+  local account_home=$1 credential provider_bin login
+  credential=$account_home/auth.json
+  provider_bin=$(provider_binary codex "$account_home" 2>/dev/null || printf 'codex')
+  login=$(credential_login_command codex "$account_home" "$provider_bin")
+  if [ ! -f "$credential" ] || [ -L "$credential" ] || ! jq -e '
+    ((.tokens.access_token? | type) == "string" and (.tokens.access_token | length) > 0
+      and (.tokens.refresh_token? | type) == "string" and (.tokens.refresh_token | length) > 0)
+    or ((.OPENAI_API_KEY? | type) == "string" and (.OPENAI_API_KEY | length) > 0)
+  ' "$credential" >/dev/null 2>&1; then
+    echo "error: selected codex account directory '$account_home' has no usable on-disk credential; run: $login" >&2
+    return 1
+  fi
+}
+
+check_claude_credential() { # <account-home>
+  local account_home=$1 provider_bin status_json login
+  provider_bin=$(provider_binary claude "$account_home") || return 1
+  login=$(credential_login_command claude "$account_home" "$provider_bin")
+  status_json=$(run_bounded 2 /usr/bin/env CLAUDE_CONFIG_DIR="$account_home" \
+    "$provider_bin" auth status --json 2>/dev/null) || status_json=
+  if ! jq -e '.loggedIn == true' >/dev/null 2>&1 <<EOF
+$status_json
+EOF
+  then
+    echo "error: selected claude account directory '$account_home' has no usable credential; run: $login" >&2
+    return 1
+  fi
+}
+
+check_credential() { # <vendor> <account-home>
+  local vendor=$1 account_home=$2 root vendor_dir
+  root=$(account_root) || return 1
+  vendor_dir=$root/$vendor
+  valid_account_home "$vendor_dir" "$account_home" || {
+    echo "error: unsafe $vendor account home for credential verification: $account_home" >&2
+    return 1
+  }
+  case "$vendor" in
+    codex) check_codex_credential "$account_home" ;;
+    claude) check_claude_credential "$account_home" ;;
+    *)
+      echo "error: account credential verification supports only claude or codex, not '$vendor'" >&2
+      return 1
+      ;;
+  esac
+}
+
 first_account_home() { # <vendor>
   local vendor=$1 root vendor_dir candidate
   root=$(account_root) || return 1
@@ -381,6 +497,10 @@ case "${1:-}" in
     [ "$#" -eq 2 ] || { usage; exit 2; }
     select_account "$2"
     ;;
+  check-credential)
+    [ "$#" -eq 3 ] || { usage; exit 2; }
+    check_credential "$2" "$3"
+    ;;
   install-herdr-hook)
     [ "$#" -eq 3 ] || { usage; exit 2; }
     install_herdr_hook "$2" "$3"
@@ -388,6 +508,7 @@ case "${1:-}" in
   prepare)
     [ "$#" -eq 2 ] || { usage; exit 2; }
     selected_home=$(select_account "$2") || exit 1
+    check_credential "$2" "$selected_home" || exit 1
     install_herdr_hook "$2" "$selected_home" || exit 1
     printf '%s\n' "$selected_home"
     ;;
diff --git a/bin/fm-brief.sh b/bin/fm-brief.sh
index eb0ba38faf..e443e5468f 100755
--- a/bin/fm-brief.sh
+++ b/bin/fm-brief.sh
@@ -223,7 +223,18 @@ EOF
 )
 fi
 
+BROWSER_SECTION=$(cat <<'EOF'
+# Browser automation safety
+Never set `CHROME_DEVTOOLS_AXI_AUTO_CONNECT=1` or `CHROME_DEVTOOLS_AXI_HEADED=1`.
+Always set your own `CHROME_DEVTOOLS_AXI_SESSION`.
+When an authenticated dashboard is needed, set `CHROME_DEVTOOLS_AXI_USER_DATA_DIR` to a per-crewmate profile directory; the persistent profile keeps its login cookie across headless runs.
+Never use `open -a "Google Chrome"` or AppleScript that focuses an app.
+If a check genuinely cannot run headlessly, report the exact step that fails instead of falling back to a visible or auto-connected browser.
+EOF
+)
+
 if [ "$KIND" = scout ]; then
+REPORT_HEADINGS=$(fm_completion_report_required_headings)
 cat > "$BRIEF" <<EOF
 You are a crewmate: an autonomous worker agent managed by firstmate. Work on your own; do not wait for a human.
 
@@ -232,6 +243,8 @@ You are a crewmate: an autonomous worker agent managed by firstmate. Work on you
 
 $HERDR_SECTION
 
+$BROWSER_SECTION
+
 # Setup
 You are in a disposable git worktree of $REPO, at a detached HEAD on a clean default branch.
 This is a SCOUT task: the deliverable is a written report, not a PR.
@@ -262,7 +275,7 @@ The report is the only thing that survives, so anything worth keeping must be in
 
 # Definition of done
 Write your findings to \`$DATA/$ID/report.md\`.
-Use these level-two sections: Summary, What changed, Verification, Visual evidence, Artifacts, and Follow-ups.
+Use these exact level-two headings in this order: $REPORT_HEADINGS.
 The report must stand alone: what you did, what you found, the evidence (commands run, output, file:line references), and what you recommend.
 When the report is complete, append \`done: {one-line conclusion}\` to the status file and stop.
 If your findings reveal work that should ship (e.g. you reproduced a bug and the fix is clear), say so in the report; firstmate may promote this task in place, and you would then receive mode-specific ship instructions as a follow-up message.
@@ -365,6 +378,8 @@ You are a crewmate: an autonomous worker agent managed by firstmate. Work on you
 
 $HERDR_SECTION
 
+$BROWSER_SECTION
+
 # Setup
 You are in a disposable git worktree of $REPO, at a detached HEAD on a clean default branch.
 
diff --git a/bin/fm-promote.sh b/bin/fm-promote.sh
index e9d2245583..8c300bb728 100755
--- a/bin/fm-promote.sh
+++ b/bin/fm-promote.sh
@@ -19,6 +19,8 @@ DATA="${FM_DATA_OVERRIDE:-$FM_HOME/data}"
 fm_refuse_if_gate_agent
 # shellcheck source=bin/fm-account-routing-lib.sh
 . "$SCRIPT_DIR/fm-account-routing-lib.sh"
+# shellcheck source=bin/fm-report-contract-lib.sh
+. "$SCRIPT_DIR/fm-report-contract-lib.sh"
 "$FM_ROOT/bin/fm-guard.sh" || true
 ID=$1
 META="$STATE/$ID.meta"
@@ -48,7 +50,8 @@ fm_account_lifecycle_lock_release "$LIFECYCLE_LOCK" || exit 1
 LIFECYCLE_LOCK=
 trap - EXIT
 
-MESSAGE="<ship instructions: review scratch state with git status and git log; reset to a clean default-branch base; carry over only intended fix changes; create branch fm/$ID; implement; write $DATA/$ID/completion.md with sections Summary, What changed, Verification, Visual evidence, Artifacts, and Follow-ups; report done>"
+REPORT_HEADINGS=$(fm_completion_report_required_headings)
+MESSAGE="<ship instructions: review scratch state with git status and git log; reset to a clean default-branch base; carry over only intended fix changes; create branch fm/$ID; implement; write $DATA/$ID/completion.md with exact headings $REPORT_HEADINGS; report done>"
 MESSAGE_Q=$(printf '%s' "$MESSAGE" | sed "s/'/'\\\\''/g")
 echo "promoted $ID to ship (teardown protection restored)"
 printf "next: FM_HOME=%q bin/fm-send.sh fm-%s '%s'\n" "$FM_HOME" "$ID" "$MESSAGE_Q"
diff --git a/bin/fm-report-contract-lib.sh b/bin/fm-report-contract-lib.sh
index 5b46fe9265..92007463af 100644
--- a/bin/fm-report-contract-lib.sh
+++ b/bin/fm-report-contract-lib.sh
@@ -3,12 +3,18 @@
 # managed continuation prompts.
 # The durable publication and storage contract lives in docs/report-stack.md.
 
+fm_completion_report_required_headings() {
+  # shellcheck disable=SC2016 # Markdown backticks must remain literal output.
+  printf '%s' '`## Summary`, `## What changed`, `## Verification`, `## Visual evidence`, `## Artifacts`, `## Follow-ups`'
+}
+
 fm_completion_report_contract() {  # <data-dir> <task-id>
-  local data=$1 task=$2
+  local data=$1 task=$2 headings
+  headings=$(fm_completion_report_required_headings)
   printf '%s\n' \
     '# Completion report' \
-    "Before the final \`done:\` status, write \`$data/$task/completion.md\` with these six sections, each as a LEVEL-TWO markdown heading spelled exactly: \`## Summary\`, \`## What changed\`, \`## Verification\`, \`## Visual evidence\`, \`## Artifacts\`, \`## Follow-ups\`." \
-    "Publication rejects the report if any of those headings is missing, spelled differently, or written at another level - a level-one \`# Summary\` fails. Each section needs substantive prose directly under it; if you use sub-headings inside a section, make them \`###\` so they nest rather than ending the section." \
+    "Before the final \`done:\` status, write \`$data/$task/completion.md\` with these six exact level-two headings in this order: $headings." \
+    "Keep all six at level two; publication also accepts a report that consistently uses the level-one equivalents as its section structure, but do not mix heading levels. Each section needs substantive prose directly under it; if you use sub-headings inside a section, make them \`###\` so they nest rather than ending the section." \
     'When a section genuinely does not apply, say so in a sentence under the heading rather than omitting the heading.' \
     'Make it stand alone for the captain: explain the outcome, name important files or links, record the validation performed, and call out remaining risk or decisions.' \
     "Put screenshots, diagrams, or other visual artifacts under \`$data/$task/visuals/\` and reference them from the report when they materially help review." \
diff --git a/bin/fm-report-stack.mjs b/bin/fm-report-stack.mjs
index de47121baa..accf86a775 100755
--- a/bin/fm-report-stack.mjs
+++ b/bin/fm-report-stack.mjs
@@ -123,12 +123,47 @@ function lastStatus(status) {
 
 const { markdownStructure } = markdownModule;
 
+function completionSectionStructure(markdown, options = {}) {
+  const structure = markdownStructure(markdown, options);
+  const requiredIndex = new Map(requiredSections.map((section, index) => [section.toLowerCase(), index]));
+  const headings = structure
+    .map((entry, index) => ({ entry, index }))
+    .filter(({ entry }) => entry.heading?.level <= 2 && requiredIndex.has(entry.heading.content.toLowerCase()));
+  const level = headings[0]?.entry.heading.level;
+  const mixedLevels = headings.some(({ entry }) => entry.heading.level !== level);
+  let lastRequiredIndex = -1;
+  let outOfOrder = false;
+  for (const { entry } of headings) {
+    const index = requiredIndex.get(entry.heading.content.toLowerCase());
+    if (index <= lastRequiredIndex) outOfOrder = true;
+    lastRequiredIndex = index;
+  }
+  const firstHeadingIndex = headings[0]?.index;
+  const lastHeadingIndex = headings[headings.length - 1]?.index;
+  const interrupted = level === 2 && structure.some(({ heading }, index) => (
+    index > firstHeadingIndex
+    && index < lastHeadingIndex
+    && heading?.level === 1
+  ));
+  return {
+    structure,
+    level,
+    mixedLevels,
+    outOfOrder,
+    interrupted,
+  };
+}
+
 function firstSummary(markdown, fallback) {
-  const structure = markdownStructure(markdown);
-  const summaryStart = structure.findIndex(({ heading }) => heading?.level === 2 && heading.content.toLowerCase() === "summary");
+  const { structure, level } = completionSectionStructure(markdown);
+  const summaryStart = structure.findIndex(({ heading }) => (
+    heading && heading.level === level && heading.content.toLowerCase() === "summary"
+  ));
   let summaryLines;
   if (summaryStart >= 0) {
-    const followingHeading = structure.findIndex(({ heading }, index) => index > summaryStart && heading?.level === 2);
+    const followingHeading = structure.findIndex(({ heading }, index) => (
+      index > summaryStart && heading?.level <= level
+    ));
     summaryLines = structure.slice(summaryStart + 1, followingHeading < 0 ? undefined : followingHeading).map(({ line }) => line);
   } else {
     summaryLines = structure.map(({ line }) => line);
@@ -145,10 +180,19 @@ function firstSummary(markdown, fallback) {
 
 function requireCompletionSections(markdown, sourceFile, taskId) {
   const sections = new Map(requiredSections.map((section) => [section.toLowerCase(), { present: false, body: [] }]));
+  const {
+    structure,
+    level,
+    mixedLevels,
+    outOfOrder,
+    interrupted,
+  } = completionSectionStructure(markdown, { includeFenceContent: true });
   let currentSection;
-  for (const entry of markdownStructure(markdown, { includeFenceContent: true })) {
-    if (entry.heading?.level === 2) {
-      currentSection = sections.get(entry.heading.content.toLowerCase());
+  for (const entry of structure) {
+    if (entry.heading?.level <= level) {
+      currentSection = entry.heading.level === level
+        ? sections.get(entry.heading.content.toLowerCase())
+        : undefined;
       if (currentSection) currentSection.present = true;
     } else if (currentSection) {
       currentSection.body.push(entry);
@@ -169,16 +213,20 @@ function requireCompletionSections(markdown, sourceFile, taskId) {
     const state = sections.get(section.toLowerCase());
     return state.present && !state.body.some(substantive);
   });
-  if (missing.length === 0 && empty.length === 0) return;
+  if (missing.length === 0 && empty.length === 0 && !mixedLevels && !outOfOrder && !interrupted) return;
   const required = requiredSections.map((section) => `## ${section}`).join(", ");
   const absent = missing.map((section) => `## ${section}`).join(", ");
   const blank = empty.map((section) => `## ${section}`).join(", ");
   const problems = [];
   if (missing.length > 0) problems.push(`missing required section headings: ${absent}`);
   if (empty.length > 0) problems.push(`required sections have no substantive content: ${blank}`);
+  if (mixedLevels || interrupted) {
+    problems.push("required section headings do not share one top structural level (# or ##)");
+  }
+  if (outOfOrder) problems.push("required section headings are out of order");
   throw new Error(
     `completion report at ${sourceFile} ${problems.join("; ")}. `
-    + `Update ${sourceFile} to include these level-two headings with substantive content: ${required}. `
+    + `Update ${sourceFile} to include these headings at one common top structural level, in order, with substantive content (level two recommended): ${required}. `
     + `Then rerun ${fmRoot}/bin/fm-report-stack.mjs publish ${taskId} or ${fmRoot}/bin/fm-teardown.sh ${taskId}. `
     + "This attempt did not replace the durable report, and teardown remains stopped before destructive cleanup.",
   );
diff --git a/bin/fm-send.sh b/bin/fm-send.sh
index 7ad920b052..fef80bf353 100755
--- a/bin/fm-send.sh
+++ b/bin/fm-send.sh
@@ -20,6 +20,12 @@
 # Tune with FM_SEND_RETRIES (default 3) / FM_SEND_SLEEP (0.4).
 # Slash commands, and codex `$...` skill invocations resolved through harness
 # meta, get a longer pre-Enter settle so completion popups do not swallow Enter.
+# Before that shared settle path, a bare installed-skill token is refused when
+# its `/` or `$` prefix conflicts with the resolved harness form recorded in
+# .agents/skills/harness-adapters/SKILL.md. Refusal is deliberate: silently
+# rewriting would hide a supervisor caller bug. Ordinary slash commands,
+# `$`-prefixed prose, multi-token messages, keys, and unknown-harness explicit
+# targets keep their existing behavior.
 #
 # From-firstmate marker: when the resolved target is a task selector whose meta
 # records kind=secondmate, the text is prefixed with the from-firstmate marker
@@ -95,6 +101,60 @@ fm_send_count_colons() {  # <string>
   printf '%s' $(( ${#s} - ${#no_colons} ))
 }
 
+fm_send_bare_skill_name() {  # <message>
+  local message=$1 name root
+  case "$message" in
+    /*|\$*) ;;
+    *) return 1 ;;
+  esac
+  case "$message" in
+    *[[:space:]]*) return 1 ;;
+  esac
+  name=${message:1}
+  case "$name" in
+    ''|*[!A-Za-z0-9._-]*) return 1 ;;
+  esac
+  case "$name" in
+    no-mistakes)
+      printf '%s' "$name"
+      return 0
+      ;;
+  esac
+  for root in \
+    "$FM_HOME/.agents/skills" \
+    "$FM_ROOT/.agents/skills" \
+    "$FM_ROOT/skills" \
+    "${HOME:-}/.agents/skills" \
+    "${HOME:-}/.claude/skills" \
+    "${HOME:-}/.codex/skills"; do
+    [ -n "$root" ] || continue
+    [ -d "$root/$name" ] || continue
+    printf '%s' "$name"
+    return 0
+  done
+  return 1
+}
+
+fm_send_validate_skill_form() {  # <harness> <message>
+  local harness=$1 message=$2 skill expected corrected
+  skill=$(fm_send_bare_skill_name "$message") || return 0
+  case "$harness" in
+    claude|grok) expected=/ ;;
+    codex) expected='$' ;;
+    opencode|pi)
+      echo "error: refusing bare skill invocation '$message' for harness '$harness'; it has no verified bare skill form, so send natural language such as 'Run the $skill skill.'" >&2
+      return 1
+      ;;
+    *) return 0 ;;
+  esac
+  case "$message" in
+    "$expected"*) return 0 ;;
+  esac
+  corrected=$expected$skill
+  echo "error: refusing bare skill invocation '$message' for harness '$harness'; use '$corrected'" >&2
+  return 1
+}
+
 fm_send_resolve_target() {  # <raw-target>
   local raw=$1 meta pane_meta target backend assumed colons id session hint
 
@@ -188,6 +248,11 @@ shift
 
 fm_backend_validate "$TARGET_BACKEND" || exit 1
 
+if [ "${1:-}" != "--key" ]; then
+  MESSAGE=$*
+  fm_send_validate_skill_form "$TARGET_HARNESS" "$MESSAGE" || exit 1
+fi
+
 # Classify a from-firstmate -> secondmate request. Only a task selector resolved
 # through this home's meta whose authoritative kind is secondmate is marked: the
 # secondmate then routes its reply via the status path (see fm-marker-lib.sh).
@@ -198,10 +263,10 @@ if [ -n "$TARGET_SELECTOR" ] && [ -n "$TARGET_META" ] && [ "$(fm_meta_get "$TARG
   MARK_FROM_FIRSTMATE=1
 fi
 
-# Resolve the target's harness from its meta (recorded by fm-spawn), used only to
-# scope the codex `$<skill>` popup-settle below. A task selector carries
-# meta; an explicit backend-target escape hatch has none, so its harness is
-# unknown and treated as non-codex (the safe default that keeps the fast path).
+# The target's harness came from its meta (recorded by fm-spawn), and scopes both
+# the bare-skill form guard above and the codex `$<skill>` popup-settle below.
+# A task selector carries meta; an explicit backend-target escape hatch has none,
+# so its harness is unknown and retains the existing unguarded fast path.
 # The target's BACKEND comes from selector meta, from matching an explicit target
 # back to recorded meta, or from strict explicit-target shape validation.
 # Do not add a separate passive liveness preflight here. Active send paths own
@@ -257,7 +322,6 @@ if [ "${1:-}" = "--key" ]; then
     fi
   fi
 else
-  MESSAGE=$*
   if [ "$MARK_FROM_FIRSTMATE" = 1 ]; then
     fm_message_mark_from_firstmate "$MESSAGE" MESSAGE
   fi
diff --git a/bin/fm-spawn.sh b/bin/fm-spawn.sh
index e66d231827..68f872ce31 100755
--- a/bin/fm-spawn.sh
+++ b/bin/fm-spawn.sh
@@ -697,6 +697,7 @@ if [ "$RECOVERY_ACCOUNT" = 1 ]; then
     exit 1
   fi
   KIND=$recorded_kind
+  RECOVERY_RECORDED_KIND=$recorded_kind
   if [ "$DIRECT_ACCOUNT_RECOVERY" = 1 ]; then
     case "$KIND" in
       ship|scout) ;;
@@ -1932,8 +1933,7 @@ if [ -e "$STATE/$ID.grok-turnend-token" ] || [ -L "$STATE/$ID.grok-turnend-token
 if [ -e "/tmp/fm-$ID" ] || [ -L "/tmp/fm-$ID" ]; then ORIGINAL_TASK_TMP_PRESENT=1; else ORIGINAL_TASK_TMP_PRESENT=0; fi
 
 if [ "$RECOVERY_ACCOUNT" = 1 ]; then
-  RECORDED_KIND=$(fm_meta_get "$RESUME_META" kind)
-  [ -n "$RECORDED_KIND" ] || RECORDED_KIND=ship
+  RECORDED_KIND=$RECOVERY_RECORDED_KIND
   if [ "$KIND" != ship ] && [ "$KIND" != "$RECORDED_KIND" ]; then
     echo "error: account recovery kind '$KIND' does not match recorded kind '$RECORDED_KIND'" >&2
     exit 1
@@ -2629,7 +2629,7 @@ else
     [ -n "$PROJ_ABS" ] && [ -d "$PROJ_ABS" ] || { echo "error: recorded project is unavailable for managed recovery: ${PROJ_ABS:-<missing>}" >&2; exit 1; }
     [ -n "$WT" ] && [ -d "$WT" ] || { echo "error: recorded worktree is unavailable for managed recovery: ${WT:-<missing>}" >&2; exit 1; }
   else
-    PROJ_ABS="$(cd "$(resolve_project_dir_arg "$PROJ")" && pwd)"
+    PROJ_ABS="$(cd "$(resolve_project_dir_arg "$PROJ")" && pwd -P)"
     WT=""
   fi
 fi
diff --git a/bin/fm-teardown.sh b/bin/fm-teardown.sh
index ea03eda10b..7c073e610d 100755
--- a/bin/fm-teardown.sh
+++ b/bin/fm-teardown.sh
@@ -1849,6 +1849,7 @@ if not stat.S_ISDIR(os.lstat(base).st_mode):
 print(base)
 PY
   ) || return 1
+  [ -e "$base/fm-$ID" ] || [ -L "$base/fm-$ID" ] || return 0
   removal_tree_operation "$base/fm-$ID" "task temp root" remove
 }
 
diff --git a/bin/fm-watch-checkpoint.sh b/bin/fm-watch-checkpoint.sh
index d754301fa4..f016226419 100755
--- a/bin/fm-watch-checkpoint.sh
+++ b/bin/fm-watch-checkpoint.sh
@@ -88,13 +88,13 @@ run_with_perl_timeout() {
 
 set +e
 if command -v timeout >/dev/null 2>&1; then
-  timeout "$SECONDS_ARG" "$SCRIPT_DIR/fm-watch.sh" >"$OUT" 2>"$ERR"
+  FM_WATCH_CHECKPOINT=1 timeout "$SECONDS_ARG" "$SCRIPT_DIR/fm-watch.sh" >"$OUT" 2>"$ERR"
   RC=$?
 elif command -v gtimeout >/dev/null 2>&1; then
-  gtimeout "$SECONDS_ARG" "$SCRIPT_DIR/fm-watch.sh" >"$OUT" 2>"$ERR"
+  FM_WATCH_CHECKPOINT=1 gtimeout "$SECONDS_ARG" "$SCRIPT_DIR/fm-watch.sh" >"$OUT" 2>"$ERR"
   RC=$?
 else
-  run_with_perl_timeout >"$OUT" 2>"$ERR"
+  FM_WATCH_CHECKPOINT=1 run_with_perl_timeout >"$OUT" 2>"$ERR"
   RC=$?
 fi
 set -e
diff --git a/bin/fm-watch.sh b/bin/fm-watch.sh
index 9b4495edb6..c9d21bc9d2 100755
--- a/bin/fm-watch.sh
+++ b/bin/fm-watch.sh
@@ -923,7 +923,9 @@ while :; do
   # alive. Supervision scripts warn when this goes stale with tasks in flight.
   safe_touch_marker_or_log "$STATE/.last-watcher-beat" "watcher beacon" || true
 
-  prune_reports_if_due
+  if [ "${FM_WATCH_CHECKPOINT:-0}" != 1 ]; then
+    prune_reports_if_due
+  fi
 
   # A managed provider's SessionStart hook may race the initial spawn return.
   # Reconcile only metas still missing provider_session_id; failures stay
diff --git a/docs/configuration.md b/docs/configuration.md
index ba90b4a845..c9d0027548 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -173,6 +173,7 @@ The selected provider command receives `CLAUDE_CONFIG_DIR=<home>` or `CODEX_HOME
 New ship/scout launches never ask Agent Fleet to enable a profile, establish identity, install a bundle, or acquire a lease.
 They invoke Herdr's own integration installer against the selected profile directory and verify its per-profile hook file before launching.
 Account credentials remain captain-owned and read-only to Firstmate; selection never authenticates, logs in, or invokes a model.
+Before installing that hook or creating an endpoint, spawn preflight fails closed when the selected directory lacks a usable credential and prints the exact provider-scoped login command for a human.
 
 Codex health and usage are genuinely readable per account.
 Every selection performs a fresh per-account quota read instead of trusting a prior cache, and a Codex directory with no fresh general usage window is skipped.
diff --git a/docs/report-stack.md b/docs/report-stack.md
index 947f486422..f9df53041b 100644
--- a/docs/report-stack.md
+++ b/docs/report-stack.md
@@ -19,7 +19,9 @@ Expired entries are renamed to deletion tombstones before the index changes, and
 New task metadata carries `report_required=1`.
 A ship task writes `data/<id>/completion.md`, while a scout keeps using `data/<id>/report.md`.
 Both may attach screenshots, diagrams, or other review artifacts under `data/<id>/visuals/`.
-Every post-cutover ship and scout report must use the level-two sections Summary, What changed, Verification, Visual evidence, Artifacts, and Follow-ups.
+Every post-cutover ship and scout report must use the sections Summary, What changed, Verification, Visual evidence, Artifacts, and Follow-ups in that order.
+All six section headings must use one common top structural level: either level one, or level two beneath an optional level-one report title.
+The brief scaffold requests the level-two form so reports are consistent, while publication accepts the level-one form because heading depth is formatting rather than substance.
 Every required section must contain substantive body content, with an explicit `None.` accepted when the section has nothing to report.
 Within a real required section, meaningful fenced transcript or literal-code lines count as body content, but an empty fence body, whitespace, a bare Markdown blockquote or list marker, or Unicode control and format characters alone do not.
 Fence delimiters never count as body content, and heading-like lines inside a fence never satisfy a required section heading.
diff --git a/tests/fm-account-directory.test.sh b/tests/fm-account-directory.test.sh
index 512c6db17a..dc07c90725 100755
--- a/tests/fm-account-directory.test.sh
+++ b/tests/fm-account-directory.test.sh
@@ -11,6 +11,7 @@ ACCOUNT_ROOT="$TMP_ROOT/accounts"
 FAKEBIN=$(fm_fakebin "$TMP_ROOT")
 QUOTA_LOG="$TMP_ROOT/quota.log"
 HERDR_LOG="$TMP_ROOT/herdr.log"
+CLAUDE_AUTH_LOG="$TMP_ROOT/claude-auth.log"
 TREEHOUSE_LOG="$TMP_ROOT/treehouse.log"
 
 mkdir -p "$ACCOUNT_ROOT/codex" "$ACCOUNT_ROOT/claude"
@@ -79,12 +80,29 @@ fi
 SH
 chmod +x "$FAKEBIN/herdr"
 
+cat > "$FAKEBIN/claude" <<'SH'
+#!/usr/bin/env bash
+set -u
+[ "${1:-}" = auth ] && [ "${2:-}" = status ] && [ "${3:-}" = --json ] || exit 64
+[ -n "${CLAUDE_CONFIG_DIR:-}" ] || exit 65
+printf '%s\n' "$CLAUDE_CONFIG_DIR" >> "$FM_FAKE_CLAUDE_AUTH_LOG"
+if [ -f "$CLAUDE_CONFIG_DIR/test-authenticated" ]; then
+  printf '%s\n' '{"loggedIn":true,"authMethod":"claude.ai"}'
+  exit 0
+fi
+printf '%s\n' '{"loggedIn":false,"authMethod":"none"}'
+exit 1
+SH
+chmod +x "$FAKEBIN/claude"
+
 run_selector() {
   FM_ACCOUNT_DIRECTORY_TEST_LAB=firstmate-account-directory-test-lab-v1 \
     FM_ACCOUNT_DIRECTORY_ROOT="$ACCOUNT_ROOT" \
     FM_ACCOUNT_DIRECTORY_QUOTA_AXI="$FAKEBIN/quota-axi" \
     FM_ACCOUNT_DIRECTORY_HERDR="$FAKEBIN/herdr" \
+    FM_ACCOUNT_DIRECTORY_CLAUDE_BIN="$FAKEBIN/claude" \
     FM_FAKE_QUOTA_LOG="$QUOTA_LOG" FM_FAKE_HERDR_LOG="$HERDR_LOG" \
+    FM_FAKE_CLAUDE_AUTH_LOG="$CLAUDE_AUTH_LOG" \
     "$SELECTOR" "$@"
 }
 
@@ -93,6 +111,14 @@ set_remaining() {
   mkdir -p "$ACCOUNT_ROOT/codex/$account/.agent-fleet-quota-cache/quota-axi"
   printf '%s\n' "$remaining" > "$ACCOUNT_ROOT/codex/$account/test-remaining"
   printf '{"stale":true}\n' > "$ACCOUNT_ROOT/codex/$account/.agent-fleet-quota-cache/quota-axi/quotas.json"
+  printf '{"auth_mode":"chatgpt","tokens":{"access_token":"test-access","refresh_token":"test-refresh"}}\n' \
+    > "$ACCOUNT_ROOT/codex/$account/auth.json"
+}
+
+set_claude_authenticated() {
+  local account=$1
+  mkdir -p "$ACCOUNT_ROOT/claude/$account"
+  : > "$ACCOUNT_ROOT/claude/$account/test-authenticated"
 }
 
 reset_accounts() {
@@ -100,6 +126,7 @@ reset_accounts() {
   mkdir -p "$ACCOUNT_ROOT/codex" "$ACCOUNT_ROOT/claude"
   : > "$QUOTA_LOG"
   : > "$HERDR_LOG"
+  : > "$CLAUDE_AUTH_LOG"
 }
 
 test_codex_picks_highest_fresh_minimum_and_skips_no_window() {
@@ -191,11 +218,33 @@ test_default_root_uses_passwd_home_not_ambient_home() {
   pass "default account discovery ignores ambient HOME and stays under the passwd home"
 }
 
+test_claude_credential_check_recovers_from_stale_profile_binary_manifest() {
+  local account_home passwd_home
+  reset_accounts
+  account_home="$ACCOUNT_ROOT/claude/1"
+  passwd_home="$TMP_ROOT/credential-passwd-home"
+  set_claude_authenticated 1
+  mkdir -p "$passwd_home/.local/bin"
+  ln -s "$FAKEBIN/claude" "$passwd_home/.local/bin/claude"
+  printf '{"binary":{"resolved_path":"/missing/claude"}}\n' \
+    > "$account_home/.agent-fleet-provider-binary.json"
+
+  FM_ACCOUNT_DIRECTORY_TEST_LAB=firstmate-account-directory-test-lab-v1 \
+    FM_ACCOUNT_DIRECTORY_ROOT="$ACCOUNT_ROOT" \
+    FM_ACCOUNT_DIRECTORY_PASSWD_HOME="$passwd_home" \
+    FM_FAKE_CLAUDE_AUTH_LOG="$CLAUDE_AUTH_LOG" \
+    "$SELECTOR" check-credential claude "$account_home" \
+    || fail "Claude credential check did not recover from a stale pinned binary"
+  assert_grep "$account_home" "$CLAUDE_AUTH_LOG" \
+    "Claude credential check did not scope the current provider binary to the selected account"
+  pass "Claude credential preflight resolves the current install when profile binary metadata is stale"
+}
+
 test_prepare_installs_and_verifies_per_account_herdr_hooks() {
   local codex_home claude_home
   reset_accounts
   set_remaining 1 90,80
-  mkdir -p "$ACCOUNT_ROOT/claude/1"
+  set_claude_authenticated 1
 
   codex_home=$(run_selector prepare codex 2>"$TMP_ROOT/prepare-codex.err")
   claude_home=$(run_selector prepare claude 2>"$TMP_ROOT/prepare-claude.err")
@@ -206,6 +255,40 @@ test_prepare_installs_and_verifies_per_account_herdr_hooks() {
   pass "prepare uses Herdr's own installer and verifies each selected profile hook"
 }
 
+test_prepare_rejects_missing_credentials_before_hook_install() {
+  local out status codex_home claude_home
+
+  reset_accounts
+  set_remaining 1 90,80
+  codex_home="$ACCOUNT_ROOT/codex/1"
+  rm -f "$codex_home/auth.json"
+  out=$(run_selector prepare codex 2>&1)
+  status=$?
+  expect_code 1 "$status" "Codex prepare without auth.json should fail closed"
+  assert_contains "$out" "selected codex account directory '$codex_home' has no usable on-disk credential" \
+    "Codex credential refusal omitted the selected account directory"
+  assert_contains "$out" "CODEX_HOME='$codex_home'" \
+    "Codex credential refusal omitted the exact scoped login command"
+  [ ! -s "$HERDR_LOG" ] || fail "Codex credential refusal still installed a Herdr hook"
+
+  reset_accounts
+  claude_home="$ACCOUNT_ROOT/claude/1"
+  mkdir -p "$claude_home"
+  out=$(run_selector prepare claude 2>&1)
+  status=$?
+  expect_code 1 "$status" "Claude prepare without a usable login should fail closed"
+  assert_contains "$out" "selected claude account directory '$claude_home' has no usable credential" \
+    "Claude credential refusal omitted the selected account directory"
+  assert_contains "$out" "CLAUDE_CONFIG_DIR='$claude_home'" \
+    "Claude credential refusal omitted the exact scoped login command"
+  assert_contains "$out" "auth login" \
+    "Claude credential refusal omitted the provider login command"
+  assert_grep "$claude_home" "$CLAUDE_AUTH_LOG" \
+    "Claude credential preflight did not query the selected config directory"
+  [ ! -s "$HERDR_LOG" ] || fail "Claude credential refusal still installed a Herdr hook"
+  pass "prepare refuses unauthenticated account directories before hook installation"
+}
+
 make_spawn_fakebin() {
   local fakebin=$1
   cat > "$fakebin/tmux" <<'SH'
@@ -301,7 +384,9 @@ run_direct_spawn() {
     FM_ACCOUNT_DIRECTORY_ROOT="$ACCOUNT_ROOT" \
     FM_ACCOUNT_DIRECTORY_QUOTA_AXI="$FAKEBIN/quota-axi" \
     FM_ACCOUNT_DIRECTORY_HERDR="$FAKEBIN/herdr" \
+    FM_ACCOUNT_DIRECTORY_CLAUDE_BIN="$FAKEBIN/claude" \
     FM_FAKE_QUOTA_LOG="$QUOTA_LOG" FM_FAKE_HERDR_LOG="$HERDR_LOG" \
+    FM_FAKE_CLAUDE_AUTH_LOG="$CLAUDE_AUTH_LOG" \
     FM_AGENT_FLEET_BIN="$FAKEBIN/forbidden-agent-fleet" \
     FM_FAKE_AGENT_FLEET_LOG="$TMP_ROOT/agent-fleet.log" \
     "$ROOT/bin/fm-spawn.sh" "$@"
@@ -364,7 +449,8 @@ test_spawn_uses_direct_claude_fallback_and_hook() {
   local record id out launch meta
   reset_accounts
   : > "$TMP_ROOT/agent-fleet.log"
-  mkdir -p "$ACCOUNT_ROOT/claude/2" "$ACCOUNT_ROOT/claude/1"
+  mkdir -p "$ACCOUNT_ROOT/claude/2"
+  set_claude_authenticated 1
   id=direct-claude-z2
   record=$(make_spawn_case direct-claude claude "$id")
   read_spawn_case "$record"
@@ -382,6 +468,27 @@ test_spawn_uses_direct_claude_fallback_and_hook() {
   pass "new account-flagged Claude spawn uses deterministic CLAUDE_CONFIG_DIR with an explicit warning"
 }
 
+test_spawn_refuses_unauthenticated_account_before_endpoint_creation() {
+  local record id out status
+  reset_accounts
+  mkdir -p "$ACCOUNT_ROOT/claude/1"
+  id=direct-claude-unauth-z2a
+  record=$(make_spawn_case direct-claude-unauth claude "$id")
+  read_spawn_case "$record"
+
+  out=$(run_direct_spawn "$SPAWN_HOME" "$SPAWN_WORKTREE" "$SPAWN_LAUNCH_LOG" \
+    "$id" "$SPAWN_PROJECT" --account-pool legacy-claude-pool 2>&1)
+  status=$?
+  expect_code 1 "$status" "unauthenticated direct Claude spawn should fail closed"
+  assert_contains "$out" "selected claude account directory '$ACCOUNT_ROOT/claude/1' has no usable credential" \
+    "spawn credential refusal omitted the selected account directory"
+  assert_contains "$out" "auth login" "spawn credential refusal omitted the exact login command"
+  assert_absent "$SPAWN_HOME/state/.fake-endpoint" \
+    "unauthenticated direct Claude spawn created an endpoint"
+  [ ! -s "$SPAWN_LAUNCH_LOG" ] || fail "unauthenticated direct Claude spawn typed a launch command"
+  pass "fm-spawn refuses an unauthenticated direct account before endpoint creation"
+}
+
 test_observe_spawn_uses_direct_directory_without_agent_fleet() {
   local record id out launch meta
   reset_accounts
@@ -957,15 +1064,26 @@ if [ "${FM_TEST_FOCUSED:-}" = direct-recovery-lifecycle ]; then
   exit 0
 fi
 
+if [ "${FM_TEST_FOCUSED:-}" = credential-preflight ]; then
+  test_claude_credential_check_recovers_from_stale_profile_binary_manifest
+  test_prepare_installs_and_verifies_per_account_herdr_hooks
+  test_prepare_rejects_missing_credentials_before_hook_install
+  test_spawn_refuses_unauthenticated_account_before_endpoint_creation
+  exit 0
+fi
+
 test_codex_picks_highest_fresh_minimum_and_skips_no_window
 test_codex_rechecks_health_on_every_selection
 test_codex_fails_when_no_account_has_a_fresh_window
 test_codex_timeout_skips_wedged_account
 test_claude_uses_stable_first_without_treating_usage_as_health
 test_default_root_uses_passwd_home_not_ambient_home
+test_claude_credential_check_recovers_from_stale_profile_binary_manifest
 test_prepare_installs_and_verifies_per_account_herdr_hooks
+test_prepare_rejects_missing_credentials_before_hook_install
 test_spawn_uses_direct_codex_home_without_agent_fleet
 test_spawn_uses_direct_claude_fallback_and_hook
+test_spawn_refuses_unauthenticated_account_before_endpoint_creation
 test_observe_spawn_uses_direct_directory_without_agent_fleet
 test_direct_spawn_and_recovery_support_detached_worktree
 test_direct_recovery_preserves_recorded_task_context
diff --git a/tests/fm-account-routing.test.sh b/tests/fm-account-routing.test.sh
index 57e870f344..2d51920b24 100755
--- a/tests/fm-account-routing.test.sh
+++ b/tests/fm-account-routing.test.sh
@@ -17,6 +17,8 @@ TEARDOWN="$ROOT/bin/fm-teardown.sh"
 SESSION_SYNC="$ROOT/bin/fm-account-session-sync.sh"
 CONTINUATION="$ROOT/bin/fm-account-continuation.sh"
 TMP_ROOT=$(fm_test_tmproot fm-account-routing-tests)
+REAL_GIT=$(command -v git)
+export FM_TEST_REAL_GIT="$REAL_GIT"
 
 assert_not_grep() {
   local pattern=$1 file=$2 label=$3
@@ -187,6 +189,19 @@ case "${1:-}" in
 esac
 exit 0
 SH
+  cat > "$fakebin/git" <<'SH'
+#!/usr/bin/env bash
+if [ -n "${FM_FAKE_LIVE_DEFAULT_BRANCH:-}" ] && [ -n "${FM_FAKE_LIVE_DEFAULT_TIP:-}" ]; then
+  case " $* " in
+    *" ls-remote --symref origin HEAD "*|*" ls-remote --symref origin HEAD")
+      printf 'ref: refs/heads/%s\tHEAD\n%s\tHEAD\n' "$FM_FAKE_LIVE_DEFAULT_BRANCH" "$FM_FAKE_LIVE_DEFAULT_TIP"
+      exit 0
+      ;;
+  esac
+fi
+exec "$FM_TEST_REAL_GIT" "$@"
+SH
+  chmod +x "$fakebin/git"
   chmod +x "$fakebin/tmux"
   cat > "$fakebin/treehouse" <<'SH'
 #!/usr/bin/env bash
@@ -451,6 +466,9 @@ run_spawn() {
     FM_FAKE_TREEHOUSE_PATH="$WT_DIR" FM_TREEHOUSE_ROOT="$CASE_DIR/treehouse-pools" \
     FM_FAKE_TREEHOUSE_SLEEP="${FM_FAKE_TREEHOUSE_SLEEP:-}" \
     FM_FAKE_TREEHOUSE_RETURN_SLEEP="${FM_FAKE_TREEHOUSE_RETURN_SLEEP:-}" \
+    FM_TEST_REAL_GIT="$REAL_GIT" \
+    FM_FAKE_LIVE_DEFAULT_BRANCH="${FM_FAKE_LIVE_DEFAULT_BRANCH:-}" \
+    FM_FAKE_LIVE_DEFAULT_TIP="${FM_FAKE_LIVE_DEFAULT_TIP:-}" \
     FM_FAKE_TREEHOUSE_RETURN_CHILD_PID_FILE="${FM_FAKE_TREEHOUSE_RETURN_CHILD_PID_FILE:-}" \
     FM_FAKE_TREEHOUSE_RETURN_MARKER="${FM_FAKE_TREEHOUSE_RETURN_MARKER:-}" \
     FM_TEST_REAL_PS="${FM_TEST_REAL_PS:-}" \
@@ -478,6 +496,7 @@ run_teardown() {
     FM_FAKE_TREEHOUSE_LOG="$TREEHOUSE_LOG" FM_FAKE_ENDPOINT_FILE="$CASE_DIR/endpoint-live" \
     FM_FAKE_TREEHOUSE_RETURN_SLEEP="${FM_FAKE_TREEHOUSE_RETURN_SLEEP:-}" \
     FM_FAKE_TMUX_LABEL_FILE="$CASE_DIR/tmux-label" \
+    FM_TEST_REAL_GIT="$REAL_GIT" \
     FM_AGENT_FLEET_BIN="$FAKEBIN_DIR/agent-fleet" \
     TMUX="fake,1,0" PATH="$FAKEBIN_DIR:$PATH" "$TEARDOWN" "$@"
 }
@@ -676,7 +695,7 @@ test_changed_acquisition_is_retained_during_unmanaged_rollback() {
     FM_FAKE_TMUX_FAIL_SEND_MATCH=GOTMPDIR \
     run_spawn "$id" "$PROJ_DIR" > "$out_file" &
   spawn_pid=$!
-  for _ in $(seq 1 100); do [ -f "$marker" ] && break; sleep 0.05; done
+  for _ in $(seq 1 300); do [ -f "$marker" ] && break; sleep 0.05; done
   [ -f "$marker" ] \
     || { kill "$spawn_pid" 2>/dev/null || true; fail "changed-acquisition test never reached the post-install failure"; }
   printf '%s\n' retained-commit > "$WT_DIR/retained-commit.txt"
@@ -2079,7 +2098,7 @@ make_seeded_secondmate_home() {
     "$id" "$home_abs" > "$HOME_DIR/data/secondmates.md"
 }
 
-test_secondmate_pool_is_nonactivating_and_noninherited() {
+test_pool_only_secondmate_stays_routing_off() {
   local id rec sm out status
   id=account-secondmate-off-z10
   rec=$(make_case secondmate-off claude)
@@ -2090,14 +2109,14 @@ test_secondmate_pool_is_nonactivating_and_noninherited() {
 
   out=$(FM_TEST_PANE_PATH="$sm" run_spawn "$id" "$sm" --secondmate)
   status=$?
-  [ "$status" -eq 0 ] || fail "pool-only secondmate spawn should stay legacy/off (exit $status): $out"
-  [ ! -s "$AF_LOG" ] || fail "secondmate pool activated Agent Fleet while routing was off: $(cat "$AF_LOG")"
-  assert_not_grep '^account_' "$HOME_DIR/state/$id.meta" "off secondmate wrote account metadata"
+  [ "$status" -eq 0 ] || fail "pool-only secondmate spawn should keep account routing off (exit $status): $out"
+  [ ! -s "$AF_LOG" ] || fail "pool-only secondmate spawn activated legacy Agent Fleet while routing was off: $(cat "$AF_LOG")"
+  assert_not_grep '^account_' "$HOME_DIR/state/$id.meta" "pool-only secondmate spawn entered an account-routing path"
   assert_absent "$sm/config/secondmate-account-pool" "secondmate account pool leaked into the child home"
-  pass "the primary secondmate pool is non-inherited and does not activate routing by itself"
+  pass "a primary secondmate pool stays non-inherited and does not activate routing by itself"
 }
 
-test_secondmate_pool_routes_when_mode_is_enforced_and_mode_inherits() {
+test_enabled_secondmate_uses_legacy_agent_fleet_not_direct_account_directory() {
   local id rec sm out status
   id=account-secondmate-enforce-z11
   rec=$(make_case secondmate-enforce claude)
@@ -2113,12 +2132,12 @@ test_secondmate_pool_routes_when_mode_is_enforced_and_mode_inherits() {
     run_spawn "$id" "$sm" --secondmate)
   status=$?
   [ "$status" -eq 0 ] || fail "enforced secondmate spawn should succeed (exit $status): $out"
-  assert_regex "lease choose --pool claude-captains --task .*-$id-.* --provider claude" "$AF_LOG" "secondmate did not use its primary-owned account pool"
+  assert_regex "lease choose --pool claude-captains --task .*-$id-.* --provider claude" "$AF_LOG" "enabled secondmate routing did not use legacy Agent Fleet"
   assert_grep 'account_pool=claude-captains' "$HOME_DIR/state/$id.meta" "secondmate meta lost its account pool"
-  assert_not_grep '^account_home=' "$HOME_DIR/state/$id.meta" "secondmate entered direct account-directory routing"
+  assert_not_grep '^account_home=' "$HOME_DIR/state/$id.meta" "enabled secondmate routing silently entered the direct account-directory path"
   [ "$(cat "$sm/config/account-routing-mode" 2>/dev/null)" = enforce ] || fail "account routing mode did not inherit into the secondmate home"
   assert_absent "$sm/config/secondmate-account-pool" "primary-only secondmate pool leaked into the child home"
-  pass "secondmate routing uses the primary pool while the mode, but not that pool, inherits"
+  pass "enabled secondmate routing uses legacy Agent Fleet and never direct account directories"
 }
 
 test_explicit_secondmate_route_preserves_ambient_primary_enforce() {
@@ -3198,7 +3217,7 @@ test_continuation_fails_closed_without_original_brief() {
   clear_case_logs
   out=$(FM_ROOT_OVERRIDE="$ROOT" FM_HOME="$HOME_DIR" FM_STATE_OVERRIDE="$HOME_DIR/state" \
     FM_DATA_OVERRIDE="$HOME_DIR/data" FM_FAKE_ENDPOINT_FILE="$CASE_DIR/endpoint-live" \
-    FM_FAKE_TMUX_LOG="$TMUX_LOG" PATH="$FAKEBIN_DIR:$PATH" \
+    FM_FAKE_TMUX_LOG="$TMUX_LOG" FM_TEST_REAL_GIT="$REAL_GIT" PATH="$FAKEBIN_DIR:$PATH" \
     "$CONTINUATION" "$id" missing-brief 2>&1)
   status=$?
   [ "$status" -ne 0 ] || fail "continuation without original brief unexpectedly succeeded"
@@ -6060,7 +6079,8 @@ if [ "${FM_TEST_FOCUSED:-}" = explicit-secondmate-route ]; then
 fi
 
 if [ "${FM_TEST_FOCUSED:-}" = secondmate-direct-scope ]; then
-  run_isolated_test test_secondmate_pool_routes_when_mode_is_enforced_and_mode_inherits
+  run_isolated_test test_pool_only_secondmate_stays_routing_off
+  run_isolated_test test_enabled_secondmate_uses_legacy_agent_fleet_not_direct_account_directory
   exit 0
 fi
 
@@ -6357,8 +6377,8 @@ run_isolated_test test_native_resume_migrates_legacy_session_mapping_after_launc
 run_isolated_test test_native_resume_rejects_zero_sequence_on_current_schema
 run_isolated_test test_native_resume_accepts_agent_fleet_utc_offset_timestamps
 run_isolated_test test_native_resume_uses_private_launch_directory_and_cleans_it
-run_isolated_test test_secondmate_pool_is_nonactivating_and_noninherited
-run_isolated_test test_secondmate_pool_routes_when_mode_is_enforced_and_mode_inherits
+run_isolated_test test_pool_only_secondmate_stays_routing_off
+run_isolated_test test_enabled_secondmate_uses_legacy_agent_fleet_not_direct_account_directory
 run_isolated_test test_explicit_secondmate_route_preserves_ambient_primary_enforce
 run_isolated_test test_enforced_secondmate_requires_routing_inheritance_and_capable_home
 run_isolated_test test_secondmate_routing_inheritance_is_authoritative_for_every_mode
diff --git a/tests/fm-backend-zellij.test.sh b/tests/fm-backend-zellij.test.sh
index 7aef69fa4a..f49d9ca133 100755
--- a/tests/fm-backend-zellij.test.sh
+++ b/tests/fm-backend-zellij.test.sh
@@ -908,21 +908,33 @@ test_kill_is_noop_when_session_absent() {
 }
 
 test_teardown_passes_recorded_tab_id_to_zellij_kill() {
-  local dir state data config project fb out status
-  dir="$TMP_ROOT/teardown-zellij-ghost"; state="$dir/state"; data="$dir/data"; config="$dir/config"; project="$dir/project"
-  mkdir -p "$state" "$data/zghost" "$config" "$project" "$dir/responses"
+  local dir state data config project worktree fb out status
+  dir="$TMP_ROOT/teardown-zellij-ghost"; state="$dir/state"; data="$dir/data"; config="$dir/config"; project="$dir/project"; worktree="$dir/pool/1/project"
+  mkdir -p "$state" "$data/zghost" "$config" "$project" "$dir/pool/1" "$dir/responses"
+  fm_git_worktree "$project" "$worktree" zghost-worktree
+  printf '{"worktrees":[{"name":"1","path":"%s","leased":true,"lease_holder":"firstmate-zghost"}]}\n' \
+    "$worktree" > "$dir/pool/treehouse-state.json"
   printf 'report\n' > "$data/zghost/report.md"
   fm_write_meta "$state/zghost.meta" \
     "window=firstmate:7" \
     "backend=zellij" \
     "zellij_tab_id=3" \
-    "worktree=$dir/missing-worktree" \
+    "worktree=$worktree" \
     "project=$project" \
     "kind=scout"
   printf '[]\n' > "$dir/responses/1.out"
   printf '[{"tab_id":3,"name":"fm-zghost"}]\n' > "$dir/responses/2.out"
   fb=$(make_zellij_fakebin "$dir")
-  out=$( PATH="$fb:$PATH" FM_STATE_OVERRIDE="$state" FM_DATA_OVERRIDE="$data" FM_CONFIG_OVERRIDE="$config" \
+  cat > "$fb/treehouse" <<'SH'
+#!/usr/bin/env bash
+if [ "${1:-}" = return ]; then
+  target=${!#}
+  git -C "$target" worktree remove --force "$target"
+fi
+exit 0
+SH
+  chmod +x "$fb/treehouse"
+  out=$( PATH="$fb:$PATH" FM_STATE_OVERRIDE="$state" FM_DATA_OVERRIDE="$data" FM_CONFIG_OVERRIDE="$config" FM_TREEHOUSE_ROOT="$dir" \
     FM_ZELLIJ_LOG="$dir/log" FM_ZELLIJ_RESPONSES="$dir/responses" FM_ZELLIJ_SESSION_LIST="firstmate" \
     "$ROOT/bin/fm-teardown.sh" zghost 2>&1 )
   status=$?
diff --git a/tests/fm-backend.test.sh b/tests/fm-backend.test.sh
index a09459b60c..97a76d9caa 100755
--- a/tests/fm-backend.test.sh
+++ b/tests/fm-backend.test.sh
@@ -983,7 +983,11 @@ esac
 exit 0
 SH
   chmod +x "$fb/tmux"
-  fm_fake_exit0 "$fb" treehouse
+  cat > "$fb/treehouse" <<'SH'
+#!/usr/bin/env bash
+printf '%s\n' "${FM_FAKE_TREEHOUSE_PATH:?}"
+SH
+  chmod +x "$fb/treehouse"
   printf '%s\n' "$fb"
 }
 
@@ -994,6 +998,8 @@ run_spawn_case() {  # <bin-root> <fakebin> <log> <state> <data> <config> <proj>
   env PATH="$fb:$PATH" FM_ROOT_OVERRIDE="$bin" \
     FM_STATE_OVERRIDE="$state" FM_DATA_OVERRIDE="$data" FM_CONFIG_OVERRIDE="$config" \
     FM_PROJECTS_OVERRIDE="$TMP_ROOT/unused-projects" \
+    FM_TREEHOUSE_ROOT="${FM_TREEHOUSE_ROOT:-}" \
+    FM_FAKE_TREEHOUSE_PATH="${FM_FAKE_TREEHOUSE_PATH:-}" \
     FM_SPAWN_NO_GUARD=1 TMUX="fake,1,0" FM_TMUX_LOG="$log" \
     "$bin/bin/fm-spawn.sh" "$@"
 }
@@ -1082,10 +1088,10 @@ run_spawn_symlink_case() {  # <label> <physical|logical>
   mkdir -p "$data/$id"
   printf 'test brief content\n' > "$data/$id/brief.md"
   state="$TMP_ROOT/symlink-state-$label"; config="$TMP_ROOT/symlink-config-$label"
-  mkdir -p "$state" "$config"
+  mkdir -p "$state" "$config" "$TMP_ROOT/symlink-treehouse-$label"
   log="$TMP_ROOT/symlink-spawn-$label.log"
 
-  out=$(run_spawn_case "$ROOT" "$fb" "$log" "$state" "$data" "$config" "$proj" -- "$id" "$proj" claude 2>&1)
+  out=$(FM_FAKE_TREEHOUSE_PATH="$wt" FM_TREEHOUSE_ROOT="$TMP_ROOT/symlink-treehouse-$label" run_spawn_case "$ROOT" "$fb" "$log" "$state" "$data" "$config" "$proj" -- "$id" "$proj" claude 2>&1)
   rc=$?
   expect_code 0 "$rc" "fm-spawn.sh should succeed for a project reached through a symlinked prefix when the backend reports $first_reply cwd"$'\n'"$out"
   assert_contains "$out" "worktree=$wt" \
diff --git a/tests/fm-brief.test.sh b/tests/fm-brief.test.sh
index a5ce892ffb..a87e540975 100755
--- a/tests/fm-brief.test.sh
+++ b/tests/fm-brief.test.sh
@@ -109,12 +109,14 @@ test_ship_completion_report_contract() {
   brief="$home/data/$id/brief.md"
   assert_grep "# Completion report" "$brief" "ship brief has no completion-report contract"
   assert_grep "data/$id/completion.md" "$brief" "ship brief has no durable report path"
-  assert_grep "six sections, each as a LEVEL-TWO markdown heading spelled exactly" "$brief" \
-    "ship brief does not require exact level-two report headings"
+  assert_grep "six exact level-two headings in this order" "$brief" \
+    "ship brief does not require ordered exact level-two report headings"
   assert_grep "\`## Summary\`, \`## What changed\`, \`## Verification\`, \`## Visual evidence\`, \`## Artifacts\`, \`## Follow-ups\`" "$brief" \
     "ship brief has no exact review-oriented report schema"
-  assert_grep "a level-one \`# Summary\` fails" "$brief" \
-    "ship brief does not reject completion sections at the wrong heading level"
+  assert_grep "publication also accepts a report that consistently uses the level-one equivalents" "$brief" \
+    "ship brief does not describe the accepted level-one compatibility form"
+  assert_grep "do not mix heading levels" "$brief" \
+    "ship brief does not forbid structurally mixed report sections"
   assert_grep "When a section genuinely does not apply, say so in a sentence under the heading rather than omitting the heading." "$brief" \
     "ship brief permits inapplicable report sections to be omitted"
   assert_grep "data/$id/visuals/" "$brief" "ship brief has no visual evidence path"
@@ -132,11 +134,40 @@ test_scout_completion_report_contract() {
   FM_HOME="$home" "$ROOT/bin/fm-brief.sh" "$id" some-proj --scout >/dev/null 2>&1
   brief="$home/data/$id/brief.md"
   assert_grep "data/$id/report.md" "$brief" "scout brief has no durable report path"
-  assert_grep "Summary, What changed, Verification, Visual evidence, Artifacts, and Follow-ups" "$brief" \
-    "scout brief does not name every enforced report section"
+  assert_grep "\`## Summary\`, \`## What changed\`, \`## Verification\`, \`## Visual evidence\`, \`## Artifacts\`, \`## Follow-ups\`" "$brief" \
+    "scout brief does not name every enforced report heading concretely"
   pass "fm-brief.sh: scout tasks receive the enforced completion-report schema"
 }
 
+test_browser_automation_safety_contract() {
+  local home kind id brief
+  home="$TMP_ROOT/browser-safety-home"
+  mkdir -p "$home/data"
+  for kind in ship scout; do
+    id="brief-browser-safety-$kind"
+    if [ "$kind" = scout ]; then
+      FM_HOME="$home" "$ROOT/bin/fm-brief.sh" "$id" some-proj --scout >/dev/null 2>&1
+    else
+      FM_HOME="$home" "$ROOT/bin/fm-brief.sh" "$id" some-proj >/dev/null 2>&1
+    fi
+    brief="$home/data/$id/brief.md"
+    assert_grep "# Browser automation safety" "$brief" "$kind brief omitted browser safety"
+    assert_grep "Never set \`CHROME_DEVTOOLS_AXI_AUTO_CONNECT=1\` or \`CHROME_DEVTOOLS_AXI_HEADED=1\`." "$brief" \
+      "$kind brief omitted both independent visible-browser hazards"
+    assert_grep "Always set your own \`CHROME_DEVTOOLS_AXI_SESSION\`." "$brief" \
+      "$kind brief omitted per-crewmate browser session isolation"
+    assert_grep "\`CHROME_DEVTOOLS_AXI_USER_DATA_DIR\` to a per-crewmate profile directory" "$brief" \
+      "$kind brief omitted persistent authenticated-profile isolation"
+    assert_grep "persistent profile keeps its login cookie across headless runs" "$brief" \
+      "$kind brief omitted authenticated headless reuse"
+    assert_grep "Never use \`open -a \"Google Chrome\"\` or AppleScript that focuses an app." "$brief" \
+      "$kind brief omitted focus-hijack commands"
+    assert_grep "report the exact step that fails instead of falling back" "$brief" \
+      "$kind brief omitted fail-closed headless reporting"
+  done
+  pass "fm-brief.sh: ship and scout briefs always carry browser-isolation safety"
+}
+
 test_promoted_scout_receives_completion_contract() {
   local home data id out expected_report
   home="$TMP_ROOT/promote-report-home"
@@ -147,7 +178,7 @@ test_promoted_scout_receives_completion_contract() {
   out=$(FM_HOME="$home" FM_DATA_OVERRIDE="$data" FM_ROOT_OVERRIDE="$ROOT" "$ROOT/bin/fm-promote.sh" "$id") \
     || fail "scout promotion failed"
   assert_grep 'kind=ship' "$home/state/$id.meta" "scout promotion did not update task kind"
-  assert_contains "$out" "Summary, What changed, Verification, Visual evidence, Artifacts, and Follow-ups" \
+  assert_contains "$out" "\`## Summary\`, \`## What changed\`, \`## Verification\`, \`## Visual evidence\`, \`## Artifacts\`, \`## Follow-ups\`" \
     "promoted scout did not receive the ship completion-report schema"
   expected_report="$data/$id/completion.md"
   assert_contains "$out" "$expected_report" "promoted scout did not receive the authoritative completion-report path"
@@ -454,6 +485,7 @@ test_no_mistakes_dod_wording
 test_ship_project_memory_wording
 test_ship_completion_report_contract
 test_scout_completion_report_contract
+test_browser_automation_safety_contract
 test_promoted_scout_receives_completion_contract
 test_promote_serializes_with_account_session_updates
 test_promote_locks_lifecycle_before_metadata_and_rechecks_kind
diff --git a/tests/fm-checkout-refresh.test.sh b/tests/fm-checkout-refresh.test.sh
index 693c1e0e3d..4f5d4d684a 100755
--- a/tests/fm-checkout-refresh.test.sh
+++ b/tests/fm-checkout-refresh.test.sh
@@ -331,7 +331,7 @@ test_nested_active_project_invalidates_coverage_health() {
   projects="$container/projects"
   nested="$projects/nested-directory"
   nested_state="$TMP_ROOT/nested-active-state"
-  mkdir -p "$nested" "$nested_state"
+  mkdir -p "$nested" "$nested_state" "$TMP_ROOT/nested-active-treehouse"
   printf '%s\n' preserved-nested-heartbeat > "$nested_state/heartbeat"
 
   set +e
@@ -352,7 +352,7 @@ test_nested_active_project_invalidates_coverage_health() {
 }
 
 test_discovery_rejects_nested_configured_and_scanned_paths() {
-  local remote seed outer configured_child scan_root scanned_child scanned_canonical out err
+  local remote seed outer configured_child scan_root scanned_child scanned_canonical out err status
   remote=$(build_origin exact-discovery)
   seed="$FM_TEST_HOME/projects/exact-discovery"
   outer="$TMP_ROOT/exact-discovery-outer"
@@ -370,8 +370,11 @@ test_discovery_rejects_nested_configured_and_scanned_paths() {
     printf 'scan %s\n' "$scan_root"
   } > "$FM_TEST_HOME/config/checkout-refresh"
 
-  run_refresh discover > "$out" 2> "$err" \
-    || fail "exact-root discovery fixture failed"
+  set +e
+  run_refresh discover > "$out" 2> "$err"
+  status=$?
+  set -e
+  [ "$status" -ne 0 ] || fail "exact-root discovery accepted invalid configured paths"
 
   assert_no_grep "^$configured_child$" "$out" \
     "configured nested directory was emitted as a checkout"
@@ -608,7 +611,7 @@ test_ignored_skill_files_are_outside_the_collision_guard() {
   run_refresh verify-worktree "$worktree" "$source" \
     || fail "an ignored skill file made a clean local acquisition fail"
   out=$(run_refresh preflight "$worktree") \
-    || fail "preflight rejected an acquisition containing only ignored skill material"
+    || fail "preflight rejected an acquisition containing only ignored skill material: $out"
   assert_not_contains "$out" "HYGIENE:" \
     "ignored skill material entered the untracked-draft collision inventory"
   grep -Fq '# intentional ignored material' "$draft" \
diff --git a/tests/fm-fleet-sync.test.sh b/tests/fm-fleet-sync.test.sh
index d31c7e052d..976c3dfe00 100755
--- a/tests/fm-fleet-sync.test.sh
+++ b/tests/fm-fleet-sync.test.sh
@@ -495,45 +495,57 @@ test_live_default_probe_overrides_stale_origin_head() {
 }
 
 test_direct_sync_honors_shared_checkout_lock() {
-  local home clone before common key lock_root lock out
+  local home clone before lock_root lock out holder ready release
   home=$(new_home)
   clone=$(build_pair "$home" shared-lock)
   advance_origin "$home" shared-lock C1
   before=$(head_sha "$clone")
-  common=$(git -C "$clone" rev-parse --git-common-dir)
-  case "$common" in /*) ;; *) common="$clone/$common" ;; esac
-  common=$(cd "$common" && pwd -P)
-  key=$(printf '%s' "$common" | shasum -a 256 | awk '{print substr($1,1,24)}')
   lock_root="$home/checkout-locks"
-  lock="$lock_root/$key.lock"
-  mkdir -p "$lock"
-  printf '%s\n' "$$" > "$lock/pid"
+  # shellcheck source=bin/fm-checkout-lock-lib.sh
+  . "$ROOT/bin/fm-checkout-lock-lib.sh"
+  fm_checkout_lock_prepare "$lock_root" || fail "could not prepare shared checkout lock fixture"
+  lock=$(fm_checkout_lock_path "$clone" "$lock_root") || fail "could not resolve shared checkout lock fixture"
+  ready="$home/checkout-lock-ready"
+  release="$home/checkout-lock-release"
+  bash -c '
+    . "$1"
+    . "$2"
+    fm_lock_try_acquire "$3" || exit 1
+    : > "$4"
+    while [ ! -f "$5" ]; do sleep 0.01; done
+    fm_lock_release "$3"
+  ' _ "$ROOT/bin/fm-wake-lib.sh" "$ROOT/bin/fm-checkout-lock-lib.sh" "$lock" "$ready" "$release" &
+  holder=$!
+  for _ in 1 2 3 4 5 6 7 8 9 10; do
+    [ -f "$ready" ] && break
+    kill -0 "$holder" 2>/dev/null || break
+    sleep 0.05
+  done
+  [ -f "$ready" ] || { kill "$holder" 2>/dev/null || true; fail "checkout lock holder never published ownership"; }
 
   out=$(FM_CHECKOUT_REFRESH_LOCK_ROOT="$lock_root" \
     FM_HOME="$home" FM_ROOT_OVERRIDE="$ROOT" \
     "$ROOT/bin/fm-fleet-sync.sh" "$clone" 2>/dev/null)
 
-  assert_contains "$out" "$clone: skipped: refresh already running (pid $$)" \
+  assert_contains "$out" "$clone: skipped: refresh already running (pid $holder)" \
     "direct fleet sync bypassed the shared checkout lock"
   [ "$(head_sha "$clone")" = "$before" ] || fail "direct sync mutated a contended checkout"
-  rm -rf "$lock"
+  : > "$release"
+  wait "$holder" || fail "checkout lock holder did not release cleanly"
   pass "direct sync serializes through the shared canonical checkout lock"
 }
 
 test_direct_sync_timeout_terminates_descendants() {
-  local home clone fakebin real_git out status parent_pid child_pid common key lock_root lock
+  local home clone fakebin real_git out status parent_pid child_pid lock_root lock
   home=$(new_home)
   clone=$(build_pair "$home" direct-timeout)
   advance_origin "$home" direct-timeout C1
   fakebin="$home/direct-timeout-fakebin"
   real_git=$(command -v git)
   mkdir -p "$fakebin"
-  common=$(git -C "$clone" rev-parse --git-common-dir)
-  case "$common" in /*) ;; *) common="$clone/$common" ;; esac
-  common=$(cd "$common" && pwd -P)
-  key=$(printf '%s' "$common" | shasum -a 256 | awk '{print substr($1,1,24)}')
   lock_root="$home/checkout-refresh-state/locks"
-  lock="$lock_root/$key.lock"
+  fm_checkout_lock_prepare "$lock_root" || fail "could not prepare timeout checkout lock fixture"
+  lock=$(fm_checkout_lock_path "$clone" "$lock_root") || fail "could not resolve timeout checkout lock fixture"
   cat > "$fakebin/git" <<'SH'
 #!/usr/bin/env bash
 is_fetch=0
@@ -581,6 +593,8 @@ SH
   [ "$status" -eq 0 ] || fail "direct bounded fleet sync failed unexpectedly: $out"
   assert_contains "$out" "direct-timeout: skipped: refresh timed out after 1s" \
     "direct fleet sync did not surface its process-tree timeout"
+  [ -f "$home/direct-fetch-parent.pid" ] && [ -f "$home/direct-fetch-child.pid" ] \
+    || fail "direct fleet sync did not start the bounded fetch fixture: $out"
   parent_pid=$(cat "$home/direct-fetch-parent.pid")
   child_pid=$(cat "$home/direct-fetch-child.pid")
   if kill -0 "$parent_pid" 2>/dev/null || kill -0 "$child_pid" 2>/dev/null; then
diff --git a/tests/fm-gate-refuse.test.sh b/tests/fm-gate-refuse.test.sh
index d838b60e01..97d3046efa 100755
--- a/tests/fm-gate-refuse.test.sh
+++ b/tests/fm-gate-refuse.test.sh
@@ -204,20 +204,26 @@ esac
 exit 0
 SH
   chmod +x "$fakebin/tmux"
-  fm_fake_exit0 "$fakebin" treehouse
+  cat > "$fakebin/treehouse" <<'SH'
+#!/usr/bin/env bash
+printf '%s\n' "${FM_FAKE_TREEHOUSE_PATH:?}"
+SH
+  chmod +x "$fakebin/treehouse"
   printf '%s\n' "$fakebin"
 }
 
 # run_spawn <cwd> <home> <id> <proj> <pane> <fakebin> [ASSIGN...] -> combined output
 run_spawn() {
   local cwd=$1 home=$2 id=$3 proj=$4 pane=$5 fakebin=$6; shift 6
-  mkdir -p "$home/data/$id"
+  mkdir -p "$home/data/$id" "$home/treehouse-pools"
   printf 'brief\n' > "$home/data/$id/brief.md"
   ( cd "$cwd" && env -u NO_MISTAKES_GATE -u FM_GATE_REFUSE_BYPASS \
       "FM_ROOT_OVERRIDE=" "FM_HOME=$home" \
       "FM_STATE_OVERRIDE=$home/state" "FM_DATA_OVERRIDE=$home/data" \
       "FM_PROJECTS_OVERRIDE=$home/projects" "FM_CONFIG_OVERRIDE=$home/config" \
+      "FM_TREEHOUSE_ROOT=$home/treehouse-pools" \
       "FM_SPAWN_NO_GUARD=1" "FM_FAKE_PANE_PATH=$pane" "TMUX=fake,1,0" \
+      "FM_FAKE_TREEHOUSE_PATH=$pane" \
       "PATH=$fakebin:$PATH" "$@" \
       "$(guarded_script "$cwd" "$SPAWN")" "$id" "$proj" codex ) 2>&1
 }
@@ -332,13 +338,27 @@ test_send_refuses_and_admits() {
 # task (HEAD reachable from origin), so a normal teardown genuinely succeeds and a
 # refused one leaves the task untouched (mirrors tests/fm-teardown make_case).
 make_teardown_case() {
-  local name=$1 case_dir fakebin t
+  local name=$1 case_dir fakebin wt
   case_dir="$TMP/$name"; fakebin="$case_dir/fakebin"
   mkdir -p "$case_dir/state" "$case_dir/config" "$fakebin"
-  for t in treehouse tmux; do
-    printf '#!/usr/bin/env bash\nexit 0\n' > "$fakebin/$t"
-    chmod +x "$fakebin/$t"
-  done
+  cat > "$fakebin/treehouse" <<'SH'
+#!/usr/bin/env bash
+if [ "${1:-}" = return ]; then
+  target=${!#}
+  git -C "$target" worktree remove --force "$target"
+fi
+exit 0
+SH
+  chmod +x "$fakebin/treehouse"
+  cat > "$fakebin/tmux" <<'SH'
+#!/usr/bin/env bash
+case "${1:-}" in
+  display-message) exit 1 ;;
+  list-windows) exit 0 ;;
+esac
+exit 0
+SH
+  chmod +x "$fakebin/tmux"
   cat > "$fakebin/gh-axi" <<'SH'
 #!/usr/bin/env bash
 case "${1:-} ${2:-}" in
@@ -363,12 +383,17 @@ SH
   rm -rf "$case_dir/_seed"
   git clone -q "$case_dir/origin.git" "$case_dir/project"
   git -C "$case_dir/project" remote set-head origin main 2>/dev/null || true
-  git -C "$case_dir/project" worktree add -q -b fm/task-x1 "$case_dir/wt" main
-  git -C "$case_dir/wt" commit -q --allow-empty -m "shippable work"
-  git -C "$case_dir/wt" push -q origin fm/task-x1
+  wt="$case_dir/pool/1/project"
+  mkdir -p "$case_dir/pool/1"
+  git -C "$case_dir/project" worktree add -q -b fm/task-x1 "$wt" main
+  git -C "$wt" commit -q --allow-empty -m "shippable work"
+  git -C "$wt" push -q origin fm/task-x1
   git -C "$case_dir/project" fetch -q origin
+  printf '{"worktrees":[{"name":"1","path":"%s","leased":true,"lease_holder":"firstmate-task-x1"}]}\n' \
+    "$wt" > "$case_dir/pool/treehouse-state.json"
   fm_write_meta "$case_dir/state/task-x1.meta" \
-    "window=fm-task-x1" "worktree=$case_dir/wt" "project=$case_dir/project" \
+    "window=firstmate:fm-task-x1" "tmux_session_target=firstmate:fm-task-x1" \
+    "worktree=$wt" "project=$case_dir/project" \
     "kind=ship" "mode=no-mistakes"
   touch "$case_dir/state/.last-watcher-beat"
   printf '%s\n' "$case_dir"
@@ -403,7 +428,7 @@ test_teardown_refuses_and_admits() {
   # no-regression: a normal session tears down the landed task.
   case_dir=$(make_teardown_case teardown-ok)
   out=$(run_teardown "$NORMAL_CWD" "$case_dir"); rc=$?
-  expect_code 0 "$rc" "teardown: a normal session must still tear down landed work"
+  expect_code 0 "$rc" "teardown: a normal session must still tear down landed work: $out"
   assert_not_contains "$out" "$ENV_MSG" "teardown: normal teardown must not print the gate refusal"
   assert_not_contains "$out" "$PATH_MSG" "teardown: normal teardown must not print the backstop refusal"
   assert_not_contains "$out" "REFUSED" "teardown: normal teardown of landed work must not refuse"
diff --git a/tests/fm-gotmp.test.sh b/tests/fm-gotmp.test.sh
index 8ce412d29f..2d9aa21f95 100755
--- a/tests/fm-gotmp.test.sh
+++ b/tests/fm-gotmp.test.sh
@@ -40,6 +40,7 @@ cleanup() {
 trap cleanup EXIT
 
 TMP_ROOT=$(mktemp -d "${TMPDIR:-/tmp}/fm-gotmp-tests.XXXXXX")
+TMP_ROOT=$(cd "$TMP_ROOT" && pwd -P)
 
 # Build a fake FM_HOME/FM_ROOT so the real fm-teardown.sh (symlinked in) resolves
 # state and helper scripts inside it. Stub the helper scripts fm-teardown calls so no
@@ -47,8 +48,15 @@ TMP_ROOT=$(mktemp -d "${TMPDIR:-/tmp}/fm-gotmp-tests.XXXXXX")
 # `if [ -d "$WT" ]` guards skip, so teardown runs straight to the cleanup + state rm.
 make_fake_root() {
   local id=$1 tasktmp=$2
-  local fake="$TMP_ROOT/$id"
-  mkdir -p "$fake/bin/backends" "$fake/state"
+  local fake="$TMP_ROOT/$id" worktree
+  mkdir -p "$fake/bin/backends" "$fake/state" "$fake/project" "$fake/treehouse-pools/project/1"
+  fake=$(cd "$fake" && pwd -P)
+  worktree="$fake/treehouse-pools/project/1/project"
+  git -C "$fake/project" init -q
+  git -C "$fake/project" -c user.name=test -c user.email=test@example.invalid commit -q --allow-empty -m initial
+  git -C "$fake/project" worktree add -q -b "fm/$id" "$worktree"
+  printf '{"worktrees":[{"name":"1","path":"%s","leased":true,"lease_holder":"firstmate-%s"}]}\n' \
+    "$worktree" "$id" > "$fake/treehouse-pools/project/treehouse-state.json"
   # Symlink the REAL teardown so the test exercises actual code, not a copy.
   ln -s "$TEARDOWN" "$fake/bin/fm-teardown.sh"
   # fm-backend.sh + its tmux adapter: symlink the REAL files (teardown sources
@@ -61,6 +69,9 @@ make_fake_root() {
   ln -s "$ROOT/bin/fm-composer-lib.sh" "$fake/bin/fm-composer-lib.sh"
   # fm-lock-lib.sh: teardown sources it for the shared lock-staleness proof.
   ln -s "$ROOT/bin/fm-lock-lib.sh" "$fake/bin/fm-lock-lib.sh"
+  ln -s "$ROOT/bin/fm-checkout-lock-lib.sh" "$fake/bin/fm-checkout-lock-lib.sh"
+  ln -s "$ROOT/bin/fm-process-tree-lib.sh" "$fake/bin/fm-process-tree-lib.sh"
+  ln -s "$ROOT/bin/fm-wake-lib.sh" "$fake/bin/fm-wake-lib.sh"
   # fm-gate-refuse-lib.sh: teardown sources it before any fleet mutation.
   ln -s "$ROOT/bin/fm-gate-refuse-lib.sh" "$fake/bin/fm-gate-refuse-lib.sh"
   ln -s "$ROOT/bin/fm-account-routing-lib.sh" "$fake/bin/fm-account-routing-lib.sh"
@@ -76,6 +87,21 @@ SH
 exit 0
 SH
   chmod +x "$fake/bin/fm-fleet-sync.sh"
+  cat > "$fake/bin/treehouse" <<'SH'
+#!/usr/bin/env bash
+if [ "${1:-}" = return ]; then
+  target=${!#}
+  git -C "$target" worktree remove --force "$target"
+fi
+exit 0
+SH
+  chmod +x "$fake/bin/treehouse"
+  cat > "$fake/bin/tmux" <<'SH'
+#!/usr/bin/env bash
+case "${1:-}" in display-message) exit 1 ;; list-windows) exit 0 ;; esac
+exit 0
+SH
+  chmod +x "$fake/bin/tmux"
   # fm-tasks-axi-lib.sh: stub (teardown sources it). Report no backend so
   # backlog_refresh_reminder takes the plain-message path; no tasks-axi here.
   cat > "$fake/bin/fm-tasks-axi-lib.sh" <<'SH'
@@ -84,8 +110,9 @@ SH
   # Meta with a nonexistent worktree so the dirty/treehouse blocks skip.
   cat > "$fake/state/$id.meta" <<META
 window=fakeses:fm-$id
-worktree=$TMP_ROOT/nonexistent-worktree-$id
-project=$TMP_ROOT/nonexistent-project-$id
+tmux_session_target=fakeses:fm-$id
+worktree=$worktree
+project=$fake/project
 harness=claude
 kind=ship
 mode=no-mistakes
@@ -106,7 +133,8 @@ test_spawn_contract_and_mkdir_pattern() {
   # shellcheck disable=SC2016  # single quotes are deliberate: literal source string
   grep -F 'echo "tasktmp=$TASK_TMP"' "$SPAWN" >/dev/null \
     || fail "fm-spawn missing: tasktmp= line in meta write"
-  grep -F 'export GOTMPDIR=' "$SPAWN" >/dev/null \
+  # shellcheck disable=SC2016  # single quotes are deliberate: literal source string
+  grep -F 'GOTMPDIR=$TASK_TMP/gotmp' "$SPAWN" >/dev/null \
     || fail "fm-spawn missing: GOTMPDIR export into pane"
   # Behavioral: the mkdir + meta-write pattern spawn uses must produce a gotmp dir and
   # a meta line whose value the teardown grep (tasktmp=, cut -d= -f2-) reads back whole.
@@ -132,7 +160,7 @@ test_spawn_contract_and_mkdir_pattern() {
 # --- fm-teardown side (real subprocess) ---
 
 test_teardown_removes_tasktmp_dir() {
-  local id=td-rm-z2
+  local id="td-rm-z2-$$"
   local task_tmp="/tmp/fm-$id"
   mkdir -p "$task_tmp/gotmp"
   printf 'leftover\n' > "$task_tmp/gotmp/build-artifact"
@@ -141,8 +169,9 @@ test_teardown_removes_tasktmp_dir() {
   # Sanity: dir + contents exist before teardown.
   [ -d "$task_tmp/gotmp" ] || fail "precondition: gotmp missing before teardown"
   # Run the REAL teardown against the fake root.
-  FM_HOME="$fake" bash "$fake/bin/fm-teardown.sh" "$id" >/dev/null 2>&1 \
-    || fail "teardown exited non-zero with a valid tasktmp"
+  local teardown_out
+  teardown_out=$(PATH="$fake/bin:$PATH" TMPDIR="$TMP_ROOT" FM_HOME="$fake" FM_TREEHOUSE_ROOT="$fake/treehouse-pools" bash "$fake/bin/fm-teardown.sh" "$id" 2>&1) \
+    || fail "teardown exited non-zero with a valid tasktmp: $teardown_out"
   [ ! -e "$task_tmp" ] \
     || fail "teardown did not remove the tasktmp dir ($task_tmp still exists)"
   pass "fm-teardown removes the dir pointed to by tasktmp= in meta"
@@ -151,56 +180,28 @@ test_teardown_removes_tasktmp_dir() {
 test_teardown_skips_gracefully_without_tasktmp() {
   # Backward compat: a meta from a pre-fix task has no tasktmp= line. Teardown must
   # not error and must not remove anything.
-  local id=td-absent-z3
-  local fake="$TMP_ROOT/$id-root"
-  mkdir -p "$fake/bin/backends" "$fake/state"
-  ln -s "$TEARDOWN" "$fake/bin/fm-teardown.sh"
-  ln -s "$ROOT/bin/fm-backend.sh" "$fake/bin/fm-backend.sh"
-  ln -s "$ROOT/bin/backends/tmux.sh" "$fake/bin/backends/tmux.sh"
-  ln -s "$ROOT/bin/fm-tmux-lib.sh" "$fake/bin/fm-tmux-lib.sh"
-  ln -s "$ROOT/bin/fm-composer-lib.sh" "$fake/bin/fm-composer-lib.sh"
-  ln -s "$ROOT/bin/fm-lock-lib.sh" "$fake/bin/fm-lock-lib.sh"
-  # fm-gate-refuse-lib.sh: teardown sources it before any fleet mutation.
-  ln -s "$ROOT/bin/fm-gate-refuse-lib.sh" "$fake/bin/fm-gate-refuse-lib.sh"
-  ln -s "$ROOT/bin/fm-account-routing-lib.sh" "$fake/bin/fm-account-routing-lib.sh"
-  cat > "$fake/bin/fm-guard.sh" <<'SH'
-#!/usr/bin/env bash
-exit 0
-SH
-  chmod +x "$fake/bin/fm-guard.sh"
-  cat > "$fake/bin/fm-fleet-sync.sh" <<'SH'
-#!/usr/bin/env bash
-exit 0
-SH
-  chmod +x "$fake/bin/fm-fleet-sync.sh"
-  cat > "$fake/bin/fm-tasks-axi-lib.sh" <<'SH'
-fm_tasks_axi_backend_available() { return 1; }
-SH
-  # No tasktmp= line at all.
-  cat > "$fake/state/$id.meta" <<META
-window=fakeses:fm-$id
-worktree=$TMP_ROOT/nonexistent-wt-$id
-project=$TMP_ROOT/nonexistent-proj-$id
-harness=claude
-kind=ship
-mode=no-mistakes
-yolo=off
-META
-  FM_HOME="$fake" bash "$fake/bin/fm-teardown.sh" "$id" >/dev/null 2>&1 \
+  local id="td-absent-z3-$$"
+  local fake meta
+  fake=$(make_fake_root "$id" "/tmp/fm-$id")
+  meta="$fake/state/$id.meta"
+  awk '!/^tasktmp=/' "$meta" > "$meta.without-tasktmp"
+  mv "$meta.without-tasktmp" "$meta"
+  PATH="$fake/bin:$PATH" FM_HOME="$fake" FM_TREEHOUSE_ROOT="$fake/treehouse-pools" bash "$fake/bin/fm-teardown.sh" "$id" >/dev/null 2>&1 \
     || fail "teardown exited non-zero when tasktmp= was absent"
   pass "fm-teardown skips gracefully when tasktmp= is absent (backward compat)"
 }
 
 test_teardown_skips_gracefully_when_dir_missing() {
   # tasktmp= points to a path that does not exist. Teardown must not error.
-  local id=td-missing-z4
+  local id="td-missing-z4-$$"
   local task_tmp="/tmp/fm-$id"
   # Intentionally do NOT create $task_tmp.
   [ ! -e "$task_tmp" ] || fail "precondition: task_tmp should not exist yet"
   local fake
   fake=$(make_fake_root "$id" "$task_tmp")
-  FM_HOME="$fake" bash "$fake/bin/fm-teardown.sh" "$id" >/dev/null 2>&1 \
-    || fail "teardown exited non-zero when tasktmp dir was missing"
+  local teardown_out
+  teardown_out=$(PATH="$fake/bin:$PATH" FM_HOME="$fake" FM_TREEHOUSE_ROOT="$fake/treehouse-pools" bash "$fake/bin/fm-teardown.sh" "$id" 2>&1) \
+    || fail "teardown exited non-zero when tasktmp dir was missing: $teardown_out"
   [ ! -e "$task_tmp" ] || fail "teardown created/left the tasktmp dir unexpectedly"
   pass "fm-teardown skips gracefully when tasktmp= points to a nonexistent dir"
 }
diff --git a/tests/fm-grok-harness.test.sh b/tests/fm-grok-harness.test.sh
index 9087005cfe..2af799a973 100755
--- a/tests/fm-grok-harness.test.sh
+++ b/tests/fm-grok-harness.test.sh
@@ -19,14 +19,29 @@ case "$*" in
   *"#{pane_current_path}"*) printf '%s\n' "${FM_FAKE_PANE_PATH:-}"; exit 0 ;;
 esac
 case "${1:-}" in
-  display-message) printf 'firstmate\n'; exit 0 ;;
+  display-message)
+    [ ! -f "${FM_STATE_OVERRIDE:-/nonexistent}/.fake-killed" ] || exit 1
+    printf 'firstmate\n'
+    exit 0
+    ;;
   list-windows) exit 0 ;;
-  has-session|new-session|new-window|send-keys|kill-window) exit 0 ;;
+  kill-window) : > "$FM_STATE_OVERRIDE/.fake-killed"; exit 0 ;;
+  has-session|new-session|new-window|send-keys) exit 0 ;;
 esac
 exit 0
 SH
   chmod +x "$fakebin/tmux"
   fm_fake_exit0 "$fakebin" treehouse gh-axi gh
+  cat > "$fakebin/treehouse" <<'SH'
+#!/usr/bin/env bash
+if [ "${1:-}" = return ]; then
+  target=${!#}
+  git -C "$target" worktree remove --force "$target"
+  exit $?
+fi
+printf '%s\n' "${FM_FAKE_TREEHOUSE_PATH:?}"
+SH
+  chmod +x "$fakebin/treehouse"
   printf '%s\n' "$fakebin"
 }
 
@@ -35,13 +50,16 @@ make_spawn_case() {
   case_dir="$TMP_ROOT/$name"
   home="$case_dir/home"
   proj="$case_dir/project"
-  wt="$case_dir/wt"
+  wt="$home/treehouse-pools/project/1/project"
   fakebin=$(make_spawn_fakebin "$case_dir/fake")
   grok_home="$case_dir/grok"
   id="grok-$name-x1"
-  mkdir -p "$home/data/$id" "$home/projects" "$home/state" "$home/config" "$grok_home"
+  mkdir -p "$home/data/$id" "$home/projects" "$home/state" "$home/config" "$home/treehouse-pools/project/1" "$grok_home"
   printf 'brief\n' > "$home/data/$id/brief.md"
   fm_git_worktree "$proj" "$wt" "fm/$id"
+  git -C "$wt" checkout -q --detach
+  printf '{"worktrees":[{"name":"1","path":"%s","leased":true,"lease_holder":"firstmate-%s"}]}\n' \
+    "$wt" "$id" > "$home/treehouse-pools/project/treehouse-state.json"
   touch "$home/state/.last-watcher-beat"
   printf '%s\n' "$case_dir|$home|$proj|$wt|$fakebin|$grok_home|$id"
 }
@@ -51,7 +69,9 @@ run_grok_spawn() {
   FM_ROOT_OVERRIDE='' FM_HOME="$home" \
     FM_STATE_OVERRIDE="$home/state" FM_DATA_OVERRIDE="$home/data" \
     FM_PROJECTS_OVERRIDE="$home/projects" FM_CONFIG_OVERRIDE="$home/config" \
+    FM_TREEHOUSE_ROOT="$home/treehouse-pools" \
     FM_SPAWN_NO_GUARD=1 FM_FAKE_PANE_PATH="$wt" TMUX="fake,1,0" \
+    FM_FAKE_TREEHOUSE_PATH="$wt" \
     GROK_HOME="$grok_home" PATH="$fakebin:$PATH" \
     "$SPAWN" "$id" "$proj" grok 2>&1
 }
@@ -107,7 +127,7 @@ EOF
   token=$(sed -n 's/^token=//p' "$wt/.fm-grok-turnend")
 
   FM_ROOT_OVERRIDE="$ROOT" FM_HOME="$home" FM_STATE_OVERRIDE="$home/state" \
-    GROK_HOME="$grok_home" PATH="$fakebin:$PATH" \
+    FM_TREEHOUSE_ROOT="$home/treehouse-pools" GROK_HOME="$grok_home" PATH="$fakebin:$PATH" \
     "$TEARDOWN" "$id" --force >/dev/null 2>&1 \
     || fail "grok teardown failed"
 
diff --git a/tests/fm-report-stack.test.sh b/tests/fm-report-stack.test.sh
index 79a5fcf2ee..6301945b82 100755
--- a/tests/fm-report-stack.test.sh
+++ b/tests/fm-report-stack.test.sh
@@ -704,6 +704,65 @@ test_required_source_fails_closed() {
   pass "report stack refuses a required ship report with no completion source"
 }
 
+test_required_sections_accept_one_top_heading_level_in_order() {
+  local id source entry manifest out status
+
+  id=report-level-one-b2a
+  write_task "$id" ship
+  source="$HOME_DIR/data/$id/completion.md"
+  cat > "$source" <<'EOF'
+# Summary
+
+Level-one sections are accepted.
+
+# What changed
+
+Recorded work.
+
+# Verification
+
+Evidence checked.
+
+# Visual evidence
+
+None.
+
+# Artifacts
+
+Report.
+
+# Follow-ups
+
+None.
+EOF
+  run_stack publish "$id" >/dev/null || fail "ordered level-one report sections were rejected"
+  entry=$(run_stack path "$id")
+  manifest="$(dirname "$entry")/manifest.json"
+  assert_grep '"summary": "Level one sections are accepted."' "$manifest" \
+    "manifest summary did not follow the accepted level-one section structure"
+
+  id=report-mixed-levels-b2b
+  write_task "$id" ship
+  source="$HOME_DIR/data/$id/completion.md"
+  printf '# Summary\n\nComplete.\n\n## What changed\n\nChanged.\n\n## Verification\n\nVerified.\n\n## Visual evidence\n\nNone.\n\n## Artifacts\n\nReport.\n\n## Follow-ups\n\nNone.\n' > "$source"
+  out=$(run_stack publish "$id" 2>&1)
+  status=$?
+  [ "$status" -ne 0 ] || fail "mixed level-one and level-two report sections unexpectedly published"
+  assert_contains "$out" "do not share one top structural level (# or ##)" \
+    "mixed-heading refusal did not explain the common-level requirement"
+
+  id=report-out-of-order-b2c
+  write_task "$id" ship
+  source="$HOME_DIR/data/$id/completion.md"
+  printf '# Summary\n\nComplete.\n\n# Verification\n\nVerified.\n\n# What changed\n\nChanged.\n\n# Visual evidence\n\nNone.\n\n# Artifacts\n\nReport.\n\n# Follow-ups\n\nNone.\n' > "$source"
+  out=$(run_stack publish "$id" 2>&1)
+  status=$?
+  [ "$status" -ne 0 ] || fail "out-of-order level-one report sections unexpectedly published"
+  assert_contains "$out" "required section headings are out of order" \
+    "out-of-order refusal did not explain the ordering requirement"
+  pass "report stack accepts level one or two while rejecting mixed and out-of-order sections"
+}
+
 test_required_sections_fail_actionably() {
   local id=report-headings-b3 out status before after source heading
   write_task "$id" ship
@@ -4018,6 +4077,12 @@ if [ "${FM_TEST_FOCUSED:-}" = report-fence-enforcement ]; then
   exit 0
 fi
 
+if [ "${FM_TEST_FOCUSED:-}" = report-heading-levels ]; then
+  test_required_sections_accept_one_top_heading_level_in_order
+  test_required_sections_reject_empty_bodies
+  exit 0
+fi
+
 if [ "${FM_TEST_FOCUSED:-}" = fenced-report-body-final ]; then
   test_fenced_required_section_bodies_use_scoped_content
   test_nested_short_fences_do_not_satisfy_required_sections
@@ -4097,6 +4162,7 @@ test_metadata_is_bounded_before_reading
 test_report_temps_are_exclusive_and_randomized
 test_visual_inventory_is_count_and_depth_bounded
 test_required_source_fails_closed
+test_required_sections_accept_one_top_heading_level_in_order
 test_required_sections_fail_actionably
 test_required_sections_reject_empty_bodies
 test_required_sections_reject_container_only_markers
diff --git a/tests/fm-secondmate-harness.test.sh b/tests/fm-secondmate-harness.test.sh
index 34a12591fa..418379e06f 100755
--- a/tests/fm-secondmate-harness.test.sh
+++ b/tests/fm-secondmate-harness.test.sh
@@ -38,6 +38,7 @@ set -u
 . "$ROOT/bin/fm-config-inherit-lib.sh"
 
 BASE_PATH=${FM_TEST_BASE_PATH:-/usr/bin:/bin:/usr/sbin:/sbin}
+REAL_GIT=$(PATH="$BASE_PATH" command -v git)
 fm_git_identity fmtest fmtest@example.com
 TMP_ROOT=$(fm_test_tmproot fm-secondmate-harness)
 export FM_BACKEND=tmux
@@ -245,6 +246,17 @@ make_noop_tmux() {
 exit 0
 SH
   chmod +x "$fakebin/tmux"
+  cat > "$fakebin/git" <<'SH'
+#!/usr/bin/env bash
+case " $* " in
+  *" ls-remote --symref origin HEAD "*|*" ls-remote --symref origin HEAD")
+    printf 'ref: refs/heads/%s\tHEAD\n%s\tHEAD\n' "$FM_FAKE_LIVE_DEFAULT_BRANCH" "$FM_FAKE_LIVE_DEFAULT_TIP"
+    exit 0
+    ;;
+esac
+exec "$FM_TEST_REAL_GIT" "$@"
+SH
+  chmod +x "$fakebin/git"
   printf '%s\n' "$fakebin"
 }
 
@@ -252,11 +264,17 @@ SH
 # seed marker, AGENTS.md, bin/, and a charter to launch). config/ is intentionally
 # left absent so the spawn's propagation is what creates it.
 make_seeded_home() {
-  local home=$1 id=$2
+  local home=$1 id=$2 branch primary
+  branch=$(git -C "$ROOT" for-each-ref --format='%(refname:short)' --contains HEAD refs/heads | head -1)
+  git clone --quiet "$ROOT" "$home"
+  git -C "$home" checkout --quiet -B "$branch" origin/main
   mkdir -p "$home/bin" "$home/data"
-  printf '# Firstmate\n' > "$home/AGENTS.md"
   printf '%s\n' "$id" > "$home/.fm-secondmate-home"
   printf 'charter\n' > "$home/data/charter.md"
+  primary="${home%/*}/home"
+  mkdir -p "$primary/data"
+  printf '%s\n' "- $id - test secondmate (home: $(cd "$home" && pwd -P); scope: test; projects: ; added 2026-07-26)" \
+    > "$primary/data/secondmates.md"
 }
 
 # spawn_secondmate <world> <id> <home> [explicit-harness]
@@ -265,18 +283,24 @@ make_seeded_home() {
 # detect_own. stderr is discarded (the local-HEAD ff sync harmlessly skips a
 # non-worktree home). Inspect <world>/home/state/<id>.meta and <home>/config after.
 spawn_secondmate() {
-  local world=$1 id=$2 home=$3 harness=${4:-} fakebin
-  mkdir -p "$world/home/state" "$world/home/data"
+  local world=$1 id=$2 home=$3 harness=${4:-} fakebin branch
+  mkdir -p "$world/home/state" "$world/home/data" "$world/home/treehouse-pools"
+  printf '%s\n' "- $id - test secondmate (home: $(cd "$home" && pwd -P); scope: test; projects: ; added 2026-07-26)" \
+    > "$world/home/data/secondmates.md"
   fakebin=$(make_noop_tmux "$world/tmux-$id")
+  branch=$(git -C "$ROOT" for-each-ref --format='%(refname:short)' --contains HEAD refs/heads | head -1)
   # An empty harness must contribute zero args, not an empty positional; build the
   # arg list explicitly so the optional harness is omitted cleanly.
   local spawn_args=("$id" "$home")
   [ -n "$harness" ] && spawn_args+=("$harness")
   spawn_args+=(--secondmate)
   PATH="$fakebin:$BASE_PATH" TMUX='' CLAUDECODE=1 \
+    FM_TEST_REAL_GIT="$REAL_GIT" FM_FAKE_LIVE_DEFAULT_BRANCH="$branch" \
+    FM_FAKE_LIVE_DEFAULT_TIP="$(git -C "$ROOT" rev-parse origin/main)" \
     FM_ROOT_OVERRIDE="$ROOT" FM_HOME="$world/home" \
     FM_STATE_OVERRIDE="$world/home/state" FM_DATA_OVERRIDE="$world/home/data" \
     FM_PROJECTS_OVERRIDE="$world/home/projects" FM_CONFIG_OVERRIDE="$world/home/config" \
+    FM_TREEHOUSE_ROOT="$world/home/treehouse-pools" \
     FM_SPAWN_NO_GUARD=1 \
     "$ROOT/bin/fm-spawn.sh" "${spawn_args[@]}" >/dev/null 2>&1 || true
 }
@@ -441,6 +465,17 @@ esac
 exit 0
 SH
   chmod +x "$fakebin/tmux"
+  cat > "$fakebin/git" <<'SH'
+#!/usr/bin/env bash
+case " $* " in
+  *" ls-remote --symref origin HEAD "*|*" ls-remote --symref origin HEAD")
+    printf 'ref: refs/heads/%s\tHEAD\n%s\tHEAD\n' "$FM_FAKE_LIVE_DEFAULT_BRANCH" "$FM_FAKE_LIVE_DEFAULT_TIP"
+    exit 0
+    ;;
+esac
+exec "$FM_TEST_REAL_GIT" "$@"
+SH
+  chmod +x "$fakebin/git"
   printf '%s\n' "$fakebin"
 }
 
@@ -448,12 +483,15 @@ SH
 # Same shape as spawn_secondmate but captures the launch command into <launchlog>
 # and does not discard stderr, so callers can assert on both.
 spawn_secondmate_capture() {
-  local world=$1 id=$2 home=$3 launchlog=$4 fakebin
+  local world=$1 id=$2 home=$3 launchlog=$4 fakebin branch
   shift 4
   mkdir -p "$world/home/state" "$world/home/data"
   fakebin=$(make_launch_capturing_tmux "$world/tmux-$id")
+  branch=$(git -C "$ROOT" for-each-ref --format='%(refname:short)' --contains HEAD refs/heads | head -1)
   : > "$launchlog"
   PATH="$fakebin:$BASE_PATH" TMUX='' CLAUDECODE=1 \
+    FM_TEST_REAL_GIT="$REAL_GIT" FM_FAKE_LIVE_DEFAULT_BRANCH="$branch" \
+    FM_FAKE_LIVE_DEFAULT_TIP="$(git -C "$ROOT" rev-parse origin/main)" \
     FM_ROOT_OVERRIDE="$ROOT" FM_HOME="$world/home" \
     FM_STATE_OVERRIDE="$world/home/state" FM_DATA_OVERRIDE="$world/home/data" \
     FM_PROJECTS_OVERRIDE="$world/home/projects" FM_CONFIG_OVERRIDE="$world/home/config" \
@@ -655,6 +693,16 @@ test_spawn_fallback_chain_and_crew_scout_unaffected() {
   wt="$w/crew-wt"
   fakebin=$(make_launch_capturing_tmux "$w/tmux-crew")
   fm_git_worktree "$proj" "$wt" "wt-crew"
+  git -C "$wt" checkout --quiet --detach
+  cat > "$fakebin/treehouse" <<'SH'
+#!/usr/bin/env bash
+case "$*" in
+  'get --help') printf '%s\n' 'Usage: treehouse get [--lease]' ;;
+  get\ --lease*) printf '%s\n' "${FM_FAKE_PANE_PATH:?}" ;;
+esac
+exit 0
+SH
+  chmod +x "$fakebin/treehouse"
   mkdir -p "$home/data/$id" "$home/projects" "$home/state"
   printf 'brief\n' > "$home/data/$id/brief.md"
   : > "$launchlog"
@@ -662,6 +710,8 @@ test_spawn_fallback_chain_and_crew_scout_unaffected() {
   node_bin=$(command -v node) || fail "crew-unaffected: node is required"
   node_dir=$(dirname "$node_bin")
   PATH="$fakebin:$node_dir:$BASE_PATH" TMUX="fake,1,0" CLAUDECODE=1 \
+    FM_TEST_REAL_GIT="$REAL_GIT" FM_FAKE_LIVE_DEFAULT_BRANCH=main \
+    FM_FAKE_LIVE_DEFAULT_TIP="$(git -C "$proj" rev-parse HEAD)" \
     FM_ROOT_OVERRIDE="$ROOT" FM_HOME="$home" \
     FM_STATE_OVERRIDE="$home/state" FM_DATA_OVERRIDE="$home/data" \
     FM_PROJECTS_OVERRIDE="$home/projects" FM_CONFIG_OVERRIDE="$home/config" \
diff --git a/tests/fm-secondmate-lifecycle-e2e.test.sh b/tests/fm-secondmate-lifecycle-e2e.test.sh
index fd71fdb359..be848467bb 100755
--- a/tests/fm-secondmate-lifecycle-e2e.test.sh
+++ b/tests/fm-secondmate-lifecycle-e2e.test.sh
@@ -28,6 +28,7 @@ set -u
 . "$(dirname "${BASH_SOURCE[0]}")/secondmate-helpers.sh"
 
 TMP_ROOT=$(fm_test_tmproot fm-secondmate-lifecycle)
+ROOT=$(make_refreshable_firstmate_source "$TMP_ROOT/firstmate-source") || fail "could not create refreshable Firstmate source"
 export FM_BACKEND=tmux
 
 HOME_DIR="$TMP_ROOT/main home"
@@ -211,9 +212,12 @@ phase_recovery() {
 phase_teardown() {
   local teardown_out
   : > "$LOG"
-  teardown_out=$(PATH="$FAKEBIN:$PATH" FM_HOME="$HOME_DIR" FM_FAKE_TMUX_LOG="$LOG" FM_FAKE_TMUX_CAPTURE="$PANE" \
+  unlink "$SUB/projects/gamma/.no-mistakes-init"
+  unlink "$SUB/projects/gamma/.no-mistakes-doctor"
+  teardown_out=$(PATH="$FAKEBIN:$PATH" FM_HOME="$HOME_DIR" FM_PROJECTS_OVERRIDE="$HOME_DIR/projects" \
+    FM_FAKE_TMUX_LOG="$LOG" FM_FAKE_TMUX_CAPTURE="$PANE" \
     "$ROOT/bin/fm-teardown.sh" design 2>&1) \
-    || fail "teardown failed for the empty secondmate home"
+    || fail "teardown failed for the empty secondmate home: $teardown_out"
   printf '%s\n' "$teardown_out" | grep -F 'Backlog:' >/dev/null \
     && fail "secondmate teardown emitted a main-backlog completion reminder"
   assert_absent "$SUB" "teardown did not remove the retired secondmate home"
diff --git a/tests/fm-secondmate-liveness.test.sh b/tests/fm-secondmate-liveness.test.sh
index 345b2b65b3..38801192e1 100755
--- a/tests/fm-secondmate-liveness.test.sh
+++ b/tests/fm-secondmate-liveness.test.sh
@@ -316,6 +316,9 @@ add_sm_home() {
   printf '%s\n' "$id" > "$home/.fm-secondmate-home"
   printf '# Firstmate\n' > "$home/AGENTS.md"
   printf 'charter\n' > "$home/data/charter.md"
+  mkdir -p "$w/home/data"
+  printf '%s\n' "- $id - test secondmate (home: $(cd "$home" && pwd -P); scope: test; projects: ; added 2026-07-26)" \
+    > "$w/home/data/secondmates.md"
   {
     printf 'window=%s\n' "$window"
     printf 'kind=secondmate\n'
@@ -567,16 +570,20 @@ EOF
 
   fake_root="$w/fake-root"
   mkdir -p "$fake_root/bin"
-  cat > "$fake_root/bin/fm-spawn.sh" <<'SH'
+cat > "$fake_root/bin/fm-spawn.sh" <<'SH'
 #!/usr/bin/env bash
-FM_ROOT_OVERRIDE="$FM_TEST_REAL_ROOT" "$FM_TEST_REAL_ROOT/bin/fm-spawn.sh" "$@" > "$FM_MANAGED_SPAWN_OUT" 2>&1
+FM_ROOT_OVERRIDE="$FM_TEST_REAL_ROOT" FM_HOME="$FM_MANAGED_PRIMARY_HOME" \
+  FM_STATE_OVERRIDE="$FM_MANAGED_PRIMARY_HOME/state" FM_DATA_OVERRIDE="$FM_MANAGED_PRIMARY_HOME/data" \
+  "$FM_TEST_REAL_ROOT/bin/fm-spawn.sh" "$@" > "$FM_MANAGED_SPAWN_OUT" 2>&1
 status=$?
 cat "$FM_MANAGED_SPAWN_OUT"
 exit "$status"
 SH
   cat > "$fake_root/bin/fm-account-session-sync.sh" <<'SH'
 #!/usr/bin/env bash
-FM_ROOT_OVERRIDE="$FM_TEST_REAL_ROOT" exec "$FM_TEST_REAL_ROOT/bin/fm-account-session-sync.sh" "$@"
+FM_ROOT_OVERRIDE="$FM_TEST_REAL_ROOT" FM_HOME="$FM_MANAGED_PRIMARY_HOME" \
+  FM_STATE_OVERRIDE="$FM_MANAGED_PRIMARY_HOME/state" FM_DATA_OVERRIDE="$FM_MANAGED_PRIMARY_HOME/data" \
+  exec "$FM_TEST_REAL_ROOT/bin/fm-account-session-sync.sh" "$@"
 SH
   cat > "$fake_root/bin/fm-fleet-sync.sh" <<'SH'
 #!/usr/bin/env bash
@@ -624,6 +631,7 @@ SH
   out=$(run_bootstrap "$tmuxfb:$fb" "$w/home" zsh "$log" \
     FM_ROOT_OVERRIDE="$fake_root" FM_TEST_REAL_ROOT="$ROOT" \
     FM_AGENT_FLEET_BIN="$fake_af" FM_ACCOUNT_SESSION_WAIT_SECONDS=2 \
+    FM_MANAGED_PRIMARY_HOME="$w/home" \
     FM_MANAGED_WORKSPACE="$workspace" \
     FM_MANAGED_NATIVE_DIR_FILE="$native_dir_file" FM_MANAGED_SESSION_REFRESHED="$refreshed" \
     FM_MANAGED_SPAWN_OUT="$w/spawn.out")
diff --git a/tests/fm-secondmate-safety.test.sh b/tests/fm-secondmate-safety.test.sh
index f1c956e44d..22a33cbdd6 100755
--- a/tests/fm-secondmate-safety.test.sh
+++ b/tests/fm-secondmate-safety.test.sh
@@ -11,6 +11,7 @@ set -u
 . "$(dirname "${BASH_SOURCE[0]}")/secondmate-helpers.sh"
 
 TMP_ROOT=$(fm_test_tmproot fm-secondmate-safety)
+ROOT=$(make_refreshable_firstmate_source "$TMP_ROOT/firstmate-source") || fail "could not create refreshable Firstmate source"
 export FM_BACKEND=tmux
 
 make_live_default_firstmate_worktree() {
diff --git a/tests/fm-send-popup-settle.test.sh b/tests/fm-send-popup-settle.test.sh
index 685ce627ab..bf21ea963d 100755
--- a/tests/fm-send-popup-settle.test.sh
+++ b/tests/fm-send-popup-settle.test.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# fm-send pre-submit popup-settle selection (the codex `$<skill>` fix).
+# fm-send bare-skill syntax guard and pre-submit popup-settle selection.
 #
 # Some TUIs open a completion popup when the composer's first character triggers
 # it: codex (and others) for a leading `/` slash command, and codex specifically
@@ -24,6 +24,12 @@
 # real safety net; this settle is only the optimization that lets the popup clear so
 # the first Enter lands.
 #
+# A bare installed-skill token is refused before typing when its prefix is wrong
+# for the resolved harness. That guard is intentionally separate from settle:
+# matching forms still reach the matrix below, ordinary slash commands and
+# multi-token `$` prose keep their old behavior, and unknown-harness explicit
+# targets remain an escape hatch.
+#
 # Every case below passes a LITERAL `$<skill>` / `$price` message in single quotes
 # on purpose - the whole point is to send an unexpanded `$...` line to the agent -
 # so SC2016 (which flags single-quoted `$` as a probably-forgotten expansion) is a
@@ -109,6 +115,25 @@ first_settle() {  # <expected> <label> <harness|--explicit> <message> [selector-
   pass "fm-send popup-settle: $label -> ${expected}s"
 }
 
+refuse_skill_form() {  # <label> <harness> <message> <expected-correction>
+  local label=$1 harness=$2 msg=$3 correction=$4
+  local dir fb log home err rc
+  dir="$TMP_ROOT/refuse-$RANDOM"; mkdir -p "$dir/state"
+  fb=$(make_stubs "$dir"); log="$dir/sleep.log"; home="$dir"; err="$dir/send.err"
+  mkdir -p "$home/.agents/skills/${msg:1}"
+  fm_write_meta "$home/state/popupcase.meta" "window=sess:win" "harness=$harness"
+  : > "$log"
+  env FM_SEND_SETTLE=0 PATH="$fb:$PATH" \
+    FM_ROOT_OVERRIDE="$home" FM_HOME="$home" FM_SLEEP_LOG="$log" \
+    "$SEND" popupcase "$msg" >/dev/null 2>"$err"; rc=$?
+  [ "$rc" -ne 0 ] || fail "$label: wrong skill form unexpectedly sent"
+  assert_contains "$(cat "$err")" "refusing bare skill invocation '$msg' for harness '$harness'" \
+    "$label: refusal omitted the wrong token and resolved harness"
+  assert_contains "$(cat "$err")" "$correction" "$label: refusal omitted the correct form"
+  [ ! -s "$log" ] || fail "$label: wrong skill form reached popup-settle or submission"
+  pass "fm-send skill form: $label refused before typing"
+}
+
 # Codex `$<skill>` gets the long settle so its `$` popup clears (the fix).
 first_settle 1.2 'codex $skill -> long settle' codex '$no-mistakes'
 
@@ -116,8 +141,16 @@ first_settle 1.2 'codex $skill -> long settle' codex '$no-mistakes'
 # task id, not only by the legacy `fm-<id>` window label.
 first_settle 1.2 'codex $skill exact task id -> long settle' codex '$no-mistakes' exact
 
-# Same `$` message to claude keeps the fast path: `$` is ordinary text there.
-first_settle 0.3 'claude $-message -> fast path' claude '$no-mistakes'
+# Claude and Grok use slash skill forms.
+first_settle 1.2 'claude /skill -> long settle' claude '/no-mistakes'
+first_settle 1.2 'grok /skill -> long settle' grok '/no-mistakes'
+
+# Known bare skills with the wrong harness form fail before any text is typed.
+refuse_skill_form 'codex rejects claude skill form' codex '/no-mistakes' "use '\$no-mistakes'"
+refuse_skill_form 'claude rejects codex skill form' claude '$no-mistakes' "use '/no-mistakes'"
+refuse_skill_form 'grok rejects codex skill form' grok '$no-mistakes' "use '/no-mistakes'"
+refuse_skill_form 'installed firstmate skill is also guarded' codex '/reports' "use '\$reports'"
+refuse_skill_form 'unverified opencode form uses natural-language fallback' opencode '/no-mistakes' 'Run the no-mistakes skill.'
 
 # `$`-prefixed plain text to claude (a price) must NOT popup-settle - the regression
 # the codex scoping exists to prevent.
diff --git a/tests/fm-spawn-dispatch-profile.test.sh b/tests/fm-spawn-dispatch-profile.test.sh
index 477e8b9541..6514b70804 100755
--- a/tests/fm-spawn-dispatch-profile.test.sh
+++ b/tests/fm-spawn-dispatch-profile.test.sh
@@ -12,6 +12,7 @@ set -u
 
 SPAWN="$ROOT/bin/fm-spawn.sh"
 TMP_ROOT=$(fm_test_tmproot fm-spawn-dispatch-profile)
+REAL_GIT=$(command -v git)
 
 make_spawn_fakebin() {
   local dir=$1 fakebin
@@ -42,7 +43,24 @@ esac
 exit 0
 SH
   chmod +x "$fakebin/tmux"
-  fm_fake_exit0 "$fakebin" treehouse
+  cat > "$fakebin/treehouse" <<'SH'
+#!/usr/bin/env bash
+printf '%s\n' "${FM_FAKE_TREEHOUSE_PATH:?}"
+SH
+  chmod +x "$fakebin/treehouse"
+  cat > "$fakebin/git" <<'SH'
+#!/usr/bin/env bash
+if [ -n "${FM_FAKE_LIVE_DEFAULT_BRANCH:-}" ] && [ -n "${FM_FAKE_LIVE_DEFAULT_TIP:-}" ]; then
+  case " $* " in
+    *" ls-remote --symref origin HEAD "*|*" ls-remote --symref origin HEAD")
+      printf 'ref: refs/heads/%s\tHEAD\n%s\tHEAD\n' "$FM_FAKE_LIVE_DEFAULT_BRANCH" "$FM_FAKE_LIVE_DEFAULT_TIP"
+      exit 0
+      ;;
+  esac
+fi
+exec "${FM_TEST_REAL_GIT:?}" "$@"
+SH
+  chmod +x "$fakebin/git"
   printf '%s\n' "$fakebin"
 }
 
@@ -55,9 +73,10 @@ make_spawn_case() {
   wt="$case_dir/wt"
   launchlog="$case_dir/launch.log"
   fakebin=$(make_spawn_fakebin "$case_dir/fake")
-  mkdir -p "$home/data" "$home/projects" "$home/state" "$home/config"
+  mkdir -p "$home/data" "$home/projects" "$home/state" "$home/config" "$home/treehouse-pools"
   printf '%s\n' "$harness" > "$home/config/crew-harness"
   fm_git_worktree "$proj" "$wt" "wt-$name"
+  git -C "$wt" checkout -q --detach
   touch "$home/state/.last-watcher-beat"
   for id in "$@"; do
     mkdir -p "$home/data/$id"
@@ -73,11 +92,15 @@ enable_dispatch_profile() {
 }
 
 make_seeded_secondmate_home() {
-  local home=$1 id=$2
+  local home=$1 id=$2 branch
+  branch=$(git -C "$ROOT" for-each-ref --format='%(refname:short)' --contains HEAD refs/heads | head -1)
+  git clone --quiet "$ROOT" "$home"
+  git -C "$home" checkout --quiet -B "$branch" origin/main
   mkdir -p "$home/bin" "$home/data"
-  printf '# Firstmate\n' > "$home/AGENTS.md"
   printf '%s\n' "$id" > "$home/.fm-secondmate-home"
   printf 'charter for %s\n' "$id" > "$home/data/charter.md"
+  printf '%s\n' "- $id - test secondmate (home: $(cd "$home" && pwd -P); scope: test; projects: ; added 2026-07-26)" \
+    > "$HOME_DIR/data/secondmates.md"
 }
 
 run_spawn() {
@@ -87,8 +110,11 @@ run_spawn() {
   FM_ROOT_OVERRIDE='' FM_HOME="$home" \
     FM_STATE_OVERRIDE="$home/state" FM_DATA_OVERRIDE="$home/data" \
     FM_PROJECTS_OVERRIDE="$home/projects" FM_CONFIG_OVERRIDE="$home/config" \
+    FM_TREEHOUSE_ROOT="$home/treehouse-pools" \
     FM_SPAWN_NO_GUARD=1 FM_FAKE_PANE_PATH="$wt" TMUX="fake,1,0" \
+    FM_FAKE_TREEHOUSE_PATH="${FM_TEST_TREEHOUSE_PATH:-$wt}" \
     FM_FAKE_LAUNCH_LOG="$launchlog" GROK_HOME="$home/grok-home" PATH="$fakebin:$PATH" \
+    FM_TEST_REAL_GIT="$REAL_GIT" \
     "$SPAWN" "$@" 2>&1
 }
 
@@ -366,17 +392,20 @@ test_batch_forwards_shared_profile_flags() {
 }
 
 test_active_dispatch_profile_does_not_block_secondmate_launch() {
-  local rec id sm out status
+  local rec id sm out status branch
   id=profile-secondmate-z16
   rec=$(make_spawn_case profile-secondmate codex "$id")
   read_case_record "$rec"
   enable_dispatch_profile "$HOME_DIR"
   sm="$CASE_DIR/secondmate-home"
   make_seeded_secondmate_home "$sm" "$id"
+  branch=$(git -C "$ROOT" for-each-ref --format='%(refname:short)' --contains HEAD refs/heads | head -1)
 
-  out=$(run_spawn "$HOME_DIR" "$WT_DIR" "$FAKEBIN_DIR" "$LAUNCH_LOG" "$id" "$sm" --secondmate)
+  out=$(FM_TEST_TREEHOUSE_PATH="$sm" FM_FAKE_LIVE_DEFAULT_BRANCH="$branch" \
+    FM_FAKE_LIVE_DEFAULT_TIP="$(git -C "$ROOT" rev-parse origin/main)" \
+    run_spawn "$HOME_DIR" "$WT_DIR" "$FAKEBIN_DIR" "$LAUNCH_LOG" "$id" "$sm" --secondmate)
   status=$?
-  expect_code 0 "$status" "secondmate spawn should be exempt from the dispatch-profile explicit harness requirement"
+  expect_code 0 "$status" "secondmate spawn should be exempt from the dispatch-profile explicit harness requirement: $out"
   assert_contains "$out" "spawned $id harness=codex kind=secondmate" "secondmate launch did not use secondmate harness resolution"
   assert_grep "kind=secondmate" "$HOME_DIR/state/$id.meta" "secondmate meta missing kind=secondmate"
   assert_meta_profile "$HOME_DIR/state/$id.meta" codex default default
diff --git a/tests/fm-tangle-guard.test.sh b/tests/fm-tangle-guard.test.sh
index 6745f57b8d..ce0ec07d30 100755
--- a/tests/fm-tangle-guard.test.sh
+++ b/tests/fm-tangle-guard.test.sh
@@ -179,7 +179,7 @@ SH
 
 run_spawn() {
   local home=$1 id=$2 proj=$3 pane=$4 fakebin=$5
-  mkdir -p "$home/data/$id"
+  mkdir -p "$home/data/$id" "$home/treehouse-pools"
   printf 'brief\n' > "$home/data/$id/brief.md"
   FM_ROOT_OVERRIDE='' FM_HOME="$home" \
     FM_STATE_OVERRIDE="$home/state" FM_DATA_OVERRIDE="$home/data" \
@@ -264,7 +264,7 @@ SH
 
 run_spawn_record() {
   local home=$1 id=$2 proj=$3 pane=$4 fakebin=$5 rec=$6
-  mkdir -p "$home/data/$id"
+  mkdir -p "$home/data/$id" "$home/treehouse-pools"
   printf 'brief\n' > "$home/data/$id/brief.md"
   FM_ROOT_OVERRIDE='' FM_HOME="$home" \
     FM_STATE_OVERRIDE="$home/state" FM_DATA_OVERRIDE="$home/data" \
diff --git a/tests/fm-teardown.test.sh b/tests/fm-teardown.test.sh
index ea5751c55d..d31d505074 100755
--- a/tests/fm-teardown.test.sh
+++ b/tests/fm-teardown.test.sh
@@ -704,6 +704,25 @@ run_teardown_named() {
 test_local_only_fork_remote_allows() {
   local case_dir rc
   case_dir=$(make_case fork-allow)
+  cat > "$case_dir/fakebin/tmux" <<'SH'
+#!/usr/bin/env bash
+state="$(dirname "$0")/.tmux-live"
+case "${1:-}" in
+  display-message)
+    [ -f "$state" ] || exit 1
+    case "${*: -1}" in
+      *pane_current_command*) printf 'bash\n' ;;
+      *session_name*window_name*) printf 'firstmate\tfm-task-x1\n' ;;
+      *) printf '%%1\n' ;;
+    esac
+    exit 0
+    ;;
+  list-windows) [ ! -f "$state" ] || printf '%s\n' fm-task-x1; exit 0 ;;
+  kill-window) rm -f "$state"; exit 0 ;;
+esac
+exit 0
+SH
+  chmod +x "$case_dir/fakebin/tmux"
   write_meta "$case_dir" local-only ship
   wt_commit "$case_dir" "fix the thing"
   add_fork_with_pushed_branch "$case_dir"
@@ -1943,7 +1962,15 @@ case "${1:-}" in
     while [ ! -f "$FM_FAKE_ALLOW_KILL" ]; do sleep 0.01; done
     exit 0
     ;;
-  display-message) exit 1 ;;
+  display-message)
+    [ ! -f "$FM_FAKE_ALLOW_KILL" ] || exit 1
+    case "$*" in
+      *'#{session_name}:#{window_name}'*) printf 'firstmate:fm-task-x1\n' ;;
+      *'#{window_name}'*) printf 'fm-task-x1\n' ;;
+      *'#{pane_id}'*) printf '%%1\n' ;;
+    esac
+    exit 0
+    ;;
 esac
 exit 0
 SH
@@ -1953,7 +1980,7 @@ SH
     FM_FAKE_KILL_STARTED="$kill_started" FM_FAKE_ALLOW_KILL="$allow_kill" \
     run_teardown "$case_dir" --force > "$case_dir/stdout" 2> "$case_dir/stderr" &
   teardown_pid=$!
-  for _ in 1 2 3 4 5 6 7 8 9 10; do
+  for _ in $(seq 1 100); do
     [ -f "$kill_started" ] && break
     sleep 0.05
   done
@@ -2003,7 +2030,7 @@ test_managed_child_teardown_locks_generation_before_snapshot() {
     'window=fm-task-x1' \
     'tmux_session_target=firstmate:fm-task-x1' \
     "worktree=$case_dir/wt" \
-    "project=$case_dir/project" \
+    "project=$case_dir/wt" \
     'kind=secondmate' \
     'mode=secondmate' \
     "home=$case_dir/wt"
diff --git a/tests/fm-watch-triage.test.sh b/tests/fm-watch-triage.test.sh
index 393ad2f825..caa50c2e37 100755
--- a/tests/fm-watch-triage.test.sh
+++ b/tests/fm-watch-triage.test.sh
@@ -24,6 +24,7 @@ set -u
 . "$ROOT/bin/fm-classify-lib.sh"
 
 WATCH="$ROOT/bin/fm-watch.sh"
+WATCH_CHECKPOINT="$ROOT/bin/fm-watch-checkpoint.sh"
 DRAIN="$ROOT/bin/fm-wake-drain.sh"
 
 TMP_ROOT=$(fm_test_tmproot fm-watch-triage-tests)
@@ -330,12 +331,16 @@ test_turn_ended_not_working_surfaced() {
   local dir state fakebin out drain_out pid
   dir=$(make_case turn-ended-stopped); state="$dir/state"; fakebin="$dir/fakebin"
   out="$dir/watch.out"; drain_out="$dir/drain.out"
-  : > "$state/task.turn-ended"
   # No running pipeline, no busy pane: the crewmate has stopped (e.g. it finished via
   # an interactive menu and wrote no done: status). Default unknown verdict.
   export FM_FAKE_CREW_STATE='state: unknown · source: none · no current-state source available'
   watch_bg "$state" "$fakebin" "$out"
   pid=$!
+  wait_numeric_file "$state/.watch.lock/pid" 30 || {
+    reap "$pid"
+    fail "watcher did not publish readiness before the stopped turn-end signal"
+  }
+  : > "$state/task.turn-ended"
   wait_for_exit "$pid" 40 || fail "watcher did not surface a turn-end whose crew is not provably working"
   grep -F "signal: $state/task.turn-ended" "$out" >/dev/null || fail "watcher did not print the surfaced turn-end signal"
   FM_STATE_OVERRIDE="$state" "$DRAIN" > "$drain_out" 2>/dev/null || fail "drain after the surfaced turn-end failed"
@@ -1414,6 +1419,43 @@ SH
   pass "watcher delegates per-task sync budgets and separately cadences the sweep"
 }
 
+test_checkpoint_reconciles_managed_secondmate_session() {
+  local dir state fakebin fake_root sync_bin meta out status
+  dir=$(make_case checkpoint-account-session-sync); state="$dir/state"; fakebin="$dir/fakebin"
+  fake_root="$dir/root"
+  sync_bin="$fake_root/bin/fm-account-session-sync.sh"
+  meta="$state/managed-secondmate.meta"
+  out="$dir/checkpoint.out"
+  mkdir -p "$fake_root/bin"
+  fm_write_meta "$meta" \
+    "window=firstmate:fm-managed-secondmate" \
+    "kind=secondmate" \
+    "account_task=fleet-managed-secondmate" \
+    "account_attempt=attempt-managed-secondmate"
+  cat > "$sync_bin" <<'SH'
+#!/usr/bin/env bash
+set -u
+meta="$FM_STATE_OVERRIDE/managed-secondmate.meta"
+grep -q '^kind=secondmate$' "$meta" || exit 1
+grep -q '^account_task=' "$meta" || exit 1
+grep -q '^provider_session_id=' "$meta" && exit 0
+printf 'provider_session_id=session-checkpoint\n' >> "$meta"
+SH
+  chmod +x "$sync_bin"
+
+  set +e
+  env PATH="$fakebin:/usr/bin:/bin:/usr/sbin:/sbin" \
+    FM_ROOT_OVERRIDE="$fake_root" FM_STATE_OVERRIDE="$state" \
+    FM_ACCOUNT_SESSION_SYNC_INTERVAL=0 FM_POLL=1 FM_CHECK_INTERVAL=999999 \
+    FM_HEARTBEAT=999999 "$WATCH_CHECKPOINT" --seconds 8 > "$out" 2>&1
+  status=$?
+  set -e
+  [ "$status" -eq 124 ] || fail "quiet checkpoint watch returned $status: $(cat "$out")"
+  grep -E '^provider_session_id=session-checkpoint$' "$meta" >/dev/null \
+    || fail "checkpoint watch skipped managed-secondmate session reconciliation"
+  pass "checkpoint watches preserve managed-secondmate provider session reconciliation"
+}
+
 test_watcher_markers_refuse_symlinks() {
   local dir state fake_root sync_bin outside before after
   dir=$(make_case watcher-marker-symlink); state="$dir/state"
@@ -1493,6 +1535,12 @@ if [ "${FM_TEST_FOCUSED:-}" = review-round-23 ]; then
   exit 0
 fi
 
+if [ "${FM_TEST_FOCUSED:-}" = checkpoint-account-session-sync ]; then
+  test_account_session_sync_is_bounded_and_cadenced
+  test_checkpoint_reconciles_managed_secondmate_session
+  exit 0
+fi
+
 if [ "${FM_TEST_FOCUSED:-}" = managed-tmux-reverse-map ]; then
   test_managed_tmux_window_id_reverse_mapping
   exit 0
@@ -1540,5 +1588,6 @@ test_beacon_stays_fresh_while_absorbing
 test_afk_present_reverts_watcher_to_one_shot
 test_afk_paused_changed_pane_hands_off_plain_stale
 test_account_session_sync_is_bounded_and_cadenced
+test_checkpoint_reconciles_managed_secondmate_session
 test_watcher_markers_refuse_symlinks
 test_watcher_timeout_wrapper_uses_hard_kill_fallback
diff --git a/tests/secondmate-helpers.sh b/tests/secondmate-helpers.sh
index 3dd0981cb9..e75511af4e 100644
--- a/tests/secondmate-helpers.sh
+++ b/tests/secondmate-helpers.sh
@@ -189,6 +189,24 @@ SH
   git -C "$home" -c user.name='Firstmate Tests' -c user.email='tests@example.invalid' commit -qm initial
 }
 
+# Create a Firstmate source whose advertised default branch is the exact
+# checked-out revision, so explicit-home refresh checks do not depend on the
+# gate worktree's detached HEAD or its older remote default.
+make_refreshable_firstmate_source() {
+  local destination=$1 remote="$1.git"
+  mkdir -p "$destination" || return 1
+  git -C "$ROOT" archive HEAD AGENTS.md .gitignore bin | tar -x -C "$destination" || return 1
+  git -C "$destination" init --quiet -b main || return 1
+  git -C "$destination" add . || return 1
+  git -C "$destination" -c user.name='Firstmate Tests' -c user.email='tests@example.invalid' \
+    commit --quiet -m snapshot || return 1
+  git clone --quiet --bare "$destination" "$remote" || return 1
+  git -C "$destination" remote add origin "$remote" || return 1
+  git -C "$destination" update-ref refs/remotes/origin/main HEAD || return 1
+  git -C "$destination" symbolic-ref refs/remotes/origin/HEAD refs/remotes/origin/main || return 1
+  printf '%s\n' "$destination"
+}
+
 # Scaffold a filled secondmate charter brief under <home>/data/<id>/brief.md.
 # Args: home id charter [project...]
 scaffold_secondmate_charter() {