diff --git a/AGENTS.md b/AGENTS.md
index 256e5c536de..297f330cf48 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -81,7 +81,7 @@ config/supervision-branch-model config/supervision-branch-effort  Pi supervision
 config/supervision-host  optional opt-in to the supervision host, which runs the supervision branch's contract on a headless engine beside a Claude primary in the away posture; LOCAL, gitignored, not inherited; absent changes nothing; see docs/configuration.md "Supervision host"
 config/startup-memory-budget     primary-authoritative per-home startup-memory budget; LOCAL, gitignored, materialized as 7,500 estimated tokens by locked primary bootstrap and inherited into secondmate homes; see docs/configuration.md "Startup memory budget"
 config/stow-pass-horizon  optional presence flag opting this home in to /stow's default-off pass-count decay horizon; LOCAL, gitignored, and not inherited; see docs/configuration.md "Stow pass horizon"
-config/herdr-presentation-spaces  optional "off" opt-out from, or "on" opt-in to, Herdr's default-on disposable single-task visual projection, which is unconfigured-default-on only at or above a Herdr version floor; LOCAL, gitignored; inherited by secondmate homes; see docs/herdr-backend.md "Presentation spaces"
+config/herdr-presentation-spaces  optional Herdr visual layout: "off" opts out of, "on" opts into the default-on disposable single-task projection, and "crew" opens task panes in a shared crew workspace; the unconfigured default requires a Herdr version floor; LOCAL, gitignored; inherited by secondmate homes; see docs/herdr-backend.md "Presentation spaces" and "Crew workspace"
 config/trace-context  optional presence flag enabling default-off native W3C trace-context propagation to spawned agents; LOCAL, gitignored; inherited by secondmate homes; see docs/configuration.md "Trace context propagation" and docs/trace-context.md
 config/lavish-axi-host  optional one-line per-machine Lavish server address; LOCAL, gitignored, inherited by secondmate homes, and exported into every worker launch; see docs/configuration.md "Lavish server address" for opening versus polling
 config/brief-include.md  optional standing worker instructions appended verbatim as the last section of every ship and scout scaffold; LOCAL, gitignored, and not inherited; keep its text out of `## Firstmate spec`; see docs/configuration.md "Home brief include"
diff --git a/README.md b/README.md
index a4faabeaa13..00fd9bfb86c 100644
--- a/README.md
+++ b/README.md
@@ -42,7 +42,7 @@ Launching a supported harness inside it for your primary session instantiates yo
 ## Features
 
 - **One liaison** - you talk only to the first mate; it dispatches, supervises, escalates only real decisions, and reports plain outcomes.
-- **A visible crew** - every crewmate works in its own tmux window or Herdr tab, or in an experimental Zellij tab, experimental cmux workspace, or experimental Orca terminal you can watch or type into; the first mate reconciles.
+- **A visible crew** - every crewmate works in its own tmux window, Herdr tab or configured crew pane, or an experimental Zellij tab, experimental cmux workspace, or experimental Orca terminal you can watch or type into; the first mate reconciles.
 - **Disposable worktrees** - each task runs in a clean [treehouse](https://github.com/kunchenguid/treehouse) git worktree, or an Orca-managed worktree when `backend=orca`, so parallel work on one repo never collides.
 - **Two task shapes** - ship tasks deliver authorized changes; scout tasks leave standalone investigation reports when the intake contract warrants separate research.
 - **Explicit project modes** - each project ships via `no-mistakes`, `direct-PR`, or `local-only`, with an optional `+yolo` merge-autonomy flag, an optional `branch=<prefix>` override for the default `fm/` ship-branch prefix, and an optional `forge=gerrit` binding under which the worker publishes a Gerrit change instead of opening a pull request.
diff --git a/bin/backends/herdr-crew-equalize.py b/bin/backends/herdr-crew-equalize.py
new file mode 100755
index 00000000000..430269e174d
--- /dev/null
+++ b/bin/backends/herdr-crew-equalize.py
@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""Even out the split ratios of one Herdr tab without touching its panes.
+
+This helper is the wire transport for Firstmate's crew-workspace grid
+(docs/herdr-backend.md "Crew workspace"). It sends only two methods: the
+read-only ``layout.export`` for one exact tab, and the non-destructive
+``layout.set_split_ratio``. It never sends ``layout.apply``, which recreates
+every pane (verified against Herdr 0.9.1, protocol 22, and would kill the
+agents running in them).
+
+Each split gets the ratio that gives every pane an equal share along that
+split's direction: a pane counts 1, a split in the same direction sums its
+children, and a split in the other direction takes the larger child. A tree
+of right splits holding down splits therefore becomes an even grid.
+
+Wire protocol verified against Herdr 0.9.1, protocol 22:
+
+  request:  {"id":ID,"method":"layout.export","params":{"tab_id":T}}\\n
+  response: {"id":ID,"result":{"type":"layout_export","layout":
+             {"tab_id":T,"root":NODE,...}}}\\n
+  request:  {"id":ID,"method":"layout.set_split_ratio",
+             "params":{"tab_id":T,"path":[bool...],"ratio":R}}\\n
+  response: {"id":ID,"result":{"type":"layout_split_ratio_set","layout":{...}}}\\n
+
+A path step of false selects a split's first child and true its second.
+
+Usage: herdr-crew-equalize.py <socket_path> <tab_id>
+
+Exit status:
+  0  the tab's final layout has the same panes and the even ratios;
+  2  arguments or socket connection were invalid;
+  3  a request could not be sent or its response could not be read;
+  4  a response was malformed, mismatched, reported an error, or the final
+     layout changed a pane or kept an uneven ratio.
+"""
+
+import json
+import socket
+import sys
+import time
+
+
+CONNECT_TIMEOUT = 5.0
+RESPONSE_TIMEOUT = 5.0
+RECV_CHUNK = 65536
+MAX_RESPONSE_BYTES = 4 * 1024 * 1024
+REQUEST_ID = "fm-crew-equalize"
+TOLERANCE = 0.001
+
+
+class Failure(Exception):
+    def __init__(self, status):
+        super().__init__(status)
+        self.status = status
+
+
+def _read_line(sock, deadline):
+    buffer = b""
+    while b"\n" not in buffer:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            return None
+        sock.settimeout(remaining)
+        try:
+            chunk = sock.recv(RECV_CHUNK)
+        except (OSError, socket.timeout):
+            return None
+        if not chunk:
+            return None
+        buffer += chunk
+        if len(buffer) > MAX_RESPONSE_BYTES:
+            return None
+    return buffer.split(b"\n", 1)[0]
+
+
+def _call(socket_path, method, params, result_type, tab_id):
+    try:
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.settimeout(CONNECT_TIMEOUT)
+        sock.connect(socket_path)
+    except OSError:
+        raise Failure(2)
+    try:
+        request = {"id": REQUEST_ID, "method": method, "params": params}
+        try:
+            sock.sendall(
+                (json.dumps(request, separators=(",", ":")) + "\n").encode("utf-8")
+            )
+        except OSError:
+            raise Failure(3)
+        line = _read_line(sock, time.monotonic() + RESPONSE_TIMEOUT)
+    finally:
+        sock.close()
+    if line is None:
+        raise Failure(3)
+    try:
+        response = json.loads(line.decode("utf-8", "replace"))
+    except ValueError:
+        raise Failure(4)
+    result = response.get("result") if isinstance(response, dict) else None
+    layout = result.get("layout") if isinstance(result, dict) else None
+    if (
+        response.get("id") != REQUEST_ID
+        or response.get("error") is not None
+        or result.get("type") != result_type
+        or not isinstance(layout, dict)
+        or layout.get("tab_id") != tab_id
+        or not isinstance(layout.get("root"), dict)
+    ):
+        raise Failure(4)
+    return layout["root"]
+
+
+def _count(node, direction):
+    kind = node.get("type")
+    if kind == "pane":
+        return 1
+    if kind != "split":
+        raise Failure(4)
+    first, second = node.get("first"), node.get("second")
+    if not isinstance(first, dict) or not isinstance(second, dict):
+        raise Failure(4)
+    if node.get("direction") == direction:
+        return _count(first, direction) + _count(second, direction)
+    return max(_count(first, direction), _count(second, direction))
+
+
+def _targets(node, path, out):
+    """Collect (path, current ratio, even ratio) for every split under node."""
+    if node.get("type") != "split":
+        return
+    direction = node.get("direction")
+    if direction not in ("right", "down"):
+        raise Failure(4)
+    first = _count(node["first"], direction)
+    second = _count(node["second"], direction)
+    ratio = node.get("ratio")
+    if not isinstance(ratio, (int, float)):
+        raise Failure(4)
+    out.append((path, float(ratio), first / (first + second)))
+    _targets(node["first"], path + [False], out)
+    _targets(node["second"], path + [True], out)
+
+
+def _panes(node):
+    if node.get("type") == "pane":
+        return [node.get("pane_id")]
+    return _panes(node["first"]) + _panes(node["second"])
+
+
+def main(argv):
+    if len(argv) != 3:
+        return 2
+    socket_path, tab_id = argv[1:]
+    if not socket_path.startswith("/") or not tab_id:
+        return 2
+    if any(char in tab_id for char in "\t\r\n"):
+        return 2
+    try:
+        root = _call(socket_path, "layout.export", {"tab_id": tab_id}, "layout_export", tab_id)
+        before = _panes(root)
+        targets = []
+        _targets(root, [], targets)
+        for path, current, even in targets:
+            if abs(current - even) <= TOLERANCE:
+                continue
+            _call(
+                socket_path,
+                "layout.set_split_ratio",
+                {"tab_id": tab_id, "path": path, "ratio": even},
+                "layout_split_ratio_set",
+                tab_id,
+            )
+        root = _call(socket_path, "layout.export", {"tab_id": tab_id}, "layout_export", tab_id)
+        if _panes(root) != before:
+            return 4
+        final = []
+        _targets(root, [], final)
+        if any(abs(current - even) > TOLERANCE for _, current, even in final):
+            return 4
+    except Failure as failure:
+        return failure.status
+    except (KeyError, TypeError, AttributeError, RecursionError):
+        return 4
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main(sys.argv))
+    except (BrokenPipeError, KeyboardInterrupt):
+        sys.exit(3)
diff --git a/bin/backends/herdr.sh b/bin/backends/herdr.sh
index d7de3b66a66..68ee994a7fb 100644
--- a/bin/backends/herdr.sh
+++ b/bin/backends/herdr.sh
@@ -17,8 +17,9 @@
 # FIRSTMATE HOME (the primary, and each secondmate, gets its own), ONE herdr TAB
 # per task inside its home's workspace. The default-on presentation projection
 # creates a disposable workspace for a clean fresh task instead unless the home
-# opts out. That
-# workspace is a non-authoritative visual projection containing only the normal
+# opts out, and a home that selects "crew" places each task as a split pane in
+# durable per-home crew workspaces instead (fm_backend_herdr_crew_create_task).
+# A projected workspace is a non-authoritative visual projection containing only the normal
 # task pane. Its random token and mutable label never authorize lookup,
 # adoption, reuse, closure, deletion, task ownership, or endpoint selection.
 # A version 2 journal can participate in replacing only its exact same-identity
@@ -150,13 +151,22 @@ FM_BACKEND_HERDR_SECONDMATE_MARKER=".fm-secondmate-home"
 FM_BACKEND_HERDR_PRESENTATION_JOURNAL_SUFFIX=".herdr-presentation"
 
 # The config item a home writes to opt out of, or explicitly in to, the
-# projection.
+# projection, or to select the shared crew workspace instead.
 FM_BACKEND_HERDR_PRESENTATION_CONFIG="herdr-presentation-spaces"
+# Crew layout: every crewmate and scout of a home becomes one split pane in a
+# durable per-home crew workspace, at most this many panes per workspace
+# before another crew workspace opens right after it. The workspace ids are
+# recorded per named session in the home's state dir under this prefix, so
+# placement never trusts a label.
+FM_BACKEND_HERDR_CREW_PANE_CAP_DEFAULT=6
+FM_BACKEND_HERDR_CREW_RECORD_PREFIX=".herdr-crew-workspace-"
 
 # fm_backend_herdr_presentation_preference <config-dir>: the single owner of
 # config/herdr-presentation-spaces parsing. Echoes exactly one of "off", "on"
-# (a deliberate opt-in, honored even below the version floor), or "default"
-# (this home configured nothing, so the floor decides).
+# (a deliberate opt-in, honored even below the version floor), "crew:<cap>"
+# (shared crew workspaces, split panes capped at <cap> per workspace: "crew"
+# alone means the default cap, "crew:<n>" sets it), or "default" (this home
+# configured nothing, so the floor decides).
 # Values are read with the whole-file whitespace-stripped convention the other
 # scalar config items already use (config/backlog-backend, config/crew-harness),
 # plus case folding. An empty file is the historical presence-based opt-in form
@@ -173,8 +183,10 @@ fm_backend_herdr_presentation_preference() {  # <config-dir>
   case "$value" in
     off) printf 'off\n' ;;
     ''|on) printf 'on\n' ;;
+    crew) printf 'crew:%s\n' "$FM_BACKEND_HERDR_CREW_PANE_CAP_DEFAULT" ;;
+    crew:[1-9]|crew:1[0-6]) printf '%s\n' "$value" ;;
     *)
-      echo "warning: $file: unrecognized value \"$value\"; herdr presentation spaces fall back to the default (write \"off\" to opt out, \"on\" to force the projection on)" >&2
+      echo "warning: $file: unrecognized value \"$value\"; herdr presentation spaces fall back to the default (write \"off\" to opt out, \"on\" to force the projection on, \"crew\" or \"crew:<1-16>\" for shared crew workspaces of split panes)" >&2
       printf 'default\n'
       ;;
   esac
@@ -326,8 +338,10 @@ fm_backend_herdr_presentation_default_supported() {  # <state-dir> [<session>]
 # fm_backend_herdr_presentation_enabled <config-dir> [<state-dir>]: the one gate
 # bin/fm-spawn.sh consults before projecting this home's children into
 # disposable one-task workspaces (docs/herdr-backend.md "Presentation spaces"
-# owns the full contract). An explicit "off" or "on" is obeyed as written; a
-# home that configured nothing is projected only at or above the version floor,
+# owns the full contract). An explicit "off" or "on" is obeyed as written, and
+# "crew:<cap>" is never a per-task projection (the caller reads the
+# out-parameter below to take the crew path instead); a home that configured
+# nothing is projected only at or above the version floor,
 # and otherwise falls back to the flat layout with one warning. Sets
 # FM_BACKEND_HERDR_PRESENTATION_PREFERENCE for the new-projection boundary to
 # distinguish an unconfigured default from an explicit opt-in.
@@ -338,7 +352,7 @@ fm_backend_herdr_presentation_enabled() {  # <config-dir> [<state-dir>]
   # shellcheck disable=SC2034
   FM_BACKEND_HERDR_PRESENTATION_PREFERENCE=$preference
   case "$preference" in
-    off) return 1 ;;
+    off|crew:*) return 1 ;;
     on) return 0 ;;
   esac
   fm_backend_herdr_presentation_default_supported "$state_dir"
@@ -2637,6 +2651,258 @@ fm_backend_herdr_projection_cleanup_exact() {  # <session> <task-pane> <seeded-p
   fi
 }
 
+# --- crew layout: durable per-home workspaces of split task panes -----------
+#
+# docs/herdr-backend.md "Crew workspace" owns the contract. Every crewmate and
+# scout of a home that selected "crew" becomes one split pane in that home's
+# crew workspace, up to the configured cap, then the first pane of another
+# crew workspace ordered right after the last one. A crew workspace is found
+# again only through its exact id recorded in this home's state dir,
+# re-verified against the live session and its expected label, so a label
+# never places a worker. Cleanup needs nothing
+# crew-specific: fm_backend_herdr_kill closes the exact recorded pane under the
+# session lock, and closing a workspace's last pane removes it through the same
+# focus-safe emptying-close plan every other layout uses.
+
+fm_backend_herdr_crew_workspace_label() {
+  printf '%s-crew' "$(fm_backend_herdr_workspace_label)"
+}
+
+fm_backend_herdr_crew_record_path() {  # <state-dir> <session>
+  printf '%s/%s%s' "$1" "$FM_BACKEND_HERDR_CREW_RECORD_PREFIX" "${2//[^A-Za-z0-9_-]/_}"
+}
+
+# fm_backend_herdr_crew_workspace_recorded: echo this home's recorded crew
+# workspace ids for <session>, one per line in the session's workspace order,
+# keeping only ids still present there with this home's crew label; echo
+# nothing when there is no usable record, which includes workspaces Herdr
+# removed with their last pane. Returns 1 when the session's workspaces cannot
+# be read, so an unreadable layout refuses instead of minting another crew
+# workspace. Never mutates.
+fm_backend_herdr_crew_workspace_recorded() {  # <state-dir> <session>
+  local state=$1 session=$2 record ids list
+  record=$(fm_backend_herdr_crew_record_path "$state" "$session")
+  { [ -f "$record" ] && [ ! -L "$record" ]; } || return 0
+  ids=$(jq -R -s -c 'split("\n") | map(select(length > 0))' < "$record" 2>/dev/null) || return 0
+  [ "$ids" != '[]' ] || return 0
+  list=$(fm_backend_herdr_cli "$session" workspace list 2>/dev/null) || return 1
+  printf '%s' "$list" | jq -e '(.result.workspaces | type) == "array"' >/dev/null 2>&1 || return 1
+  printf '%s' "$list" | jq -r --argjson ids "$ids" --arg want "$(fm_backend_herdr_crew_workspace_label)" '
+    .result.workspaces[] | select(.label == $want and (.workspace_id as $ws | $ids | any(. == $ws))) | .workspace_id
+  ' 2>/dev/null
+}
+
+fm_backend_herdr_crew_record_write() {  # <state-dir> <session> <workspace-id>...
+  local state=$1 record tmp
+  record=$(fm_backend_herdr_crew_record_path "$state" "$2")
+  shift 2
+  mkdir -p "$state" || return 1
+  tmp=$(mktemp "$record.XXXXXX") || return 1
+  if ! { printf '%s\n' "$@" > "$tmp" && mv -f "$tmp" "$record"; }; then
+    rm -f "$tmp"
+    return 1
+  fi
+}
+
+# fm_backend_herdr_crew_grid_columns <pane-cap>: the crew tab's grid width.
+# Up to three panes sit side by side; a larger cap uses two rows, so the
+# default cap of 6 is a grid of 3 columns by 2 rows.
+fm_backend_herdr_crew_grid_columns() {  # <pane-cap>
+  if [ "$1" -le 3 ]; then printf '%s' "$1"; else printf '%s' $(( ($1 + 1) / 2 )); fi
+}
+
+# fm_backend_herdr_crew_split_anchor: "<pane-id> <direction>" for the next
+# pane in the crew tab holding <pane-id>, read from that tab's live pane
+# geometry. The grid fills its top row left to right, then its bottom row left
+# to right:
+#   1. While the tab has fewer than <columns> columns and its rightmost column
+#      is one full-height pane, split that pane right to add a column.
+#   2. Otherwise split the leftmost full-height pane down, which also refills
+#      a slot a closed pane left behind.
+#   3. Otherwise (a whole column closed while others stayed full, a shape a
+#      pane split cannot rebuild) split the largest pane across its longer
+#      visual side; the rebalance below still evens every split.
+# Empty when the layout cannot be read.
+fm_backend_herdr_crew_split_anchor() {  # <session> <pane-id> <columns>
+  fm_backend_herdr_cli "$1" pane layout --pane "$2" 2>/dev/null | jq -r --argjson columns "$3" '
+    .result.layout as $layout
+    | ($layout.panes | select(type == "array" and length > 0)) as $panes
+    | ($layout.area.height) as $height
+    | ([$panes[].rect.x] | unique) as $xs
+    | [$panes[] | select(.rect.x == ($xs | max))] as $right
+    | [$panes[] | select(.rect.height == $height)] as $full
+    | if ($xs | length) < $columns and ($right | length) == 1 and $right[0].rect.height == $height
+      then "\($right[0].pane_id) right"
+      elif ($full | length) > 0
+      then "\($full | min_by(.rect.x) | .pane_id) down"
+      else ($panes | max_by(.rect.width * .rect.height))
+        | "\(.pane_id) \(if .rect.width >= 2 * .rect.height then "right" else "down" end)"
+      end
+  ' 2>/dev/null
+}
+
+# fm_backend_herdr_crew_equalize: best-effort rebalance of one crew tab so
+# every pane gets an equal share of the grid, through
+# bin/backends/herdr-crew-equalize.py, which only reads the tab's layout and
+# sets split ratios, never recreating a pane. Any unavailable capability or
+# failure warns and leaves the tab as Herdr drew it; it never fails a caller.
+fm_backend_herdr_crew_equalize() {  # <session> <tab-id>
+  local session=$1 tab=$2 socket helper
+  command -v python3 >/dev/null 2>&1 || {
+    echo "warning: herdr crew grid rebalance requires python3; leaving the crew tab's split sizes as they are" >&2
+    return 0
+  }
+  fm_backend_herdr_cli "$session" api schema --json 2>/dev/null | jq -e '
+    [.schemas.request.oneOf[]?.properties.method.const] as $methods
+    | ($methods | index("layout.export")) != null and ($methods | index("layout.set_split_ratio")) != null
+  ' >/dev/null 2>&1 || {
+    echo "warning: herdr crew grid rebalance needs layout.export and layout.set_split_ratio; leaving the crew tab's split sizes as they are" >&2
+    return 0
+  }
+  socket=$(fm_backend_herdr_presentation_session_socket_path "$session") || {
+    echo "warning: herdr crew grid rebalance found an ambiguous named session socket; leaving the crew tab's split sizes as they are" >&2
+    return 0
+  }
+  helper=${FM_BACKEND_HERDR_CREW_EQUALIZER:-$FM_BACKEND_HERDR_ROOT/bin/backends/herdr-crew-equalize.py}
+  "$helper" "$socket" "$tab" >/dev/null 2>&1 || \
+    echo "warning: herdr crew grid rebalance could not verify even split sizes for tab $tab; leaving it as Herdr drew it" >&2
+  return 0
+}
+
+# fm_backend_herdr_crew_tab_of: echo "<workspace-id> <tab-id>" for <pane-id>
+# only when it lives in this home's labeled crew workspace. The label only
+# gates the non-destructive rebalance after a close, never any placement or
+# removal.
+fm_backend_herdr_crew_tab_of() {  # <session> <pane-id>
+  local session=$1 pane=$2 info ws tab
+  info=$(fm_backend_herdr_cli "$session" pane get "$pane" 2>/dev/null) || return 1
+  ws=$(printf '%s' "$info" | jq -r '.result.pane.workspace_id // empty' 2>/dev/null)
+  tab=$(printf '%s' "$info" | jq -r '.result.pane.tab_id // empty' 2>/dev/null)
+  [ -n "$ws" ] && [ -n "$tab" ] || return 1
+  fm_backend_herdr_cli "$session" workspace list 2>/dev/null | jq -e --arg ws "$ws" --arg want "$(fm_backend_herdr_crew_workspace_label)" '
+    [.result.workspaces[]? | select(.workspace_id == $ws and .label == $want)] | length == 1
+  ' >/dev/null 2>&1 || return 1
+  printf '%s %s' "$ws" "$tab"
+}
+
+# fm_backend_herdr_crew_create_task: place one task as a pane in this home's
+# first recorded crew workspace in <session> holding fewer than <pane-cap>
+# panes. When none has room, a new crew workspace is created, recorded, and
+# ordered right after the last crew workspace, or after <parent-workspace-id>
+# (or the unique home label) when it is the first, best-effort. The caller
+# must hold the named-session presentation lock so the record, workspace
+# choice, and split cannot race another spawn. Call it as a plain statement;
+# it prints nothing and sets:
+#   FM_BACKEND_HERDR_CREW_WORKSPACE_ID FM_BACKEND_HERDR_CREW_TAB_ID
+#   FM_BACKEND_HERDR_CREW_PANE_ID
+# The pane id is set as soon as Herdr returns one, even on a later failure, so
+# the caller's abort cleanup can close exactly that pane.
+# A same-labeled pane in any crew workspace refuses unless it is a husk, which
+# is replaced only after the new pane exists (the flat tab path's rule).
+fm_backend_herdr_crew_create_task() {  # <session> <state-dir> <cwd> <task-label> <pane-cap> [<parent-workspace-id>]
+  local session=$1 state=$2 cwd=$3 label=$4 cap=$5 parent_ws=${6:-}
+  local wsids ws wsid="" last_ws="" out="" panes all_panes="" tab_id="" pane="" count anchor husk husks="" focus_before
+  local created=0
+  FM_BACKEND_HERDR_CREW_WORKSPACE_ID=""
+  FM_BACKEND_HERDR_CREW_TAB_ID=""
+  FM_BACKEND_HERDR_CREW_PANE_ID=""
+  case "$cap" in ''|*[!0-9]*|0) cap=$FM_BACKEND_HERDR_CREW_PANE_CAP_DEFAULT ;; esac
+  wsids=$(fm_backend_herdr_crew_workspace_recorded "$state" "$session") || {
+    echo "error: could not read herdr workspaces in session '$session' to find this home's crew workspaces" >&2
+    return 1
+  }
+  while IFS= read -r ws; do
+    [ -n "$ws" ] || continue
+    panes=$(fm_backend_herdr_cli "$session" pane list --workspace "$ws" 2>/dev/null) || panes=
+    printf '%s' "$panes" | jq -e '(.result.panes | type) == "array"' >/dev/null 2>&1 || {
+      echo "error: could not parse herdr pane list output for crew workspace $ws (session $session)" >&2
+      return 1
+    }
+    while IFS= read -r husk; do
+      [ -n "$husk" ] || continue
+      if ! fm_backend_herdr_tab_is_husk "$session" "$husk"; then
+        echo "error: herdr pane '$label' already exists in crew workspace $ws (session $session)" >&2
+        return 1
+      fi
+      husks="${husks}${husk}"$'\n'
+    done < <(printf '%s' "$panes" | jq -r --arg want "$label" '.result.panes[] | select(.label == $want) | .pane_id' 2>/dev/null)
+    last_ws=$ws
+    # The first crew workspace with room gets a split, so panes freed by
+    # cleanup refill before another workspace opens.
+    count=$(printf '%s' "$panes" | jq -r '.result.panes | length' 2>/dev/null)
+    if [ -z "$wsid" ] && [ "${count:-0}" -gt 0 ] && [ "$count" -lt "$cap" ]; then
+      wsid=$ws
+      all_panes=$panes
+    fi
+  done <<FMEOF
+$wsids
+FMEOF
+  # Every create below passes --no-focus; the snapshot is the same exact-tab
+  # restore backstop the presentation path uses, skipped only when the session
+  # has no single focused tab to restore.
+  focus_before=$(fm_backend_herdr_projection_focus_snapshot "$session") || focus_before=
+  if [ -n "$wsid" ]; then
+    anchor=$(fm_backend_herdr_crew_split_anchor "$session" \
+      "$(printf '%s' "$all_panes" | jq -r '.result.panes[0].pane_id' 2>/dev/null)" \
+      "$(fm_backend_herdr_crew_grid_columns "$cap")")
+    if [ -n "$anchor" ]; then
+      out=$(fm_backend_herdr_cli "$session" pane split "${anchor%% *}" --direction "${anchor#* }" \
+        --cwd "$cwd" --no-focus 2>/dev/null) || out=
+      tab_id=$(printf '%s' "$out" | jq -r '.result.pane.tab_id // empty' 2>/dev/null)
+      pane=$(printf '%s' "$out" | jq -r '.result.pane.pane_id // empty' 2>/dev/null)
+    fi
+  else
+    out=$(fm_backend_herdr_cli "$session" workspace create --cwd "$cwd" \
+      --label "$(fm_backend_herdr_crew_workspace_label)" --no-focus 2>/dev/null) || out=
+    wsid=$(printf '%s' "$out" | jq -r '.result.workspace.workspace_id // empty' 2>/dev/null)
+    tab_id=$(printf '%s' "$out" | jq -r '.result.tab.tab_id // empty' 2>/dev/null)
+    pane=$(printf '%s' "$out" | jq -r '.result.root_pane.pane_id // empty' 2>/dev/null)
+    created=1
+  fi
+  # shellcheck disable=SC2034  # callers consume the crew placement's parts
+  FM_BACKEND_HERDR_CREW_PANE_ID=$pane
+  [ -z "$focus_before" ] || fm_backend_herdr_projection_focus_restore "$session" "$focus_before" "crew pane create" || true
+  if [ -z "$wsid" ] || [ -z "$tab_id" ] || [ -z "$pane" ]; then
+    echo "error: herdr did not return a complete crew workspace, tab, and pane for $label (session $session)" >&2
+    return 1
+  fi
+  if [ "$created" = 1 ]; then
+    # shellcheck disable=SC2086  # one live workspace id per line
+    fm_backend_herdr_crew_record_write "$state" "$session" $wsids "$wsid" || {
+      echo "error: could not record herdr crew workspace $wsid for session $session" >&2
+      return 1
+    }
+    if [ -n "$last_ws" ]; then
+      fm_backend_herdr_projection_order_best_effort "$session" "$wsid" \
+        "$(fm_backend_herdr_crew_workspace_label)" "$last_ws"
+    else
+      fm_backend_herdr_projection_order_best_effort "$session" "$wsid" \
+        "$(fm_backend_herdr_workspace_label)" "$parent_ws"
+    fi
+  fi
+  # The pane label is what duplicate detection and list-live read, never
+  # endpoint authority, so an unlabeled pane is not a usable crew placement.
+  fm_backend_herdr_cli "$session" pane rename "$pane" "$label" >/dev/null 2>&1 || {
+    echo "error: could not label herdr crew pane $pane as '$label' (session $session)" >&2
+    return 1
+  }
+  while IFS= read -r husk; do
+    [ -n "$husk" ] || continue
+    fm_backend_herdr_explicit_close_pane_confirmed "$session" "$husk" || {
+      echo "error: failed to remove preexisting herdr crew pane $husk for label '$label' (session $session)" >&2
+      return 1
+    }
+  done <<FMEOF
+$husks
+FMEOF
+  [ "$created" = 1 ] || fm_backend_herdr_crew_equalize "$session" "$tab_id"
+  # shellcheck disable=SC2034  # callers consume the crew placement's parts
+  FM_BACKEND_HERDR_CREW_WORKSPACE_ID=$wsid
+  # shellcheck disable=SC2034  # callers consume the crew placement's parts
+  FM_BACKEND_HERDR_CREW_TAB_ID=$tab_id
+  return 0
+}
+
 # fm_backend_herdr_projection_parent_workspace_exact: resolve one exact parent
 # workspace only when its presentation label is unique in the named session.
 fm_backend_herdr_projection_parent_workspace_exact() {  # <session> <parent-label>
@@ -3483,7 +3749,7 @@ fm_backend_herdr_kill_serialized() {  # <session> <pane>
 fm_backend_herdr_kill() {  # <target>
   fm_backend_herdr_target_ready "$1" || return 0
   local session=$FM_BACKEND_HERDR_SESSION pane=$FM_BACKEND_HERDR_PANE
-  local lock_path attempt=0 lock_held=0
+  local lock_path attempt=0 lock_held=0 crew_tab
   if ! declare -F fm_lock_try_acquire >/dev/null 2>&1; then
     # shellcheck source=bin/fm-wake-lib.sh
     . "$FM_BACKEND_HERDR_ROOT/bin/fm-wake-lib.sh"
@@ -3499,7 +3765,20 @@ fm_backend_herdr_kill() {  # <target>
     done
   fi
   if [ "$lock_held" = 1 ]; then
+    # A crew pane's tab is rebalanced after the close so the remaining panes
+    # keep an even grid (docs/herdr-backend.md "Crew workspace"); a home that
+    # never placed a crew pane has no crew record and makes no extra calls.
+    crew_tab=
+    if [ -f "$(fm_backend_herdr_crew_record_path "${FM_STATE_OVERRIDE:-${FM_HOME:-}/state}" "$session")" ]; then
+      crew_tab=$(fm_backend_herdr_crew_tab_of "$session" "$pane") || crew_tab=
+    fi
     fm_backend_herdr_kill_serialized "$session" "$pane"
+    if [ -n "$crew_tab" ] \
+      && [ "$(fm_backend_herdr_pane_presence_state "$session" "$pane")" = dead ] \
+      && fm_backend_herdr_cli "$session" tab get "${crew_tab#* }" 2>/dev/null \
+        | jq -e --arg tab "${crew_tab#* }" '.result.tab.tab_id == $tab' >/dev/null 2>&1; then
+      fm_backend_herdr_crew_equalize "$session" "${crew_tab#* }"
+    fi
     fm_lock_release "$lock_path" || true
   else
     echo "warning: herdr task kill could not acquire its session presentation lock; refusing an unlocked pane close" >&2
@@ -3661,8 +3940,8 @@ fm_backend_herdr_pane_for_tab() {  # <session> <workspace_id> <tab_id>
 
 # fm_backend_herdr_resolve_bare_selector: the live-tab-listing fallback for an
 # ad hoc selector with no meta (mirrors tmux's list-windows grep). Searches
-# every RUNNING named herdr session (herdr session list) for a tab whose label
-# matches <name>, since herdr sessions are not addressed by one ambient
+# every RUNNING named herdr session (herdr session list) for a tab (or, for a
+# crew-layout task, a pane) whose label matches <name>, since herdr sessions are not addressed by one ambient
 # server the way a single tmux server is. Rare path in practice (herdr tasks
 # normally carry meta), best-effort.
 fm_backend_herdr_resolve_bare_selector() {  # <name>
@@ -3673,10 +3952,15 @@ fm_backend_herdr_resolve_bare_selector() {  # <name>
     tabs=$(fm_backend_herdr_cli "$session" tab list 2>/dev/null) || continue
     tab_id=$(printf '%s' "$tabs" | jq -r --arg want "$name" \
       '.result.tabs[]? | select(.label == $want) | .tab_id' 2>/dev/null | head -1)
-    [ -n "$tab_id" ] || continue
-    wsid=$(printf '%s' "$tabs" | jq -r --arg tab "$tab_id" '.result.tabs[]? | select(.tab_id == $tab) | .workspace_id' 2>/dev/null | head -1)
-    [ -n "$wsid" ] || continue
-    pane_id=$(fm_backend_herdr_pane_for_tab "$session" "$wsid" "$tab_id") || continue
+    if [ -n "$tab_id" ]; then
+      wsid=$(printf '%s' "$tabs" | jq -r --arg tab "$tab_id" '.result.tabs[]? | select(.tab_id == $tab) | .workspace_id' 2>/dev/null | head -1)
+      [ -n "$wsid" ] || continue
+      pane_id=$(fm_backend_herdr_pane_for_tab "$session" "$wsid" "$tab_id") || continue
+    else
+      # A crew-layout task is a labeled pane rather than a labeled tab.
+      pane_id=$(fm_backend_herdr_cli "$session" pane list 2>/dev/null | jq -r --arg want "$name" \
+        '.result.panes[]? | select(.label == $want) | .pane_id' 2>/dev/null | head -1)
+    fi
     [ -n "$pane_id" ] || continue
     printf '%s:%s' "$session" "$pane_id"
     return 0
@@ -3697,18 +3981,26 @@ EOF
 # workspace because FM_HOME already names it - no glue needed, unlike the
 # primary-spawns-a-secondmate path in fm-spawn.sh. Read-only: a session/
 # workspace that does not exist yet simply lists nothing. One
-# "<session>:<pane_id>\t<label>" line per live task tab.
+# "<session>:<pane_id>\t<label>" line per live task tab, followed by one per
+# fm-<id>-labeled pane in each workspace carrying this home's crew label.
 fm_backend_herdr_list_live() {  # <session>
   local session=$1 wsid tabs tab_id label pane_id
-  wsid=$(fm_backend_herdr_workspace_find "$session") || return 0
-  [ -n "$wsid" ] || return 0
-  tabs=$(fm_backend_herdr_cli "$session" tab list --workspace "$wsid" 2>/dev/null) || return 0
-  while IFS=$'\t' read -r tab_id label; do
-    [ -n "$tab_id" ] || continue
-    pane_id=$(fm_backend_herdr_pane_for_tab "$session" "$wsid" "$tab_id") || continue
-    [ -n "$pane_id" ] || continue
-    printf '%s:%s\t%s\n' "$session" "$pane_id" "$label"
-  done < <(printf '%s' "$tabs" | jq -r '.result.tabs[]? | select(.label | startswith("fm-")) | "\(.tab_id)\t\(.label)"' 2>/dev/null)
+  wsid=$(fm_backend_herdr_workspace_find "$session") || wsid=
+  if [ -n "$wsid" ] && tabs=$(fm_backend_herdr_cli "$session" tab list --workspace "$wsid" 2>/dev/null); then
+    while IFS=$'\t' read -r tab_id label; do
+      [ -n "$tab_id" ] || continue
+      pane_id=$(fm_backend_herdr_pane_for_tab "$session" "$wsid" "$tab_id") || continue
+      [ -n "$pane_id" ] || continue
+      printf '%s:%s\t%s\n' "$session" "$pane_id" "$label"
+    done < <(printf '%s' "$tabs" | jq -r '.result.tabs[]? | select(.label | startswith("fm-")) | "\(.tab_id)\t\(.label)"' 2>/dev/null)
+  fi
+  while IFS= read -r wsid; do
+    [ -n "$wsid" ] || continue
+    fm_backend_herdr_cli "$session" pane list --workspace "$wsid" 2>/dev/null | jq -r --arg session "$session" \
+      '.result.panes[]? | select((.label // "") | startswith("fm-")) | "\($session):\(.pane_id)\t\(.label)"' 2>/dev/null
+  done < <(fm_backend_herdr_cli "$session" workspace list 2>/dev/null | jq -r --arg want "$(fm_backend_herdr_crew_workspace_label)" \
+    '.result.workspaces[]? | select(.label == $want) | .workspace_id' 2>/dev/null)
+  return 0
 }
 
 # --- native event push: pane.agent_status_changed subscriber -----------------
diff --git a/bin/fm-spawn.sh b/bin/fm-spawn.sh
index 2147e0224e5..82c2d2b9685 100755
--- a/bin/fm-spawn.sh
+++ b/bin/fm-spawn.sh
@@ -114,6 +114,9 @@
 #   selected client and running server meet the Herdr 0.8.0 floor. The local
 #   config/herdr-presentation-spaces file can say off to disable it or on to
 #   opt in below that floor; an empty file remains the historical opt-in form.
+#   The value crew (or crew:<n>) instead places every crewmate or scout, and a
+#   reclaim of a gone endpoint, as a split pane in a recorded per-home crew
+#   workspace (docs/herdr-backend.md "Crew workspace").
 #   A clean fresh task first writes state/<id>.herdr-presentation atomically,
 #   then creates a disposable
 #   workspace containing only the ordinary task pane. A successful clean create
@@ -3185,6 +3188,44 @@ freshen_spawn_worktree_base() { # <worktree>
   fi
 }
 
+# Place this task as a pane in the home's Herdr crew workspace in <session>
+# (docs/herdr-backend.md "Crew workspace"), under the shared session lock that
+# the successful launch releases, and publish the exact endpoint ids. The
+# launcher's own workspace, when it resolves exactly, only orders a newly
+# created crew workspace; it never decides placement. Exits on failure after
+# arming abort cleanup of the exact new pane.
+herdr_spawn_crew_place() { # <session> <pane-cap> <cwd> [<launcher-pane-id>]
+  local session=$1 cap=$2 cwd=$3 launcher_pane=${4-${HERDR_PANE_ID:-}} parent_ws=""
+  fm_backend_herdr_version_check || exit 1
+  fm_backend_herdr_server_ensure "$session" || exit 1
+  spawn_herdr_presentation_order_lock_acquire "$session" || {
+    echo "error: herdr crew workspace placement could not acquire its session lock; refusing a concurrent placement" >&2
+    exit 1
+  }
+  if HERDR_PANE_ID="$launcher_pane" fm_backend_herdr_launcher_identity "$session" 2>/dev/null; then
+    parent_ws=$FM_BACKEND_HERDR_LAUNCHER_WORKSPACE_ID
+  fi
+  if ! FM_HOME="${HERDR_LABEL_HOME:-$FM_HOME}" fm_backend_herdr_crew_create_task \
+    "$session" "$STATE" "$cwd" "$W" "$cap" "$parent_ws"; then
+    if [ -n "$FM_BACKEND_HERDR_CREW_PANE_ID" ]; then
+      HERDR_PROJECTION_ABORT_CLEANUP=1
+      HERDR_PROJECTION_ABORT_SESSION=$session
+      HERDR_PROJECTION_ABORT_TASK_PANE=$FM_BACKEND_HERDR_CREW_PANE_ID
+      HERDR_PROJECTION_ABORT_SEEDED_PANE=""
+    fi
+    exit 1
+  fi
+  HERDR_SES=$session
+  HERDR_WORKSPACE_ID=$FM_BACKEND_HERDR_CREW_WORKSPACE_ID
+  HERDR_SEEDED_DEFAULT_TAB_ID=""
+  HERDR_TAB_ID=$FM_BACKEND_HERDR_CREW_TAB_ID
+  HERDR_PANE_ID=$FM_BACKEND_HERDR_CREW_PANE_ID
+  HERDR_PROJECTION_ABORT_CLEANUP=1
+  HERDR_PROJECTION_ABORT_SESSION=$session
+  HERDR_PROJECTION_ABORT_TASK_PANE=$HERDR_PANE_ID
+  HERDR_PROJECTION_ABORT_SEEDED_PANE=""
+}
+
 herdr_projection_meta_field_exact() { # <meta> <key>
   local meta=$1 key=$2 count
   [ -f "$meta" ] && [ ! -L "$meta" ] || return 1
@@ -3360,42 +3401,53 @@ if [ "$RELAUNCH" -eq 1 ]; then
     # onto another herdr server - an identity change, published as a
     # self-consistent but wrong record.
     HERDR_REBIND_SES=${RELAUNCH_TARGET%%:*}
-    HERDR_CONTAINER_RAW=$(HERDR_PANE_ID="$RELAUNCH_LAUNCHER_PANE_ID" \
-      fm_backend_herdr_container_ensure "$PROJ_ABS" launcher-home "$HERDR_REBIND_SES") || {
-      # container_ensure returns 1 for several unrelated reasons - a failed
-      # version check, a server that will not start, an ambiguous workspace
-      # label, a cross-session launcher identity, a failed workspace create -
-      # and each already printed its own accurate message. Add only what this
-      # layer actually knows, and name the session mismatch solely when there
-      # IS one, rather than asserting a cause this condition cannot establish.
-      #
-      # A seat with NO herdr pane never reaches the cross-session guard at all:
-      # fm_backend_herdr_launcher_identity returns 2 for it and the placement
-      # falls back to the recorded session's labeled container, which is what
-      # makes a plain ssh or cron reclaim work. Its ambient session still reads
-      # `default` (fm_backend_herdr_session's fallback), so the inequality alone
-      # would fire for EVERY named-session task reclaimed from a plain shell and
-      # send the operator chasing a session mismatch that was never the cause.
-      HERDR_AMBIENT_SES=$(fm_backend_herdr_session)
-      if [ -n "$RELAUNCH_LAUNCHER_PANE_ID" ] && [ "$HERDR_AMBIENT_SES" != "$HERDR_REBIND_SES" ]; then
-        echo "error: task $ID's endpoint could not be re-created in its recorded herdr session '$HERDR_REBIND_SES'; this seat is running in herdr session '$HERDR_AMBIENT_SES', and a reclaim never moves a task to another session" >&2
-      else
-        echo "error: task $ID's endpoint could not be re-created in its recorded herdr session '$HERDR_REBIND_SES'; see the refusal above for what failed" >&2
-      fi
-      exit 1
-    }
-    CONTAINER=${HERDR_CONTAINER_RAW%%$'\t'*}
-    HERDR_SEEDED_DEFAULT_TAB_ID=${HERDR_CONTAINER_RAW#*$'\t'}
-    HERDR_SES=${CONTAINER%%:*}
-    HERDR_WORKSPACE_ID=${CONTAINER#*:}
-    HERDR_TASK_IDS=$(fm_backend_herdr_create_task "$CONTAINER" "$W" "$WT" "$HERDR_SEEDED_DEFAULT_TAB_ID") || exit 1
-    read -r HERDR_TAB_ID HERDR_PANE_ID <<EOF
+    # A home on the crew layout reclaims into its crew workspace instead, in
+    # the same recorded session.
+    HERDR_REBIND_PREFERENCE=$(fm_backend_herdr_presentation_preference "$CONFIG")
+    case "$HERDR_REBIND_PREFERENCE" in
+    crew:*)
+      herdr_spawn_crew_place "$HERDR_REBIND_SES" "${HERDR_REBIND_PREFERENCE#crew:}" "$WT" "$RELAUNCH_LAUNCHER_PANE_ID"
+      HERDR_PROJECTED=1
+      ;;
+    *)
+      HERDR_CONTAINER_RAW=$(HERDR_PANE_ID="$RELAUNCH_LAUNCHER_PANE_ID" \
+        fm_backend_herdr_container_ensure "$PROJ_ABS" launcher-home "$HERDR_REBIND_SES") || {
+        # container_ensure returns 1 for several unrelated reasons - a failed
+        # version check, a server that will not start, an ambiguous workspace
+        # label, a cross-session launcher identity, a failed workspace create -
+        # and each already printed its own accurate message. Add only what this
+        # layer actually knows, and name the session mismatch solely when there
+        # IS one, rather than asserting a cause this condition cannot establish.
+        #
+        # A seat with NO herdr pane never reaches the cross-session guard at all:
+        # fm_backend_herdr_launcher_identity returns 2 for it and the placement
+        # falls back to the recorded session's labeled container, which is what
+        # makes a plain ssh or cron reclaim work. Its ambient session still reads
+        # `default` (fm_backend_herdr_session's fallback), so the inequality alone
+        # would fire for EVERY named-session task reclaimed from a plain shell and
+        # send the operator chasing a session mismatch that was never the cause.
+        HERDR_AMBIENT_SES=$(fm_backend_herdr_session)
+        if [ -n "$RELAUNCH_LAUNCHER_PANE_ID" ] && [ "$HERDR_AMBIENT_SES" != "$HERDR_REBIND_SES" ]; then
+          echo "error: task $ID's endpoint could not be re-created in its recorded herdr session '$HERDR_REBIND_SES'; this seat is running in herdr session '$HERDR_AMBIENT_SES', and a reclaim never moves a task to another session" >&2
+        else
+          echo "error: task $ID's endpoint could not be re-created in its recorded herdr session '$HERDR_REBIND_SES'; see the refusal above for what failed" >&2
+        fi
+        exit 1
+      }
+      CONTAINER=${HERDR_CONTAINER_RAW%%$'\t'*}
+      HERDR_SEEDED_DEFAULT_TAB_ID=${HERDR_CONTAINER_RAW#*$'\t'}
+      HERDR_SES=${CONTAINER%%:*}
+      HERDR_WORKSPACE_ID=${CONTAINER#*:}
+      HERDR_TASK_IDS=$(fm_backend_herdr_create_task "$CONTAINER" "$W" "$WT" "$HERDR_SEEDED_DEFAULT_TAB_ID") || exit 1
+      read -r HERDR_TAB_ID HERDR_PANE_ID <<EOF
 $HERDR_TASK_IDS
 EOF
-    if [ -z "$HERDR_TAB_ID" ] || [ -z "$HERDR_PANE_ID" ]; then
-      echo "error: herdr did not return a tab/pane id for $W" >&2
-      exit 1
-    fi
+      if [ -z "$HERDR_TAB_ID" ] || [ -z "$HERDR_PANE_ID" ]; then
+        echo "error: herdr did not return a tab/pane id for $W" >&2
+        exit 1
+      fi
+      ;;
+    esac
     T="$HERDR_SES:$HERDR_PANE_ID"
     SES=$HERDR_SES
     WT_TARGET=$T
@@ -3561,6 +3613,18 @@ else
         fi
       fi
     fi
+    if [ "$HERDR_PROJECTED" -ne 1 ] && [ "$KIND" != secondmate ]; then
+      case "${FM_BACKEND_HERDR_PRESENTATION_PREFERENCE:-}" in
+      crew:*)
+        # The crew layout: a split pane in this home's one crew workspace
+        # (docs/herdr-backend.md "Crew workspace"). It shares the projection's
+        # session lock, abort cleanup of the exact new pane, and lock release
+        # after launch, so HERDR_PROJECTED also covers it below.
+        herdr_spawn_crew_place "$(fm_backend_herdr_session)" "${FM_BACKEND_HERDR_PRESENTATION_PREFERENCE#crew:}" "$PROJ_ABS"
+        HERDR_PROJECTED=1
+        ;;
+      esac
+    fi
     if [ "$HERDR_PROJECTED" -ne 1 ]; then
       HERDR_CONTAINER_RAW=$(FM_HOME="$HERDR_LABEL_HOME" fm_backend_herdr_container_ensure "$PROJ_ABS" "$HERDR_LAUNCHER_RELATIONSHIP") || exit 1
       # fm_backend_herdr_container_ensure echoes "<session>:<workspace_id>\t<seeded_default_tab_id>"
diff --git a/bin/fm-test-run.sh b/bin/fm-test-run.sh
index 30cd64f56eb..49ae8cd0e04 100755
--- a/bin/fm-test-run.sh
+++ b/bin/fm-test-run.sh
@@ -313,7 +313,7 @@ family_for_basename() {
     fm-backend-herdr-eventwait-smoke.test.sh|fm-backend-herdr-presentation-e2e.test.sh|\
     fm-backend-herdr-launcher-workspace-e2e.test.sh|\
     fm-backend-herdr-prune-safety-e2e.test.sh|fm-backend-herdr-respawn-idem-e2e.test.sh|\
-    fm-backend-herdr-focus-flash-e2e.test.sh|\
+    fm-backend-herdr-focus-flash-e2e.test.sh|fm-backend-herdr-crew-workspace-e2e.test.sh|\
     fm-backend-herdr-stale-active-tab-e2e.test.sh|\
     fm-backend-herdr-agent-exit-shell-e2e.test.sh|\
     fm-herdr-attached-viewer-live-e2e.test.sh|fm-herdr-session-cleanup-e2e.test.sh|\
@@ -368,7 +368,7 @@ family_for_basename() {
     fm-herdr-submit-confirm-live-e2e.test.sh)
       printf '%s\n' live-harness-optin
       ;;
-    fm-backend-herdr.test.sh|fm-backend-tmux-smoke.test.sh|fm-backend.test.sh|\
+    fm-backend-herdr.test.sh|fm-backend-herdr-crew.test.sh|fm-backend-tmux-smoke.test.sh|fm-backend.test.sh|\
     fm-tmux-agent-liveness.test.sh|\
     fm-control.test.sh|fm-control-relaunch.test.sh|\
     fm-herdr-session-cleanup.test.sh|fm-send-resolve-key.test.sh|fm-send-strict.test.sh|\
diff --git a/docs/architecture.md b/docs/architecture.md
index af9b3a6e67c..3a9a3c80e1c 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -256,8 +256,8 @@ That poll loop is still the default event source for backends with no native pus
 For capable Herdr sessions, the same watcher replaces its terminal sleep with a bounded native event wait that immediately surfaces `blocked`; [Push events and polling fallback](herdr-backend.md#push-events-and-polling-fallback) owns the current mechanism and capability gates, while [runtime backend verification](verification/runtime-backends.md#native-blocked-event) owns the active evidence.
 The deeper session-start agent-process liveness probe is separate from that busy-state poll: tmux and Herdr have verified classifiers for secondmate recovery, Zellij remains unverified, and Orca and cmux do not support secondmate spawns.
 Herdr can be selected explicitly or by runtime auto-detection: Treehouse remains its worktree provider, [`herdr-backend.md`](herdr-backend.md) owns current setup, CI coverage, and safety limits, and [`verification/runtime-backends.md`](verification/runtime-backends.md#herdr) owns active empirical evidence.
-Herdr uses one tab per task; [Watching and task containers](herdr-backend.md#watching-and-task-containers) owns launcher-bound workspace placement, the label-only fallback, and recovery scope.
-Its default-on presentation projection may place one clean new task in a disposable workspace without changing endpoint authority or lifecycle ownership; [Presentation spaces](herdr-backend.md#presentation-spaces) owns that conditional design, the Herdr version floor its unconfigured default is gated behind, and its narrow home-local restored-shell cleanup at locked session start.
+Herdr ordinarily uses one tab per task; [Watching and task containers](herdr-backend.md#watching-and-task-containers) owns launcher-bound workspace placement, the label-only fallback, and recovery scope.
+Its optional visual layouts may place a clean new task in a disposable workspace or a crew pane without changing endpoint authority or lifecycle ownership; [Presentation spaces](herdr-backend.md#presentation-spaces) and [Crew workspace](herdr-backend.md#crew-workspace) own their conditional designs, limits, and cleanup behavior.
 Zellij is experimental and selected only explicitly: Treehouse remains its worktree provider, [`zellij-backend.md`](zellij-backend.md) owns current setup and limits, and [`verification/runtime-backends.md`](verification/runtime-backends.md#zellij) owns active empirical evidence.
 Zellij's container shape is simpler than herdr's: one shared `firstmate` session, one tab per task, with no per-home workspace split; visible tab titles are scoped by the active home label plus a short hash of the resolved `FM_ROOT` path.
 Orca is experimental and selected only explicitly: Orca owns both worktree and terminal lifecycle, records `orca_worktree_id=` and `terminal=`, and removes worktrees through `orca worktree rm` only after the usual firstmate teardown checks pass.
diff --git a/docs/configuration.md b/docs/configuration.md
index b814d7c6d14..a5dfb662991 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -182,7 +182,7 @@ Missing, empty, duplicate, malformed, backend-inconsistent, or task-mismatched e
 Legacy tmux metadata remains cleanup-compatible when its exact window name is `fm-<id>`; opaque non-tmux endpoints require their recorded `endpoint_task_id=` binding.
 `FM_HOME` determines Herdr's home label: the primary home uses `firstmate`, and a secondmate home marked by `.fm-secondmate-home` uses `2ndmate-<secondmate-id>`.
 [`herdr-backend.md`](herdr-backend.md#watching-and-task-containers) owns launcher-bound workspace placement, the label-only fallback, collision handling, and recovery behavior.
-The local `config/herdr-presentation-spaces` file instead opts a home out of, or explicitly in to, Herdr's default-on disposable single-task visual projection; [Presentation spaces](herdr-backend.md#presentation-spaces) owns its accepted values, default, Herdr version floor, migration, behavior, safety limits, recovery contract, and narrow locked session-start cleanup of exact restored idle-shell children.
+The local `config/herdr-presentation-spaces` file instead opts a home out of, or explicitly in to, Herdr's default-on disposable single-task visual projection, or with `crew` selects shared per-home crew workspaces of task panes owned by [Crew workspace](herdr-backend.md#crew-workspace); [Presentation spaces](herdr-backend.md#presentation-spaces) owns its accepted values, default, Herdr version floor, migration, behavior, safety limits, recovery contract, and narrow locked session-start cleanup of exact restored idle-shell children.
 The setting is inherited into secondmate homes under the primary-authoritative contract owned by [`secondmate-provisioning`](../.agents/skills/secondmate-provisioning/SKILL.md).
 For normal herdr operations, `HERDR_SESSION` selects the named session, but destructive test cleanup must not rely on `HERDR_SESSION` alone.
 Use the explicit guarded cleanup path described in [`docs/herdr-backend.md`](herdr-backend.md) instead of `herdr server stop`.
diff --git a/docs/herdr-backend.md b/docs/herdr-backend.md
index 64b0fa77a1c..aeb509be3b8 100644
--- a/docs/herdr-backend.md
+++ b/docs/herdr-backend.md
@@ -82,6 +82,7 @@ Closing its last tab can remove the workspace, and the next spawn recreates it.
 
 Each new crewmate or scout is placed in a disposable one-task workspace by default, on Herdr 0.8.0 and newer.
 A home opts out by writing `off` into local gitignored `config/herdr-presentation-spaces`, and forces the projection on by writing `on`.
+The value `crew` selects shared per-home crew workspaces of task panes, owned by [Crew workspace](#crew-workspace), instead of one workspace per task.
 An absent file leaves the choice to the version floor below, an empty file and the value `on` are both a deliberate opt-in, values are compared with whitespace stripped and case ignored, and an unrecognized value warns and follows the unconfigured default rather than failing a spawn over a purely visual setting.
 The empty file is the historical presence-based opt-in form, so every home that had already enabled the projection stays enabled with no migration step, and no previously enabled home can be turned off by the default or by the floor.
 A home that never created the file gains the projection at its next Herdr spawn on a supported release; that flip is deliberate, and it reaches only the Herdr backend because no other runtime backend has a projection path.
@@ -188,6 +189,34 @@ Operational compromises:
 `tests/fm-backend-herdr-stale-active-tab-e2e.test.sh` proves a persisted-focused tab still closes when no foreground client is attached.
 `tests/fm-herdr-attached-viewer-live-e2e.test.sh` proves the other half against a real attached viewer, which `bin/fm-herdr-lab.sh viewer start` supplies over a pty sized before the fork; [`verification/runtime-backends.md`](verification/runtime-backends.md#attached-foreground-viewer) owns the active versioned evidence and the re-run trigger.
 
+## Crew workspace
+
+A home that writes `crew` into `config/herdr-presentation-spaces` keeps its own workspace for the Firstmate agent alone and places every new crewmate or scout, and every reclaim of a gone endpoint, as a split pane in a durable per-home crew workspace labeled `<home-label>-crew`.
+`crew:<n>` sets the per-workspace pane cap to any value from 1 to 16; plain `crew` means `crew:6`.
+The crew value is not gated by the presentation version floor because an ordinary task cleanup closes one pane, not a workspace.
+Secondmate agents keep their ordinary placement, and a secondmate home that inherits the value gets its own crew workspace under its own home label.
+
+The first crew workspace is created on first use with focus preserved and ordered immediately after the home's workspace on a best-effort basis.
+A placement takes the first crew workspace holding fewer panes than the cap, so a freed slot is refilled before anything new opens.
+When every crew workspace is full, the task becomes the first pane of another crew workspace, a fresh grid ordered right after the last one; a crew workspace never gains a second tab.
+Crew workspace ids are recorded in `state/.herdr-crew-workspace-<session>`, and a recorded id is reused only while that workspace still exists with the expected crew label, so a relabeled or recycled workspace is never adopted and a label alone never selects placement.
+
+With the default cap the panes form an even grid of 3 columns by 2 rows, filled top row left to right and then bottom row left to right; a cap of 3 or less is a single row, and a larger cap uses half the cap, rounded up, as the column count.
+Each new pane splits the rightmost full-height pane to the right until the row has its columns, then splits the leftmost full-height pane down.
+After every split and every crew pane cleanup, Firstmate evens out that workspace's split ratios with Herdr's `layout.set_split_ratio`, which resizes panes without restarting them, and never sends `layout.apply`, which recreates every pane.
+A later placement into a freed slot fills the gap the closed pane left.
+When a whole column closes while the other columns still hold two rows, the remaining columns are evened out and each later pane splits the largest pane along its longer side, so that workspace stays even but may not return to the exact 3 by 2 shape until its panes turn over.
+Rebalancing needs Python 3 and a Herdr that advertises both layout methods; without them placement and cleanup still work, the split halves the chosen pane, and a warning names the skipped rebalance.
+
+Placement runs under the same per-session presentation lock as the projection, and lock contention refuses the spawn rather than guessing.
+A live pane that already carries the task label refuses a duplicate launch, while an exited husk with that label is closed only after the replacement pane exists.
+A failure after the new pane exists closes that exact pane, and a crew placement writes no presentation journal.
+Cleanup closes only the task's exact pane through the ordinary exact-identity kill path and its focus-safe removal plan, so each crew workspace disappears with its last pane and a new one is created when a placement finds no room.
+List-live reports the home's crew panes alongside its home-workspace tabs, and a bare selector that matches no tab label falls back to an exact pane label, so recovery, send, capture, and turn-end detection use the recorded pane endpoint exactly as they do for a tab.
+
+`tests/fm-backend-herdr-crew.test.sh` pins parsing, first creation, grid fill, overflow, custom caps, cleanup rebalance, refill, recreation, record verification, duplicate refusal, list-live, and the no-layout-API fallback against a stateful fake.
+`tests/fm-backend-herdr-crew-workspace-e2e.test.sh` proves the same behavior and a real spawn and cleanup pass in a guarded named lab; [`verification/runtime-backends.md`](verification/runtime-backends.md#crew-workspace) owns the active versioned evidence.
+
 ## Default-tab prune safety
 
 `herdr workspace create` seeds one default tab.
@@ -356,6 +385,7 @@ Tests use thin compatibility wrappers in `tests/herdr-test-safety.sh` and never
 ## Active limits
 
 - Presentation ordering needs protocol 16 and Python and is best-effort only.
+- Crew grid rebalancing needs Python 3 and Herdr's layout methods, and a whole-column close leaves that crew workspace even but not always in its exact grid shape.
 - Mutable labels can collide; they are never placement or destructive authority.
 - A Firstmate outside Herdr cannot resolve a launcher workspace, so a colliding home label refuses new spawns until the collision is cleared.
 - Ghost and placeholder recognition uses ANSI de-emphasis when available; an unstyled glyph row carrying trailing non-idle text fails safely to `unknown`.
@@ -374,6 +404,8 @@ tests/fm-backend-herdr-respawn-idem-e2e.test.sh
 tests/fm-backend-herdr-workspace-per-home-e2e.test.sh
 tests/fm-backend-herdr-launcher-workspace-e2e.test.sh
 tests/fm-backend-herdr-presentation-e2e.test.sh
+tests/fm-backend-herdr-crew.test.sh
+tests/fm-backend-herdr-crew-workspace-e2e.test.sh
 tests/fm-backend-herdr-agent-exit-shell-e2e.test.sh
 tests/fm-herdr-pi-stale-registration-live-e2e.test.sh
 tests/fm-backend-herdr-eventwait-smoke.test.sh
diff --git a/docs/verification/runtime-backends.md b/docs/verification/runtime-backends.md
index de1158749d9..e96a8b4ab3c 100644
--- a/docs/verification/runtime-backends.md
+++ b/docs/verification/runtime-backends.md
@@ -1306,6 +1306,35 @@ HERDR_LAB_HELPER=bin/fm-herdr-lab.sh \
 
 Observed guarantee: one exact home-local, journal-correlated, one-tab and one-pane childless idle shell was closed after restoration while the exact non-target focus and default fleet session remained unchanged, and a repeat run was a no-op.
 
+### Crew workspace
+
+The crew-workspace suite ran on 2026-09-24 on Linux x86_64 against Herdr 0.9.1 protocol 22 and again against Herdr 0.7.4 protocol 16, with the 0.7.4 run using the pinned upstream release binary first on `PATH`:
+
+```sh
+HERDR_LAB_HELPER=bin/fm-herdr-lab.sh \
+  tests/fm-backend-herdr-crew-workspace-e2e.test.sh
+```
+
+Observed output on Herdr 0.9.1, identical apart from the version line on 0.7.4:
+
+```text
+# lab herdr server 0.9.1 protocol 22, client 0.9.1 protocol 22
+ok - real herdr: the first crew task creates one labeled crew workspace right after the home, without moving focus
+ok - real herdr: six crew panes fill an even 3x2 grid, top row left to right, then bottom row
+ok - real herdr: a seventh crew task opens a second crew workspace right after the first, without moving focus
+ok - real herdr: list-live discovers crew panes by their task labels
+ok - real herdr: killing one crew pane closes only that pane and keeps focus
+ok - real herdr: the next crew task refills the freed slot and restores the even grid
+ok - real herdr: a same-labeled agent-free crew pane is replaced only after its successor exists
+ok - real herdr: closing a whole crew column rebalances the remaining columns evenly
+ok - real herdr: each crew workspace disappears with its last pane and the next spawn recreates one
+ok - real herdr: real spawns on the crew setting become panes of one crew workspace
+ok - real herdr: real teardown closes one exact crew pane and the workspace goes with the last one
+```
+
+Observed guarantees: rebalancing used only `layout.export` and `layout.set_split_ratio`, every task pane kept its id through each rebalance, the lab helper's default-session tripwire held, and a real spawn and cleanup pass on the `crew` setting placed and removed exact panes with no presentation journal.
+The second crew workspace was moved from the end of the session to the slot right after the first, ahead of an unrelated sibling workspace, which the ordering assertion distinguishes from Herdr's append order.
+
 ### Workspace-removal focus safety
 
 The focus-flash regression ran on 2026-08-05 against both Herdr 0.7.5 protocol 17 and Herdr 0.8.0 protocol 19 on macOS aarch64, with the 0.7.5 run using the pinned upstream release binary first on `PATH`:
diff --git a/tests/fm-backend-herdr-crew-workspace-e2e.test.sh b/tests/fm-backend-herdr-crew-workspace-e2e.test.sh
new file mode 100755
index 00000000000..be8f13de6d6
--- /dev/null
+++ b/tests/fm-backend-herdr-crew-workspace-e2e.test.sh
@@ -0,0 +1,282 @@
+#!/usr/bin/env bash
+# Real-Herdr regression for the crew workspace layout (docs/herdr-backend.md
+# "Crew workspace"): every task of a home becomes a split pane in a recorded
+# crew workspace, filling an even 3-column by 2-row grid top row first, then
+# a second crew workspace right after the first, while cleanup closes one
+# exact pane, rebalances the rest, and a workspace disappears with its last
+# pane.
+# Every Herdr call goes through the guarded named-session lab helper.
+set -u
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+HERDR_LAB_HELPER=${HERDR_LAB_HELPER:-$ROOT/bin/fm-herdr-lab.sh}
+
+fail() { printf 'not ok - %s\n' "$1" >&2; exit 1; }
+pass() { printf 'ok - %s\n' "$1"; }
+
+command -v herdr >/dev/null 2>&1 || { echo 'skip: herdr not found'; exit 0; }
+command -v jq >/dev/null 2>&1 || { echo 'skip: jq not found'; exit 0; }
+command -v python3 >/dev/null 2>&1 || { echo 'skip: python3 not found'; exit 0; }
+[ -x "$HERDR_LAB_HELPER" ] || { echo "skip: Herdr lab helper not executable at $HERDR_LAB_HELPER"; exit 0; }
+
+HERDR_ORIGINAL_PATH=$PATH
+TMP_ROOT=$(mktemp -d "$(cd "${TMPDIR:-/tmp}" && pwd -P)/fm-herdr-crew-e2e.XXXXXX")
+FAKEBIN="$TMP_ROOT/fakebin"
+HOME_DIR="$TMP_ROOT/home"
+mkdir -p "$FAKEBIN" "$HOME_DIR/state"
+
+HERDR_LAB_SESSION=$("$HERDR_LAB_HELPER" name fm-crew-workspace)
+export HERDR_LAB_HELPER HERDR_LAB_SESSION HERDR_ORIGINAL_PATH
+RECORDED_WORKTREES=""
+cleanup() {
+  local status=$? wt
+  while IFS= read -r wt; do
+    [ -n "$wt" ] && [ -d "$wt" ] || continue
+    env PATH="$HERDR_ORIGINAL_PATH" treehouse return --force "$wt" >/dev/null 2>&1 || true
+  done <<EOF
+$RECORDED_WORKTREES
+EOF
+  env PATH="$HERDR_ORIGINAL_PATH" "$HERDR_LAB_HELPER" teardown "$HERDR_LAB_SESSION" || status=1
+  rm -rf "$TMP_ROOT"
+  exit "$status"
+}
+trap cleanup EXIT
+"$HERDR_LAB_HELPER" provision "$HERDR_LAB_SESSION" || fail 'could not provision the lab session'
+
+# Route every adapter call through the lab helper, which alone appends the
+# trailing lab session flag. The adapter's session-independent version read
+# cannot pass the helper's leading-option guard, so only it goes straight to
+# the real binary with the same explicit trailing lab session.
+REAL_HERDR=$(command -v herdr)
+export REAL_HERDR
+cat > "$FAKEBIN/herdr" <<'SH'
+#!/usr/bin/env bash
+set -u
+args=("$@")
+last=$((${#args[@]} - 1))
+flag=$((last - 1))
+if [ "${#args[@]}" -ge 2 ] \
+  && [ "${args[$flag]}" = --session ] \
+  && [ "${args[$last]}" = "$HERDR_LAB_SESSION" ]; then
+  unset "args[$last]" "args[$flag]"
+fi
+set -- "${args[@]}"
+for arg in "$@"; do
+  case "$arg" in --session|--session=*) exit 9 ;; esac
+done
+if [ "${1:-}" = --version ]; then
+  exec env PATH="$HERDR_ORIGINAL_PATH" "$REAL_HERDR" "$@" --session "$HERDR_LAB_SESSION"
+fi
+exec env PATH="$HERDR_ORIGINAL_PATH" "$HERDR_LAB_HELPER" run "$HERDR_LAB_SESSION" "$@"
+SH
+chmod +x "$FAKEBIN/herdr"
+
+lab() { env PATH="$HERDR_ORIGINAL_PATH" "$HERDR_LAB_HELPER" run "$HERDR_LAB_SESSION" "$@"; }
+printf '# lab herdr %s\n' "$(lab status --json | jq -r '"server \(.server.version) protocol \(.server.protocol), client \(.client.version) protocol \(.client.protocol)"')"
+
+# adapter <function> [args...]: run one adapter function as this test home.
+adapter() {
+  # shellcheck disable=SC2016 # the inner bash expands its own positional arguments
+  env -u HERDR_ENV -u HERDR_PANE_ID -u HERDR_TAB_ID -u HERDR_WORKSPACE_ID -u HERDR_SOCKET_PATH \
+    PATH="$FAKEBIN:$HERDR_ORIGINAL_PATH" FM_HOME="$HOME_DIR" HERDR_SESSION="$HERDR_LAB_SESSION" \
+    bash -c '. "$1/bin/backends/herdr.sh"; shift; "$@"' _ "$ROOT" "$@"
+}
+
+# place <label>: place one crew task with the default cap; prints "<ws> <tab> <pane>".
+place() {
+  # shellcheck disable=SC2016 # the inner bash expands its own positional arguments
+  env -u HERDR_ENV -u HERDR_PANE_ID -u HERDR_TAB_ID -u HERDR_WORKSPACE_ID -u HERDR_SOCKET_PATH \
+    PATH="$FAKEBIN:$HERDR_ORIGINAL_PATH" FM_HOME="$HOME_DIR" HERDR_SESSION="$HERDR_LAB_SESSION" \
+    bash -c '
+      . "$1/bin/backends/herdr.sh"
+      fm_backend_herdr_crew_create_task "$2" "$3/state" "$3" "$4" "$FM_BACKEND_HERDR_CREW_PANE_CAP_DEFAULT" "" || exit 1
+      printf "%s %s %s\n" "$FM_BACKEND_HERDR_CREW_WORKSPACE_ID" "$FM_BACKEND_HERDR_CREW_TAB_ID" "$FM_BACKEND_HERDR_CREW_PANE_ID"
+    ' _ "$ROOT" "$HERDR_LAB_SESSION" "$HOME_DIR" "$1"
+}
+
+focused() { lab workspace list | jq -r '.result.workspaces[] | select(.focused == true) | .workspace_id'; }
+
+# rects <tab>: "<pane> <x> <y> <w> <h>" per pane of that tab.
+rects() {
+  local pane
+  pane=$(lab pane list | jq -r --arg tab "$1" '[.result.panes[] | select(.tab_id == $tab)][0].pane_id')
+  lab pane layout --pane "$pane" | jq -r '.result.layout.panes[] | "\(.pane_id) \(.rect.x) \(.rect.y) \(.rect.width) \(.rect.height)"'
+}
+
+# even <tab> <columns> <rows>: every pane is one cell of an even grid.
+even() {
+  local tab=$1 columns=$2 rows=$3 area
+  area=$(lab pane layout --pane "$(lab pane list | jq -r --arg tab "$tab" '[.result.panes[] | select(.tab_id == $tab)][0].pane_id')" \
+    | jq -c '.result.layout.area')
+  rects "$tab" | awk -v c="$columns" -v r="$rows" -v area="$area" '
+    BEGIN { split(area, a, /[^0-9]+/); }
+    { w[NR] = $4; h[NR] = $5; n = NR }
+    END {
+      if (n != c * r) exit 1
+      minw = w[1]; maxw = w[1]; minh = h[1]; maxh = h[1]
+      for (i = 2; i <= n; i++) {
+        if (w[i] < minw) minw = w[i]; if (w[i] > maxw) maxw = w[i]
+        if (h[i] < minh) minh = h[i]; if (h[i] > maxh) maxh = h[i]
+      }
+      exit !(maxw - minw <= 2 && maxh - minh <= 2)
+    }'
+}
+
+# same_widths <tab>: every pane in the tab is within two cells of the same width.
+same_widths() {
+  rects "$1" | awk 'NR == 1 { lo = $4; hi = $4 } { if ($4 < lo) lo = $4; if ($4 > hi) hi = $4 } END { exit !(NR > 0 && hi - lo <= 2) }'
+}
+
+cell_of() {  # <tab> <pane> -> "<x> <y>"
+  rects "$1" | awk -v p="$2" '$1 == p { print $2, $3 }'
+}
+
+HOME_WS=$(lab workspace create --cwd "$ROOT" --label firstmate --no-focus | jq -er '.result.workspace.workspace_id') \
+  || fail 'could not create the home workspace'
+lab workspace create --cwd "$ROOT" --label other --no-focus >/dev/null || fail 'could not create a sibling workspace'
+FOCUS_BEFORE=$(focused)
+[ "$FOCUS_BEFORE" = "$HOME_WS" ] || fail "the lab's first workspace should be focused, got '$FOCUS_BEFORE'"
+
+declare -a PANES
+for i in 1 2 3 4 5 6; do
+  read -r WS TAB "PANES[$i]" < <(place "fm-t$i") || fail "could not place crew task t$i"
+  [ -n "${PANES[$i]}" ] || fail "crew task t$i returned no pane"
+  if [ "$i" = 1 ]; then CREW_WS=$WS; CREW_TAB=$TAB; fi
+  [ "$WS" = "$CREW_WS" ] || fail "crew task t$i landed in workspace $WS, not the crew workspace $CREW_WS"
+  [ "$TAB" = "$CREW_TAB" ] || fail "crew task t$i opened tab $TAB before the first tab reached six panes"
+  if [ "$i" = 3 ]; then
+    even "$CREW_TAB" 3 1 || fail "three crew panes are not three even columns: $(rects "$CREW_TAB" | tr '\n' ';')"
+  fi
+done
+[ "$(focused)" = "$FOCUS_BEFORE" ] || fail 'placing crew panes moved the focused workspace'
+ORDER=$(lab workspace list | jq -r '[.result.workspaces[].label] | join(",")')
+[ "$ORDER" = "firstmate,firstmate-crew,other" ] || fail "the crew workspace should sit right after the home workspace, got $ORDER"
+pass 'real herdr: the first crew task creates one labeled crew workspace right after the home, without moving focus'
+
+even "$CREW_TAB" 3 2 || fail "six crew panes are not an even 3x2 grid: $(rects "$CREW_TAB" | tr '\n' ';')"
+EXPECT=""
+for i in 1 2 3 4 5 6; do EXPECT="$EXPECT$(cell_of "$CREW_TAB" "${PANES[$i]}");"; done
+XS=$(rects "$CREW_TAB" | awk '{print $2}' | sort -n | uniq | tr '\n' ' ')
+YS=$(rects "$CREW_TAB" | awk '{print $3}' | sort -n | uniq | tr '\n' ' ')
+read -r X0 X1 X2 <<<"$XS"
+read -r Y0 Y1 <<<"$YS"
+[ "$EXPECT" = "$X0 $Y0;$X1 $Y0;$X2 $Y0;$X0 $Y1;$X1 $Y1;$X2 $Y1;" ] \
+  || fail "crew panes did not fill the top row left to right, then the bottom row: $EXPECT"
+pass 'real herdr: six crew panes fill an even 3x2 grid, top row left to right, then bottom row'
+
+read -r CREW_WS2 _ "PANES[7]" < <(place fm-t7) || fail 'could not place the seventh crew task'
+[ -n "$CREW_WS2" ] && [ "$CREW_WS2" != "$CREW_WS" ] || fail "the seventh crew task should open a second crew workspace, got $CREW_WS2"
+[ "$(lab tab list --workspace "$CREW_WS" | jq '.result.tabs | length')" = 1 ] || fail 'the full crew workspace should never gain a second tab'
+[ "$(lab pane list --workspace "$CREW_WS2" | jq '.result.panes | length')" = 1 ] || fail 'the second crew workspace should hold exactly the seventh pane'
+ORDER=$(lab workspace list | jq -r --arg c1 "$CREW_WS" --arg c2 "$CREW_WS2" \
+  '[.result.workspaces[] | .workspace_id as $id | if $id == $c1 then "crew1" elif $id == $c2 then "crew2" else .label end] | join(",")')
+[ "$ORDER" = "firstmate,crew1,crew2,other" ] || fail "the second crew workspace should sit right after the first, got $ORDER"
+[ "$(focused)" = "$FOCUS_BEFORE" ] || fail 'opening the second crew workspace moved the focused workspace'
+pass 'real herdr: a seventh crew task opens a second crew workspace right after the first, without moving focus'
+
+LIVE=$(adapter fm_backend_herdr_list_live "$HERDR_LAB_SESSION")
+[ "$(printf '%s\n' "$LIVE" | grep -c $'\tfm-t')" = 7 ] || fail "list-live should report all seven crew panes, got: $LIVE"
+pass 'real herdr: list-live discovers crew panes by their task labels'
+
+adapter fm_backend_herdr_kill "$HERDR_LAB_SESSION:${PANES[5]}" || fail 'kill of one crew pane failed'
+[ "$(adapter fm_backend_herdr_pane_presence_state "$HERDR_LAB_SESSION" "${PANES[5]}")" = dead ] || fail 'the killed crew pane is still present'
+for i in 1 2 3 4 6 7; do
+  [ "$(adapter fm_backend_herdr_pane_presence_state "$HERDR_LAB_SESSION" "${PANES[$i]}")" = present ] \
+    || fail "killing one crew pane removed a sibling pane t$i"
+done
+[ "$(focused)" = "$FOCUS_BEFORE" ] || fail 'killing a crew pane moved the focused workspace'
+same_widths "$CREW_TAB" || fail "remaining crew columns are uneven after a close: $(rects "$CREW_TAB" | tr '\n' ';')"
+pass 'real herdr: killing one crew pane closes only that pane and keeps focus'
+
+read -r WS TAB "PANES[8]" < <(place fm-t8) || fail 'could not refill the crew grid'
+[ "$TAB" = "$CREW_TAB" ] || fail "the freed slot should be refilled in the first tab, got $TAB"
+even "$CREW_TAB" 3 2 || fail "refilling the freed slot did not restore an even 3x2 grid: $(rects "$CREW_TAB" | tr '\n' ';')"
+[ "$(cell_of "$CREW_TAB" "${PANES[8]}")" = "$X1 $Y1" ] || fail 'the refill should take the freed bottom-middle slot'
+pass 'real herdr: the next crew task refills the freed slot and restores the even grid'
+
+read -r WS TAB PANE_DUP < <(place fm-t1) || fail 'a same-labeled agent-free crew pane should be replaced'
+[ "$(adapter fm_backend_herdr_pane_presence_state "$HERDR_LAB_SESSION" "${PANES[1]}")" = dead ] \
+  || fail 'the replaced same-labeled husk pane is still present'
+PANES[1]=$PANE_DUP
+pass 'real herdr: a same-labeled agent-free crew pane is replaced only after its successor exists'
+
+# Closing the whole right column leaves two columns Herdr would draw as one
+# third and two thirds; the rebalance after each close evens them.
+adapter fm_backend_herdr_kill "$HERDR_LAB_SESSION:${PANES[3]}" || fail 'kill of crew task t3 failed'
+adapter fm_backend_herdr_kill "$HERDR_LAB_SESSION:${PANES[6]}" || fail 'kill of crew task t6 failed'
+[ "$(rects "$CREW_TAB" | awk '{print $2}' | sort -u | wc -l)" = 2 ] || fail "closing the right column should leave two columns: $(rects "$CREW_TAB" | tr '\n' ';')"
+same_widths "$CREW_TAB" || fail "the two remaining crew columns were not rebalanced: $(rects "$CREW_TAB" | tr '\n' ';')"
+pass 'real herdr: closing a whole crew column rebalances the remaining columns evenly'
+
+for i in 1 2 4 7 8; do
+  adapter fm_backend_herdr_kill "$HERDR_LAB_SESSION:${PANES[$i]}" || fail "kill of crew task t$i failed"
+done
+[ "$(adapter fm_backend_herdr_workspace_presence_state "$HERDR_LAB_SESSION" "$CREW_WS")" = dead ] \
+  || fail 'the crew workspace should disappear with its last pane'
+[ "$(adapter fm_backend_herdr_workspace_presence_state "$HERDR_LAB_SESSION" "$CREW_WS2")" = dead ] \
+  || fail 'the second crew workspace should disappear with its last pane'
+[ "$(focused)" = "$FOCUS_BEFORE" ] || fail 'emptying the crew workspace moved the focused workspace'
+read -r WS TAB _ < <(place fm-t9) || fail 'could not place a crew task after the crew workspace emptied'
+[ -n "$WS" ] && [ "$WS" != "$CREW_WS" ] || fail 'a new crew workspace should be created after the old one emptied'
+[ "$(lab workspace list | jq -r '[.result.workspaces[].label] | join(",")')" = "firstmate,firstmate-crew,other" ] \
+  || fail 'the recreated crew workspace should again sit right after the home'
+pass 'real herdr: each crew workspace disappears with its last pane and the next spawn recreates one'
+
+# The same layout through the real spawn and teardown scripts: a home whose
+# config selects "crew" gets its crewmates as panes of one crew workspace, and
+# teardown closes each exact pane.
+if ! command -v treehouse >/dev/null 2>&1; then
+  echo 'skip: treehouse not found; the real spawn and teardown pass needs it'
+  exit 0
+fi
+SPAWN_HOME="$TMP_ROOT/spawn-home"
+PROJECT_DIR="$TMP_ROOT/project"
+mkdir -p "$SPAWN_HOME/state" "$SPAWN_HOME/config" "$PROJECT_DIR"
+touch "$SPAWN_HOME/state/.last-watcher-beat"
+printf 'crew\n' > "$SPAWN_HOME/config/herdr-presentation-spaces"
+git -C "$PROJECT_DIR" init -q
+printf '# Herdr crew E2E fixture\n' > "$PROJECT_DIR/README.md"
+git -C "$PROJECT_DIR" add README.md
+git -C "$PROJECT_DIR" -c user.name='Firstmate Tests' -c user.email='tests@example.invalid' commit -qm initial
+git clone --quiet --bare "$PROJECT_DIR" "$PROJECT_DIR.origin.git"
+git -C "$PROJECT_DIR" remote add origin "file://$PROJECT_DIR.origin.git"
+
+spawn_task() {  # <id>
+  mkdir -p "$SPAWN_HOME/data/$1"
+  printf '# Task\n## Captain'"'"'s intent\nCrew fixture %s.\n\n## Firstmate spec\nNone.\n' "$1" > "$SPAWN_HOME/data/$1/brief.md"
+  env -u HERDR_ENV -u HERDR_PANE_ID -u HERDR_TAB_ID -u HERDR_WORKSPACE_ID -u HERDR_SOCKET_PATH \
+    PATH="$FAKEBIN:$HERDR_ORIGINAL_PATH" HERDR_SESSION="$HERDR_LAB_SESSION" \
+    FM_GATE_REFUSE_BYPASS=1 FM_SPAWN_NO_GUARD=1 FM_HOME="$SPAWN_HOME" FM_ROOT_OVERRIDE="$ROOT" \
+    "$ROOT/bin/fm-spawn.sh" "$1" "$PROJECT_DIR" "sh -c 'while :; do sleep 60; done'" --mode no-mistakes --yolo off --backend herdr
+}
+teardown_task() {  # <id>
+  env -u HERDR_ENV -u HERDR_PANE_ID -u HERDR_TAB_ID -u HERDR_WORKSPACE_ID -u HERDR_SOCKET_PATH \
+    PATH="$FAKEBIN:$HERDR_ORIGINAL_PATH" HERDR_SESSION="$HERDR_LAB_SESSION" \
+    FM_GATE_REFUSE_BYPASS=1 FM_HOME="$SPAWN_HOME" FM_ROOT_OVERRIDE="$ROOT" \
+    FM_STATE_OVERRIDE="$SPAWN_HOME/state" FM_DATA_OVERRIDE="$SPAWN_HOME/data" FM_CONFIG_OVERRIDE="$SPAWN_HOME/config" \
+    "$ROOT/bin/fm-teardown.sh" "$1" --force
+}
+meta() { grep "^$2=" "$SPAWN_HOME/state/$1.meta" | cut -d= -f2-; }
+
+for id in crew-a crew-b; do
+  spawn_task "$id" > "$TMP_ROOT/$id.out" 2> "$TMP_ROOT/$id.err" || fail "real crew spawn $id failed: $(cat "$TMP_ROOT/$id.err")"
+  RECORDED_WORKTREES="${RECORDED_WORKTREES}$(meta "$id" worktree)"$'\n'
+done
+[ "$(meta crew-a herdr_workspace_id)" = "$(meta crew-b herdr_workspace_id)" ] \
+  && [ "$(meta crew-a herdr_tab_id)" = "$(meta crew-b herdr_tab_id)" ] \
+  && [ "$(meta crew-a herdr_pane_id)" != "$(meta crew-b herdr_pane_id)" ] \
+  || fail 'two real crew spawns should be two panes of one crew tab'
+SPAWN_WS=$(meta crew-a herdr_workspace_id)
+[ "$(lab workspace list | jq -r --arg ws "$SPAWN_WS" '.result.workspaces[] | select(.workspace_id == $ws) | .label')" = firstmate-crew ] \
+  || fail 'the real crew spawns did not land in a labeled crew workspace'
+[ ! -e "$SPAWN_HOME/state/crew-a.herdr-presentation" ] || fail 'a crew spawn must not write a presentation journal'
+pass 'real herdr: real spawns on the crew setting become panes of one crew workspace'
+
+PANE_B=$(meta crew-b herdr_pane_id)
+teardown_task crew-a > "$TMP_ROOT/td-a.out" 2> "$TMP_ROOT/td-a.err" || fail "real crew teardown failed: $(cat "$TMP_ROOT/td-a.err")"
+[ "$(adapter fm_backend_herdr_pane_presence_state "$HERDR_LAB_SESSION" "$PANE_B")" = present ] \
+  || fail 'tearing down one real crew task closed its sibling pane'
+teardown_task crew-b > "$TMP_ROOT/td-b.out" 2> "$TMP_ROOT/td-b.err" || fail "real crew teardown failed: $(cat "$TMP_ROOT/td-b.err")"
+[ "$(adapter fm_backend_herdr_workspace_presence_state "$HERDR_LAB_SESSION" "$SPAWN_WS")" = dead ] \
+  || fail 'the crew workspace should disappear when its last real task is torn down'
+pass 'real herdr: real teardown closes one exact crew pane and the workspace goes with the last one'
diff --git a/tests/fm-backend-herdr-crew.test.sh b/tests/fm-backend-herdr-crew.test.sh
new file mode 100755
index 00000000000..5cc6fd0a14d
--- /dev/null
+++ b/tests/fm-backend-herdr-crew.test.sh
@@ -0,0 +1,308 @@
+#!/usr/bin/env bash
+# tests/fm-backend-herdr-crew.test.sh - portable regressions for the Herdr crew
+# workspace layout (docs/herdr-backend.md "Crew workspace"): placement,
+# the 3x2 grid and its fill order, cap overflow into a second crew workspace,
+# exact-pane cleanup with rebalance, and a workspace disappearing with its
+# last pane.
+# Drives bin/backends/herdr.sh against tests/herdr-crew-fake.py, a stateful
+# fake that models Herdr's split tree and layout socket, so no Herdr is needed.
+# tests/fm-backend-herdr-crew-workspace-e2e.test.sh is the real-Herdr twin.
+set -u
+
+# shellcheck source=tests/lib.sh
+. "$(dirname "${BASH_SOURCE[0]}")/lib.sh"
+# shellcheck source=tests/herdr-test-safety.sh
+. "$(dirname "${BASH_SOURCE[0]}")/herdr-test-safety.sh"
+
+command -v jq >/dev/null 2>&1 || { echo "skip: jq not found (required by the herdr adapter)"; exit 0; }
+command -v python3 >/dev/null 2>&1 || { echo "skip: python3 not found (required by the crew fake)"; exit 0; }
+
+herdr_forget_inherited_pane
+
+TMP_ROOT=$(fm_test_tmproot fm-herdr-crew-tests)
+FAKE="$ROOT/tests/herdr-crew-fake.py"
+SERVERS=()
+crew_cleanup() {
+  local pid
+  for pid in "${SERVERS[@]:-}"; do
+    [ -n "$pid" ] && kill "$pid" 2>/dev/null
+  done
+  fm_test_cleanup
+}
+trap crew_cleanup EXIT
+
+# crew_fixture <name>: a fresh fake Herdr with one focused home workspace and
+# a live layout socket. Sets DIR, HOME_DIR, FB, and exports the fake's env.
+crew_fixture() {
+  DIR="$TMP_ROOT/$1"
+  HOME_DIR="$DIR/home"
+  FB="$DIR/fakebin"
+  mkdir -p "$HOME_DIR/state" "$HOME_DIR/config" "$FB"
+  printf '#!/usr/bin/env bash\nexec python3 %q cli "$@"\n' "$FAKE" > "$FB/herdr"
+  chmod +x "$FB/herdr"
+  export FM_FAKE_HERDR_STATE="$DIR/state.json"
+  export FM_FAKE_HERDR_SOCKET="$DIR/s.sock"
+  export FM_FAKE_HERDR_AREA=120x40
+  unset FM_FAKE_HERDR_NO_LAYOUT_API
+  python3 "$FAKE" serve "$FM_FAKE_HERDR_SOCKET" &
+  SERVERS+=("$!")
+  local i=0
+  while [ ! -S "$FM_FAKE_HERDR_SOCKET" ] && [ "$i" -lt 50 ]; do sleep 0.05; i=$((i + 1)); done
+  [ -S "$FM_FAKE_HERDR_SOCKET" ] || fail "fake layout socket did not start for $1"
+  HOME_WS=$(herdr_fake workspace create --cwd "$DIR" --label firstmate --no-focus | jq -r '.result.workspace.workspace_id')
+}
+
+herdr_fake() { PATH="$FB:$PATH" herdr "$@" --session crewlab; }
+
+# adapter <function> [args...]: run one adapter function as the fixture home.
+adapter() {
+  PATH="$FB:$PATH" FM_HOME="$HOME_DIR" HERDR_SESSION=crewlab \
+    bash -c '. "$1/bin/backends/herdr.sh"; shift; "$@"' _ "$ROOT" "$@"
+}
+
+# place <label> [cap]: place one crew task; prints "<ws> <tab> <pane>".
+place() {
+  PATH="$FB:$PATH" FM_HOME="$HOME_DIR" HERDR_SESSION=crewlab bash -c '
+    . "$1/bin/backends/herdr.sh"
+    fm_backend_herdr_crew_create_task crewlab "$2/state" "$2" "$3" "${4:-$FM_BACKEND_HERDR_CREW_PANE_CAP_DEFAULT}" "" || exit 1
+    printf "%s %s %s\n" "$FM_BACKEND_HERDR_CREW_WORKSPACE_ID" "$FM_BACKEND_HERDR_CREW_TAB_ID" "$FM_BACKEND_HERDR_CREW_PANE_ID"
+  ' _ "$ROOT" "$HOME_DIR" "$1" "${2:-}"
+}
+
+# grid <pane-in-tab>: "<label> <x> <y> <w> <h>" per pane, in layout order.
+grid() {
+  local layout labels
+  layout=$(herdr_fake pane layout --pane "$1")
+  labels=$(herdr_fake pane list)
+  jq -rn --argjson layout "$layout" --argjson labels "$labels" '
+    ($labels.result.panes | map({key: .pane_id, value: (.label // .pane_id)}) | from_entries) as $name
+    | $layout.result.layout.panes[] | "\($name[.pane_id]) \(.rect.x) \(.rect.y) \(.rect.width) \(.rect.height)"'
+}
+
+cell() { grid "$1" | awk -v l="$2" '$1 == l { print $2 "," $3 " " $4 "x" $5 }'; }
+
+focused() { herdr_fake workspace list | jq -r '.result.workspaces[] | select(.focused == true) | .workspace_id'; }
+
+# --- configuration ------------------------------------------------------------
+
+test_preference_parses_the_crew_values() {
+  local dir value got err
+  dir="$TMP_ROOT/pref"; mkdir -p "$dir"
+  for value in crew CREW ' crew ' 'Crew
+'; do
+    printf '%s' "$value" > "$dir/herdr-presentation-spaces"
+    got=$(bash -c '. "$1/bin/backends/herdr.sh"; fm_backend_herdr_presentation_preference "$2"' _ "$ROOT" "$dir")
+    assert_equals crew:6 "$got" "the value '$value' should select the crew layout with the default cap of six"
+  done
+  printf 'crew:4' > "$dir/herdr-presentation-spaces"
+  got=$(bash -c '. "$1/bin/backends/herdr.sh"; fm_backend_herdr_presentation_preference "$2"' _ "$ROOT" "$dir")
+  assert_equals crew:4 "$got" "crew:4 should set a cap of four"
+  for value in crew:0 crew:17 crew:x crews; do
+    printf '%s' "$value" > "$dir/herdr-presentation-spaces"
+    err="$dir/err"
+    got=$(bash -c '. "$1/bin/backends/herdr.sh"; fm_backend_herdr_presentation_preference "$2"' _ "$ROOT" "$dir" 2>"$err")
+    assert_equals default "$got" "the invalid value '$value' should fall back to the default"
+    assert_contains "$(cat "$err")" crew "the warning for '$value' should name the crew form"
+  done
+  printf 'crew' > "$dir/herdr-presentation-spaces"
+  if bash -c '. "$1/bin/backends/herdr.sh"; fm_backend_herdr_presentation_enabled "$2"' _ "$ROOT" "$dir" 2>/dev/null; then
+    fail "the crew layout must not also enable the one-task projection"
+  fi
+  pass "herdr crew: crew and crew:<1-16> select the crew layout, other values warn and fall back"
+}
+
+# --- placement ----------------------------------------------------------------
+
+test_first_task_creates_one_recorded_crew_workspace() {
+  local ws tab pane record
+  crew_fixture first
+  read -r ws tab pane < <(place fm-a) || fail "first crew placement failed"
+  [ "$ws" != "$HOME_WS" ] || fail "a crew task must not land in the home workspace"
+  assert_equals firstmate-crew "$(herdr_fake workspace list | jq -r --arg ws "$ws" '.result.workspaces[] | select(.workspace_id == $ws) | .label')" \
+    "the crew workspace carries the home's crew label"
+  assert_equals 1 "$(herdr_fake pane list --workspace "$ws" | jq '.result.panes | length')" \
+    "the new crew workspace should hold only the task pane, with no seeded extra"
+  assert_equals fm-a "$(herdr_fake pane get "$pane" | jq -r '.result.pane.label')" "the crew pane carries the task label"
+  record=$(printf '%s' "$HOME_DIR"/state/.herdr-crew-workspace-*)
+  assert_equals "$ws" "$(cat "$record")" "the crew workspace id is recorded in the home's state"
+  assert_equals "$HOME_WS" "$(focused)" "creating the crew workspace must not move focus"
+  pass "herdr crew: the first task creates and records one labeled crew workspace without moving focus"
+}
+
+test_six_tasks_fill_an_even_grid_top_row_first() {
+  local i ws tab pane first_tab expected actual
+  crew_fixture grid
+  for i in 1 2 3 4 5 6; do
+    read -r ws tab pane < <(place "fm-t$i") || fail "crew placement $i failed"
+    [ -n "${first_tab:-}" ] || first_tab=$tab
+    assert_equals "$first_tab" "$tab" "task $i should stay in the first crew tab"
+    if [ "$i" = 3 ]; then
+      assert_equals "0,0 40x40;40,0 40x40;80,0 40x40;" \
+        "$(for l in fm-t1 fm-t2 fm-t3; do printf '%s;' "$(cell "$pane" "$l")"; done)" \
+        "three crew tasks should be three even full-height columns"
+    fi
+  done
+  expected="0,0 40x20;40,0 40x20;80,0 40x20;0,20 40x20;40,20 40x20;80,20 40x20;"
+  actual=$(for i in 1 2 3 4 5 6; do printf '%s;' "$(cell "$pane" "fm-t$i")"; done)
+  assert_equals "$expected" "$actual" "six crew tasks should fill an even 3x2 grid, top row left to right, then bottom row"
+  assert_equals "$HOME_WS" "$(focused)" "filling the grid must not move focus"
+  pass "herdr crew: six tasks fill an even 3x2 grid, top row left to right, then bottom row"
+}
+
+test_seventh_task_overflows_into_a_second_crew_workspace() {
+  local i ws tab pane crew_ws panes=() ws2 pane7 ws8
+  crew_fixture overflow
+  for i in 1 2 3 4 5 6; do
+    read -r ws tab pane < <(place "fm-t$i") || fail "crew placement $i failed"
+    crew_ws=$ws; panes[i]=$pane
+  done
+  read -r ws2 tab pane7 < <(place fm-t7) || fail "seventh crew placement failed"
+  assert_not_equals "$crew_ws" "$ws2" "the seventh task should open a second crew workspace once the first holds six"
+  assert_equals 1 "$(herdr_fake tab list --workspace "$crew_ws" | jq '.result.tabs | length')" \
+    "the full crew workspace should never gain a second tab"
+  assert_equals 1 "$(herdr_fake pane list --workspace "$ws2" | jq '.result.panes | length')" \
+    "the second crew workspace should hold only the seventh pane"
+  assert_equals "firstmate,firstmate-crew,firstmate-crew" "$(herdr_fake workspace list | jq -r '[.result.workspaces[].label] | join(",")')" \
+    "the second crew workspace carries the crew label and follows the first"
+  assert_equals "$crew_ws $ws2" "$(tr '\n' ' ' < "$(printf '%s' "$HOME_DIR"/state/.herdr-crew-workspace-*)" | sed 's/ $//')" \
+    "both crew workspace ids are recorded in order"
+  assert_equals 7 "$(adapter fm_backend_herdr_list_live crewlab | grep -c $'\tfm-t')" "list-live should report every crew pane in both workspaces"
+  adapter fm_backend_herdr_kill "crewlab:$pane7" || fail "kill of the seventh task failed"
+  assert_equals dead "$(adapter fm_backend_herdr_workspace_presence_state crewlab "$ws2")" \
+    "the second crew workspace should disappear with its last pane"
+  assert_equals 6 "$(herdr_fake pane list --workspace "$crew_ws" | jq '.result.panes | length')" "the first crew workspace keeps its six panes"
+  adapter fm_backend_herdr_kill "crewlab:${panes[2]}" || fail "kill of task 2 failed"
+  read -r ws8 tab pane < <(place fm-t8) || fail "refill placement failed"
+  assert_equals "$crew_ws" "$ws8" "a freed slot in the first crew workspace is refilled before another workspace opens"
+  pass "herdr crew: a seventh task overflows into a second crew workspace, which goes with its last pane"
+}
+
+test_configured_cap_overflows_earlier() {
+  local ws1 ws2 ws3 tab pane
+  crew_fixture cap
+  read -r ws1 tab pane < <(place fm-a 2) || fail "crew placement a failed"
+  read -r ws2 tab pane < <(place fm-b 2) || fail "crew placement b failed"
+  assert_equals "$ws1" "$ws2" "a cap of two should put two tasks in one crew workspace"
+  assert_equals "0,0 60x40;60,0 60x40;" "$(cell "$pane" fm-a);$(cell "$pane" fm-b);" \
+    "a cap of two should place its tasks side by side"
+  read -r ws3 tab pane < <(place fm-c 2) || fail "crew placement c failed"
+  assert_not_equals "$ws1" "$ws3" "a cap of two should overflow the third task into another crew workspace"
+  pass "herdr crew: a configured cap changes how many panes a crew workspace holds"
+}
+
+# --- cleanup -------------------------------------------------------------------
+
+test_kill_closes_one_pane_among_several_and_rebalances() {
+  local i ws tab pane panes=() p
+  crew_fixture kill-one
+  for i in 1 2 3; do
+    read -r ws tab pane < <(place "fm-t$i") || fail "crew placement $i failed"
+    panes[i]=$pane
+  done
+  adapter fm_backend_herdr_kill "crewlab:${panes[2]}" || fail "kill of the middle crew pane failed"
+  assert_equals dead "$(adapter fm_backend_herdr_pane_presence_state crewlab "${panes[2]}")" "the killed crew pane should be gone"
+  for p in "${panes[1]}" "${panes[3]}"; do
+    assert_equals present "$(adapter fm_backend_herdr_pane_presence_state crewlab "$p")" "killing one crew pane must keep its siblings"
+  done
+  assert_equals "0,0 60x40;60,0 60x40;" "$(cell "${panes[1]}" fm-t1);$(cell "${panes[1]}" fm-t3);" \
+    "the two remaining crew panes should be rebalanced to equal halves"
+  assert_equals "$HOME_WS" "$(focused)" "killing a crew pane must not move focus"
+  pass "herdr crew: kill closes one exact crew pane, keeps its siblings and focus, and rebalances"
+}
+
+test_freed_slot_is_refilled() {
+  local i ws tab pane panes=()
+  crew_fixture refill
+  for i in 1 2 3 4 5 6; do
+    read -r ws tab pane < <(place "fm-t$i") || fail "crew placement $i failed"
+    panes[i]=$pane
+  done
+  adapter fm_backend_herdr_kill "crewlab:${panes[5]}" || fail "kill of the bottom-middle crew pane failed"
+  assert_equals "40,0 40x40" "$(cell "${panes[1]}" fm-t2)" "the pane above a freed slot should take its column"
+  read -r ws tab pane < <(place fm-t8) || fail "refill placement failed"
+  assert_equals "40,20 40x20" "$(cell "$pane" fm-t8)" "the next task should refill the freed bottom-middle slot"
+  pass "herdr crew: the next task refills a freed slot and restores the grid"
+}
+
+test_last_pane_removes_the_workspace_and_next_spawn_recreates_it() {
+  local ws tab pane ws2
+  crew_fixture last
+  read -r ws tab pane < <(place fm-a) || fail "crew placement failed"
+  adapter fm_backend_herdr_kill "crewlab:$pane" || fail "kill of the last crew pane failed"
+  assert_equals dead "$(adapter fm_backend_herdr_workspace_presence_state crewlab "$ws")" \
+    "the crew workspace should disappear with its last pane"
+  assert_equals "$HOME_WS" "$(focused)" "emptying the crew workspace must not move focus"
+  read -r ws2 tab pane < <(place fm-b) || fail "placement after the crew workspace emptied failed"
+  assert_not_equals "$ws" "$ws2" "a new crew workspace should be created after the old one emptied"
+  assert_equals "$ws2" "$(cat "$HOME_DIR"/state/.herdr-crew-workspace-*)" "the record should follow the new crew workspace"
+  pass "herdr crew: the crew workspace goes with its last pane and the next spawn recreates it"
+}
+
+# --- identity and refusal --------------------------------------------------------
+
+test_a_relabeled_recorded_workspace_is_never_adopted() {
+  local ws tab pane ws2 state
+  crew_fixture relabel
+  read -r ws tab pane < <(place fm-a) || fail "crew placement failed"
+  state=$(jq --arg ws "$ws" '(.workspaces[] | select(.workspace_id == $ws) | .label) = "manually-renamed"' "$FM_FAKE_HERDR_STATE")
+  printf '%s\n' "$state" > "$FM_FAKE_HERDR_STATE"
+  read -r ws2 tab pane < <(place fm-b) || fail "placement after a relabel failed"
+  assert_not_equals "$ws" "$ws2" "a recorded workspace that no longer carries the crew label must not be adopted"
+  assert_equals 1 "$(herdr_fake pane list --workspace "$ws" | jq '.result.panes | length')" \
+    "the relabeled workspace must be left untouched"
+  pass "herdr crew: a recorded workspace whose label changed is never adopted"
+}
+
+test_a_live_same_labeled_pane_refuses() {
+  local ws tab pane before state
+  crew_fixture live-dup
+  read -r ws tab pane < <(place fm-a) || fail "crew placement failed"
+  state=$(jq --arg p "$pane" '.agents[$p] = "working"' "$FM_FAKE_HERDR_STATE")
+  printf '%s\n' "$state" > "$FM_FAKE_HERDR_STATE"
+  before=$(herdr_fake pane list | jq '.result.panes | length')
+  if place fm-a >/dev/null 2>"$DIR/err"; then
+    fail "a live same-labeled crew pane must refuse a duplicate placement"
+  fi
+  assert_contains "$(cat "$DIR/err")" "already exists" "the refusal should say the pane already exists"
+  assert_equals "$before" "$(herdr_fake pane list | jq '.result.panes | length')" "a refused placement must create nothing"
+  pass "herdr crew: a live same-labeled crew pane refuses a duplicate placement"
+}
+
+test_list_live_reports_crew_panes() {
+  local ws tab pane live
+  crew_fixture list-live
+  place fm-a >/dev/null || fail "crew placement a failed"
+  place fm-b >/dev/null || fail "crew placement b failed"
+  live=$(adapter fm_backend_herdr_list_live crewlab)
+  assert_contains "$live" $'\tfm-a' "list-live should report the first crew pane"
+  assert_contains "$live" $'\tfm-b' "list-live should report the second crew pane"
+  pass "herdr crew: list-live reports crew panes by their task labels"
+}
+
+test_missing_layout_api_still_places_with_a_warning() {
+  local ws tab pane
+  crew_fixture no-layout-api
+  export FM_FAKE_HERDR_NO_LAYOUT_API=1
+  place fm-a >/dev/null || fail "crew placement a failed"
+  read -r ws tab pane < <(place fm-b 2>"$DIR/err") || fail "crew placement without the layout API failed"
+  assert_contains "$(cat "$DIR/err")" "rebalance" "an unavailable rebalance should warn"
+  assert_equals "0,0 60x40;60,0 60x40;" "$(cell "$pane" fm-a);$(cell "$pane" fm-b);" \
+    "a two-pane split needs no rebalance to be even"
+  place fm-c >/dev/null 2>&1 || fail "crew placement c failed"
+  assert_equals "90,0 30x40" "$(cell "$pane" fm-c)" "without the layout API the third column keeps Herdr's plain half split of the right pane"
+  unset FM_FAKE_HERDR_NO_LAYOUT_API
+  pass "herdr crew: without the layout API placement still works and only the rebalance is skipped"
+}
+
+test_preference_parses_the_crew_values
+test_first_task_creates_one_recorded_crew_workspace
+test_six_tasks_fill_an_even_grid_top_row_first
+test_seventh_task_overflows_into_a_second_crew_workspace
+test_configured_cap_overflows_earlier
+test_kill_closes_one_pane_among_several_and_rebalances
+test_freed_slot_is_refilled
+test_last_pane_removes_the_workspace_and_next_spawn_recreates_it
+test_a_relabeled_recorded_workspace_is_never_adopted
+test_a_live_same_labeled_pane_refuses
+test_list_live_reports_crew_panes
+test_missing_layout_api_still_places_with_a_warning
diff --git a/tests/herdr-crew-fake.py b/tests/herdr-crew-fake.py
new file mode 100755
index 00000000000..f82e1b19ce3
--- /dev/null
+++ b/tests/herdr-crew-fake.py
@@ -0,0 +1,385 @@
+#!/usr/bin/env python3
+"""Stateful fake Herdr for the portable crew-workspace suite.
+
+It models what the crew layout depends on, using the shapes recorded against
+the real binary (Herdr 0.7.4 and 0.9.1): workspaces holding tabs, each tab a
+binary split tree of panes; `pane split` replaces the target leaf with a split
+whose first child keeps the target; `pane close` collapses the leaf into its
+sibling, removes an emptied tab, and removes an emptied workspace; `pane
+layout` reports every pane's rectangle in a fixed tab area.
+
+Usage:
+  herdr-crew-fake.py cli <herdr arguments...>   (behaves as the herdr CLI)
+  herdr-crew-fake.py serve <socket-path>        (serves layout.export and
+                                                 layout.set_split_ratio)
+
+State lives in $FM_FAKE_HERDR_STATE; the fake socket path the CLI reports is
+$FM_FAKE_HERDR_SOCKET; the tab area is $FM_FAKE_HERDR_AREA (WIDTHxHEIGHT,
+default 120x40).
+"""
+
+import fcntl
+import json
+import os
+import socket
+import sys
+
+
+def area():
+    raw = os.environ.get("FM_FAKE_HERDR_AREA", "120x40")
+    width, height = raw.split("x")
+    return int(width), int(height)
+
+
+class State:
+    def __init__(self):
+        self.path = os.environ["FM_FAKE_HERDR_STATE"]
+        self.lock = open(self.path + ".lock", "a")
+        fcntl.flock(self.lock, fcntl.LOCK_EX)
+        try:
+            with open(self.path) as handle:
+                self.data = json.load(handle)
+        except (OSError, ValueError):
+            self.data = {"next": 1, "workspaces": [], "tabs": {}, "labels": {}, "agents": {}}
+
+    def save(self):
+        tmp = self.path + ".tmp"
+        with open(tmp, "w") as handle:
+            json.dump(self.data, handle)
+        os.replace(tmp, self.path)
+
+    def fresh(self, prefix):
+        number = self.data["next"]
+        self.data["next"] += 1
+        return f"{prefix}{number}"
+
+
+def leaves(node):
+    if node["type"] == "pane":
+        return [node["pane_id"]]
+    return leaves(node["first"]) + leaves(node["second"])
+
+
+def rects(node, x, y, width, height, out):
+    if node["type"] == "pane":
+        out.append({"pane_id": node["pane_id"], "rect": {"x": x, "y": y, "width": width, "height": height}})
+        return
+    if node["direction"] == "right":
+        first = int(round(width * node["ratio"]))
+        rects(node["first"], x, y, first, height, out)
+        rects(node["second"], x + first, y, width - first, height, out)
+    else:
+        first = int(round(height * node["ratio"]))
+        rects(node["first"], x, y, width, first, out)
+        rects(node["second"], x, y + first, width, height - first, out)
+
+
+def replace_leaf(node, pane_id, new):
+    if node["type"] == "pane":
+        return new if node["pane_id"] == pane_id else node
+    node["first"] = replace_leaf(node["first"], pane_id, new)
+    node["second"] = replace_leaf(node["second"], pane_id, new)
+    return node
+
+
+def remove_leaf(node, pane_id):
+    """Return the tree without pane_id, or None when it was the only leaf."""
+    if node["type"] == "pane":
+        return None if node["pane_id"] == pane_id else node
+    first = remove_leaf(node["first"], pane_id)
+    second = remove_leaf(node["second"], pane_id)
+    if first is None:
+        return second
+    if second is None:
+        return first
+    node["first"], node["second"] = first, second
+    return node
+
+
+def node_at(node, path):
+    for step in path:
+        if node["type"] != "split":
+            return None
+        node = node["second"] if step else node["first"]
+    return node
+
+
+def ok(result):
+    print(json.dumps({"id": "cli", "result": result}))
+    return 0
+
+
+def err(code):
+    print(json.dumps({"id": "cli", "error": {"code": code, "message": code}}))
+    return 1
+
+
+def option(args, name):
+    if name in args:
+        index = args.index(name)
+        if index + 1 < len(args):
+            return args[index + 1]
+    return None
+
+
+def workspace_view(state, workspace):
+    return {
+        "workspace_id": workspace["workspace_id"],
+        "label": workspace["label"],
+        "focused": workspace["focused"],
+        "active_tab_id": workspace["active_tab_id"],
+    }
+
+
+def workspace_of(state, workspace_id):
+    for workspace in state.data["workspaces"]:
+        if workspace["workspace_id"] == workspace_id:
+            return workspace
+    return None
+
+
+def tab_view(state, tab_id):
+    tab = state.data["tabs"][tab_id]
+    workspace = workspace_of(state, tab["workspace_id"])
+    return {
+        "tab_id": tab_id,
+        "workspace_id": tab["workspace_id"],
+        "label": tab["label"],
+        "focused": bool(workspace["focused"] and workspace["active_tab_id"] == tab_id),
+        "pane_count": len(leaves(tab["root"])),
+    }
+
+
+def pane_index(state):
+    index = {}
+    for tab_id, tab in state.data["tabs"].items():
+        for pane_id in leaves(tab["root"]):
+            index[pane_id] = tab_id
+    return index
+
+
+def pane_view(state, pane_id, tab_id):
+    view = {"pane_id": pane_id, "tab_id": tab_id, "workspace_id": state.data["tabs"][tab_id]["workspace_id"]}
+    if pane_id in state.data["labels"]:
+        view["label"] = state.data["labels"][pane_id]
+    return view
+
+
+def new_tab(state, workspace_id, label):
+    tab_id = state.fresh(f"{workspace_id}:t")
+    pane_id = state.fresh(f"{workspace_id}:p")
+    workspace = workspace_of(state, workspace_id)
+    state.data["tabs"][tab_id] = {
+        "workspace_id": workspace_id,
+        "label": label or str(sum(1 for t in state.data["tabs"].values() if t["workspace_id"] == workspace_id) + 1),
+        "root": {"type": "pane", "pane_id": pane_id},
+    }
+    if not workspace["active_tab_id"]:
+        workspace["active_tab_id"] = tab_id
+    return tab_id, pane_id
+
+
+def close_pane(state, pane_id):
+    index = pane_index(state)
+    tab_id = index[pane_id]
+    tab = state.data["tabs"][tab_id]
+    tab["root"] = remove_leaf(tab["root"], pane_id)
+    state.data["labels"].pop(pane_id, None)
+    if tab["root"] is not None:
+        return
+    workspace = workspace_of(state, tab["workspace_id"])
+    del state.data["tabs"][tab_id]
+    remaining = [t for t, v in state.data["tabs"].items() if v["workspace_id"] == workspace["workspace_id"]]
+    if workspace["active_tab_id"] == tab_id:
+        workspace["active_tab_id"] = remaining[0] if remaining else ""
+    if not remaining:
+        state.data["workspaces"].remove(workspace)
+        if workspace["focused"] and state.data["workspaces"]:
+            state.data["workspaces"][0]["focused"] = True
+
+
+def cli(args):
+    if len(args) >= 2 and args[-2] == "--session":
+        session = args[-1]
+        args = args[:-2]
+    else:
+        session = os.environ.get("HERDR_SESSION", "default")
+    if args == ["--version"]:
+        print("herdr 0.9.1")
+        return 0
+    command = " ".join(args[:2])
+    if command == "status --json":
+        return print(json.dumps({
+            "client": {"version": "0.9.1", "protocol": 22},
+            "server": {"running": True, "version": "0.9.1", "protocol": 22, "compatible": True},
+        })) or 0
+    if command == "api schema":
+        methods = ["layout.export", "layout.set_split_ratio", "pane.split", "pane.layout"]
+        if os.environ.get("FM_FAKE_HERDR_NO_LAYOUT_API"):
+            methods = ["pane.split", "pane.layout"]
+        return print(json.dumps({"schemas": {"request": {"oneOf": [
+            {"properties": {"method": {"const": method}}} for method in methods
+        ], "$defs": {}}}})) or 0
+    if command == "session list":
+        return print(json.dumps({"sessions": [
+            {"name": session, "running": True, "socket_path": os.environ["FM_FAKE_HERDR_SOCKET"]}
+        ]})) or 0
+    if command == "terminal title":
+        return ok({"type": "ok", "reason": "no_foreground_client"})
+
+    state = State()
+    try:
+        return dispatch(state, command, args)
+    finally:
+        state.lock.close()
+
+
+def dispatch(state, command, args):
+    rest = args[2:]
+    if command == "workspace list":
+        return ok({"type": "workspace_list", "workspaces": [workspace_view(state, w) for w in state.data["workspaces"]]})
+    if command == "workspace create":
+        workspace_id = state.fresh("w")
+        first = not state.data["workspaces"]
+        workspace = {"workspace_id": workspace_id, "label": option(rest, "--label") or "", "focused": first, "active_tab_id": ""}
+        state.data["workspaces"].append(workspace)
+        tab_id, pane_id = new_tab(state, workspace_id, "1")
+        state.save()
+        return ok({"type": "workspace_created", "workspace": workspace_view(state, workspace),
+                   "tab": tab_view(state, tab_id), "root_pane": pane_view(state, pane_id, tab_id)})
+    if command == "tab list":
+        workspace_id = option(rest, "--workspace")
+        return ok({"type": "tab_list", "tabs": [
+            tab_view(state, t) for t, v in state.data["tabs"].items() if v["workspace_id"] == workspace_id
+        ]})
+    if command == "tab get":
+        if not rest or rest[0] not in state.data["tabs"]:
+            return err("tab_not_found")
+        return ok({"type": "tab_info", "tab": tab_view(state, rest[0])})
+    if command == "tab create":
+        workspace_id = option(rest, "--workspace")
+        if workspace_of(state, workspace_id) is None:
+            return err("workspace_not_found")
+        tab_id, pane_id = new_tab(state, workspace_id, option(rest, "--label"))
+        state.save()
+        return ok({"type": "tab_created", "tab": tab_view(state, tab_id), "root_pane": pane_view(state, pane_id, tab_id)})
+    if command == "tab focus":
+        tab = state.data["tabs"].get(rest[0] if rest else "")
+        if tab is None:
+            return err("tab_not_found")
+        for workspace in state.data["workspaces"]:
+            workspace["focused"] = workspace["workspace_id"] == tab["workspace_id"]
+        workspace_of(state, tab["workspace_id"])["active_tab_id"] = rest[0]
+        state.save()
+        return ok({"type": "ok"})
+    index = pane_index(state)
+    if command == "pane list":
+        workspace_id = option(rest, "--workspace")
+        return ok({"type": "pane_list", "panes": [
+            pane_view(state, p, t) for p, t in index.items()
+            if workspace_id is None or state.data["tabs"][t]["workspace_id"] == workspace_id
+        ]})
+    if command == "pane get":
+        if not rest or rest[0] not in index:
+            return err("pane_not_found")
+        return ok({"type": "pane_info", "pane": pane_view(state, rest[0], index[rest[0]])})
+    if command == "pane split":
+        target = rest[0] if rest and not rest[0].startswith("--") else option(rest, "--pane")
+        if target not in index:
+            return err("pane_not_found")
+        tab_id = index[target]
+        pane_id = state.fresh(f"{state.data['tabs'][tab_id]['workspace_id']}:p")
+        ratio = float(option(rest, "--ratio") or 0.5)
+        tab = state.data["tabs"][tab_id]
+        tab["root"] = replace_leaf(tab["root"], target, {
+            "type": "split", "direction": option(rest, "--direction") or "right", "ratio": ratio,
+            "first": {"type": "pane", "pane_id": target}, "second": {"type": "pane", "pane_id": pane_id},
+        })
+        state.save()
+        return ok({"type": "pane_info", "pane": pane_view(state, pane_id, tab_id)})
+    if command == "pane layout":
+        target = option(rest, "--pane")
+        if target not in index:
+            return err("pane_not_found")
+        tab_id = index[target]
+        width, height = area()
+        panes = []
+        rects(state.data["tabs"][tab_id]["root"], 0, 0, width, height, panes)
+        return ok({"type": "pane_layout", "layout": {
+            "area": {"x": 0, "y": 0, "width": width, "height": height},
+            "panes": panes, "tab_id": tab_id, "workspace_id": state.data["tabs"][tab_id]["workspace_id"],
+        }})
+    if command == "pane rename":
+        if not rest or rest[0] not in index:
+            return err("pane_not_found")
+        state.data["labels"][rest[0]] = " ".join(rest[1:])
+        state.save()
+        return ok({"type": "pane_info", "pane": pane_view(state, rest[0], index[rest[0]])})
+    if command == "pane close":
+        if not rest or rest[0] not in index:
+            return err("pane_not_found")
+        close_pane(state, rest[0])
+        state.save()
+        return ok({"type": "ok"})
+    if command == "agent get":
+        status = state.data["agents"].get(rest[0] if rest else "")
+        if status is None:
+            return err("agent_not_found")
+        return ok({"type": "agent_info", "agent": {"agent": "claude", "agent_status": status}})
+    return err("unsupported_by_fake")
+
+
+def serve(socket_path):
+    server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    server.bind(socket_path)
+    server.listen(8)
+    while True:
+        connection, _ = server.accept()
+        with connection:
+            buffer = b""
+            while b"\n" not in buffer:
+                chunk = connection.recv(65536)
+                if not chunk:
+                    break
+                buffer += chunk
+            try:
+                request = json.loads(buffer.split(b"\n", 1)[0])
+            except ValueError:
+                continue
+            response = handle(request)
+            connection.sendall((json.dumps(response) + "\n").encode())
+
+
+def handle(request):
+    state = State()
+    try:
+        method, params = request.get("method"), request.get("params") or {}
+        tab_id = params.get("tab_id")
+        tab = state.data["tabs"].get(tab_id)
+        if tab is None:
+            return {"id": request.get("id"), "error": {"code": "layout_not_found"}}
+        if method == "layout.set_split_ratio":
+            node = node_at(tab["root"], params.get("path", []))
+            if node is None or node["type"] != "split":
+                return {"id": request.get("id"), "error": {"code": "layout_not_found"}}
+            node["ratio"] = params["ratio"]
+            state.save()
+            kind = "layout_split_ratio_set"
+        elif method == "layout.export":
+            kind = "layout_export"
+        else:
+            return {"id": request.get("id"), "error": {"code": "method_not_allowed"}}
+        return {"id": request.get("id"), "result": {"type": kind, "layout": {
+            "workspace_id": tab["workspace_id"], "tab_id": tab_id, "root": tab["root"],
+        }}}
+    finally:
+        state.lock.close()
+
+
+if __name__ == "__main__":
+    if len(sys.argv) >= 2 and sys.argv[1] == "serve":
+        serve(sys.argv[2])
+    elif len(sys.argv) >= 2 and sys.argv[1] == "cli":
+        sys.exit(cli(sys.argv[2:]))
+    else:
+        sys.exit(2)