fleetd#222: fix currentUserGroup() to resolve the real primary group (fleetd#225)

The helper I copied from OpenCodeLauncherTest read the CWD's owning
group instead of the process's real primary group, so it silently
picked up whatever group owns the directory Maven was started from
(staff in a home checkout, wheel under /private/tmp on macOS) rather
than a group the operator is actually in. Replaced with the id -gn
based resolution that landed on #230 for the other two copies of this
helper, same shape and skip wording.

fleetd/src/main/java/dev/ltms/fleet/auth/MemberLifecycle.java

@@ -7,15 +7,43 @@ public interface MemberLifecycle {
 
     MemberLifecycle NONE = new MemberLifecycle() {
         @Override
-        public void acquired(MemberRole role, String profile, String terminal) {
+        public MemberRole acquired(MemberRole role, String profile, String terminal) {
+            return role; // no registry configured — nothing to bind against, so the request stands
         }
 
         @Override
         public void released(String terminal) {
         }
+
+        @Override
+        public void requireSlotFor(MemberRole role, String profile) {
+            // no registry configured — nothing to validate against, so nothing is refused
+        }
     };
 
-    void acquired(MemberRole role, String profile, String terminal);
+    /**
+     * Try to bind a newly spawned {@code terminal} into the role it was granted.
+     *
+     * @return the role this session actually holds: {@code role} unchanged for a role with no
+     *         live slot-binding semantics (dev, reviewer), or when the bind succeeded; a fallback
+     *         role — never {@code role} — when a slot-bound role (architect) could not be bound.
+     *         Callers must record THIS value on the session, never the requested {@code role}, so
+     *         a later roster read never reports a role the session does not hold (CB-619). In
+     *         normal operation this fallback should not happen once {@link #requireSlotFor} has
+     *         refused every unbindable spawn upfront — but a slot can still be lost between that
+     *         check and this call to a concurrent spawn racing for the same slot, so the honest
+     *         answer is still needed here too.
+     */
+    MemberRole acquired(MemberRole role, String profile, String terminal);
 
     void released(String terminal);
+
+    /**
+     * Refuse an acquire before anything spawns when {@code role} requires a live slot binding and
+     * no configured slot carries {@code profile} (CB-619 / fleetd #123). A no-op for a role with
+     * no slot-binding semantics.
+     *
+     * @throws IllegalArgumentException naming the role, the profile, and the pools that do carry it
+     */
+    void requireSlotFor(MemberRole role, String profile);
 }

fleetd/src/main/java/dev/ltms/fleet/auth/MemberRegistry.java

@@ -8,6 +8,7 @@ import org.slf4j.LoggerFactory;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 
@@ -206,19 +207,72 @@ public final class MemberRegistry implements MemberLifecycle {
      *
      * <p>The role check is lifecycle policy. {@link CallerResolver} repeats it when resolving a
      * binding, so a later lifecycle regression cannot turn a worker into an architect.
+     *
+     * <p>CB-619 / fleetd #123: the return value is the role this session actually holds, and the
+     * caller is required to record THAT — never the requested {@code role} — on the session. Before
+     * this fix the caller kept the requested role regardless of whether the bind below succeeded, so
+     * a demoted session's {@code GET /members} row still said {@code "architect"} while
+     * {@code fleet_whoami} (which reads the live binding, not the request) correctly said
+     * {@code "worker"} — three sources of truth that disagreed about one live member, silently.
      */
     @Override
-    public void acquired(MemberRole role, String profile, String terminal) {
+    public MemberRole acquired(MemberRole role, String profile, String terminal) {
         if (role != MemberRole.ARCHITECT || terminal == null || terminal.isBlank()) {
-            return;
+            return role;
         }
         // slotsFor preserves definition order, so duplicate-profile slots use the first free one.
         for (Entry entry : slotsFor(MemberRole.ARCHITECT).values()) {
             if (Objects.equals(profile, entry.profile()) && bind(entry.key(), terminal)) {
-                return;
+                return MemberRole.ARCHITECT;
             }
         }
-        log.info("member slot: no free architect slot for profile={}; session remains a worker", profile);
+        // fleetd #123: at least WARN — a role downgrade that the roster must now also reflect is
+        // not routine bookkeeping. requireSlotFor already refuses the config-gap case (no slot at
+        // all carries this profile) before a process ever spawns; reaching here means the config DID
+        // carry a matching slot but every one of them was already bound to a different terminal — a
+        // race this pre-spawn check cannot close on its own (see requireSlotFor's javadoc).
+        log.warn("member slot: no free architect slot for profile={} terminal={}; holding the session "
+                + "as {} instead of the architect it asked for — every configured slot for this "
+                + "profile is already bound to a different terminal", profile, terminal,
+                MemberRole.DEV.wireName());
+        return MemberRole.DEV;
+    }
+
+    /**
+     * CB-619 / fleetd #123: refuse an architect acquire before anything spawns when no configured
+     * slot carries {@code profile} — the config-gap case from the original defect report (a spawn
+     * asked for {@code role=architect, profile=sonnet}, and {@code fleet.architects} carried only
+     * {@code opus} and {@code sol}). A dev/reviewer acquire is always a no-op: those pools are
+     * placement candidates only (see {@code CompositePeerLauncher}), never a live identity binding,
+     * so there is nothing here to refuse — an explicit profile outside the pool for those roles is a
+     * documented operator override, not a defect.
+     *
+     * <p>This closes the config-gap case, not the live-capacity case: a profile that DOES carry a
+     * slot can still lose the race to a concurrent spawn between this check and the actual
+     * {@link #bind}, which is why {@link #acquired} must still answer honestly even after this
+     * check has passed.
+     */
+    @Override
+    public void requireSlotFor(MemberRole role, String profile) {
+        if (role != MemberRole.ARCHITECT) {
+            return;
+        }
+        boolean hasSlot = slotsFor(MemberRole.ARCHITECT).values().stream()
+                .anyMatch(e -> Objects.equals(profile, e.profile()));
+        if (hasSlot) {
+            return;
+        }
+        List<String> pools = slotsFor(MemberRole.ARCHITECT).values().stream()
+                .map(Entry::profile)
+                .distinct()
+                .toList();
+        throw new IllegalArgumentException(
+                "no " + role.wireName() + " slot for profile '" + profile + "' — an architect's "
+                        + "identity IS the slot it is bound to, so there is nothing to bind this "
+                        + "session's identity to. fleet." + role.configKey() + " carries profiles: "
+                        + (pools.isEmpty() ? "(none configured)" : String.join(", ", pools))
+                        + "; add profile '" + profile + "' there, or spawn " + role.wireName()
+                        + " on one of those profiles instead");
     }
 
     /** Unbind a released terminal using the compare-safe registry operation. */

fleetd/src/main/java/dev/ltms/fleet/member/ClaudeCodeLauncher.java

@@ -459,12 +459,83 @@ public final class ClaudeCodeLauncher extends HerdrPeerLauncher {
      * {@link OpenCodeLauncher#writeConfig} already uses for its charter file, since the process that
      * reads this file (the spawned peer) outlives this JVM call and there is no spawn-scoped teardown
      * hook to delete it synchronously.
+     *
+     * <p><b>fleetd #222.</b> {@code Files.createTempFile(prefix, suffix)} with no directory argument
+     * resolves against {@code java.io.tmpdir} — on macOS the per-user {@code $TMPDIR} under
+     * {@code /var/folders/...}, mode {@code 0700}, both resolved against FLEETD's own OS user. Under
+     * {@code memberHerdrSocket:} the member pane runs as a DIFFERENT OS user, so that user cannot even
+     * traverse the directory, let alone read the file — and since fleetd #220 the charter file is the
+     * ONLY delivery path for {@code --append-system-prompt-file}, always, not merely the fallback it
+     * used to be. A member handed a path it cannot read is not degraded, it is broken: see this
+     * method's refusal branch below.
+     *
+     * <p><b>Measured severity (fleetd #222 real-binary check, claude 2.1.258):</b> an unreadable
+     * {@code --append-system-prompt-file} is the LOUD failure, not the silent one. {@code claude}
+     * checks the file before touching auth or the network — invoked with a bogus API key against a
+     * {@code chmod 000} file, it printed {@code Error reading append system prompt file: EACCES:
+     * permission denied, open '<path>'} and exited 1 immediately (a nonexistent path gets {@code
+     * Error: Append system prompt file not found: <path>}, same exit code). So the pre-fix bug did
+     * NOT leave a charter-less member silently occupying a pane and never calling {@code
+     * fleet_reply} — it made the herdr pane exit immediately, which the CB-306 spawn-readiness gate
+     * (this launcher's {@code spawnReadyTimeoutMs} poll) would have surfaced as "did not reach
+     * injectable state", the same unexplained-timeout shape fleetd #220 already describes. Still a
+     * real defect (every claude-code member under {@code memberHerdrSocket} would have failed to
+     * spawn), but not the worse, undetectable failure mode.
+     *
+     * <ul>
+     *   <li>{@code memberHerdrSocket} ABSENT (today's only live mode): byte-identical to before this
+     *       fix — {@code Files.createTempFile("fleetd-role-charter-", ".md")} with no directory
+     *       argument, i.e. still resolved against {@code java.io.tmpdir}.</li>
+     *   <li>{@code memberHerdrSocket} PRESENT: a fresh per-spawn directory is created under {@code
+     *       worktreeRoot} (never {@code java.io.tmpdir}) holding just the charter file, then shared
+     *       read-only with {@code worktreeGroup} via {@link EnvAllowListScrub#shareWithGroup} — the
+     *       SAME mechanism fleetd #213 built for the ZDOTDIR scrub and fleetd #219 reused for {@link
+     *       OpenCodeLauncher#writeConfig}'s {@code opencode.json} directory, reused here rather than
+     *       duplicated a third time. A per-spawn subdirectory (not {@code worktreeRoot} itself) is the
+     *       unit {@code shareWithGroup} chmods, so this never touches permissions on anything else
+     *       under {@code worktreeRoot}.</li>
+     * </ul>
+     *
+     * <p><b>Follows fleetd #219's REFUSAL decision, not #213's degrade decision.</b> The ZDOTDIR
+     * scrub is a credential CONTROL — a degraded control (the CB-596 sentinel overlay) still has
+     * value, so #213 falls back rather than refusing. A charter is NOT a control, it is the member's
+     * TURN CONTRACT (the rule that ends every turn with {@code fleet_reply}). A member spawned with no
+     * charter is not degraded, it is broken: either claude-code exits on the unreadable
+     * {@code --append-system-prompt-file} path and the spawn dies at the readiness gate (loud), or it
+     * starts anyway with no charter and never calls {@code fleet_reply} — the sender silently gets
+     * nothing (silent). Neither outcome is worth trading for "spawn something." So a missing {@code
+     * worktreeRoot}/{@code worktreeGroup} under {@code memberHerdrSocket} refuses the spawn here,
+     * naming the missing key, exactly like {@link OpenCodeLauncher#configParentDir()}.
+     *
+     * @throws IllegalStateException when {@code memberHerdrSocket} is configured but {@code
+     *                                worktreeRoot} and/or {@code worktreeGroup} is not
      */
-    private static Path writeCharterFile(String charterText) {
+    private Path writeCharterFile(String charterText) {
         try {
-            Path file = Files.createTempFile("fleetd-role-charter-", ".md");
+            if (!memberHerdrSocketConfigured()) {
+                Path file = Files.createTempFile("fleetd-role-charter-", ".md");
+                Files.writeString(file, charterText);
+                file.toFile().deleteOnExit();
+                return file;
+            }
+            Path parentDir = memberScrubParentDir();
+            String group = memberGroup();
+            if (parentDir == null || group == null) {
+                throw new IllegalStateException("memberHerdrSocket is configured, so the role/reply "
+                        + "charter file (mounted via --append-system-prompt-file) must be placed where "
+                        + "the member's OS user can read it — worktreeRoot, shared via worktreeGroup — "
+                        + "but " + (parentDir == null ? "worktreeRoot" : "worktreeGroup") + " is not "
+                        + "configured. Refusing to spawn rather than hand the member a charter path it "
+                        + "cannot read: that member's turn contract (the fleet_reply rule) would never "
+                        + "reach it. Configure both worktreeRoot and worktreeGroup to enable claude-code "
+                        + "member spawns under memberHerdrSocket.");
+            }
+            Path dir = Files.createTempDirectory(parentDir, "fleetd-role-charter-");
+            dir.toFile().deleteOnExit();
+            Path file = dir.resolve("charter.md");
             Files.writeString(file, charterText);
             file.toFile().deleteOnExit();
+            EnvAllowListScrub.shareWithGroup(dir, group);
             return file;
         } catch (IOException e) {
             throw new UncheckedIOException("cannot write role charter temp file", e);

fleetd/src/main/java/dev/ltms/fleet/session/SessionManager.java

@@ -183,6 +183,13 @@ public final class SessionManager implements TurnListener {
                                  String sessionName, String resumeSessionId) {
         MemberRole memberRole = (role == null) ? MemberRole.DEV : role;
         requireResumeCapability(profile, resumeSessionId);
+        // CB-619 / fleetd #123: an explicit profile bypasses placement (CompositePeerLauncher only
+        // constrains an UNQUALIFIED spawn to the role's pool), so it is the one path that can ask
+        // for a role with no slot to bind it to. Refuse before anything spawns. A blank profile is
+        // left to placement, which already restricts an unqualified spawn to the role's pool.
+        if (profile != null && !profile.isBlank()) {
+            memberLifecycle.requireSlotFor(memberRole, profile);
+        }
         if (wt == null) {
             // CB-557: the role must ride on the SpawnRequest, not stay a local. The launcher needs it
             // to pick the profile out of that role's pool and to label the tab; a role kept only on
@@ -198,11 +205,15 @@ public final class SessionManager implements TurnListener {
             String resolvedProfile = resolveProfile(handle, profile);
             String cwd = launcher.effectiveCwd(new SpawnRequest(resolvedProfile, requestedCwd, callerCwd));
             long now = nowNanos.getAsLong();
+            // CB-619: bind (or fail to bind) BEFORE the session is recorded, and store whatever role
+            // this call actually returns — never the requested memberRole — so the session's role,
+            // what GET /members and fleet_list report, is never a lie about what this terminal holds.
+            MemberRole actualRole = memberLifecycle.acquired(memberRole, resolvedProfile, handle.terminalId());
             MemberSession session = new MemberSession(
                     handle.id(),
                     handle.terminalId(),
                     resolvedProfile,
-                    memberRole,
+                    actualRole,
                     cwd,
                     ownerTerminal,
                     now,
@@ -215,7 +226,6 @@ public final class SessionManager implements TurnListener {
                     handle.agentSessionId());
             registry.put(handle.id(), session);
             handles.put(handle.id(), handle);
-            memberLifecycle.acquired(session.role(), session.profile(), session.terminalId());
             log.debug("acquired session id={} terminal={} profile={} owner={}",
                     handle.id(), handle.terminalId(), session.profile(), session.ownerTerminal());
             notifyAcquired(session.terminalId());
@@ -509,11 +519,14 @@ public final class SessionManager implements TurnListener {
         String resolvedProfile = resolveProfile(handle, profile);
         String cwd = launcher.effectiveCwd(new SpawnRequest(resolvedProfile, path, callerCwd));
         long now = nowNanos.getAsLong();
+        // CB-619: see the no-worktree path above — bind before recording, and store the returned
+        // actual role, so this session's role is never a lie about what it actually holds.
+        MemberRole actualRole = memberLifecycle.acquired(memberRole, resolvedProfile, handle.terminalId());
         MemberSession session = new MemberSession(
                 handle.id(),
                 handle.terminalId(),
                 resolvedProfile,
-                memberRole,
+                actualRole,
                 cwd,
                 ownerTerminal,
                 now,
@@ -526,7 +539,6 @@ public final class SessionManager implements TurnListener {
                 handle.agentSessionId());
         registry.put(handle.id(), session);
         handles.put(handle.id(), handle);
-        memberLifecycle.acquired(session.role(), session.profile(), session.terminalId());
         log.debug("acquired worktree session id={} terminal={} profile={} branch={} path={}",
                 handle.id(), handle.terminalId(), session.profile(), session.branch(), session.worktree());
         notifyAcquired(session.terminalId());

fleetd/src/test/java/dev/ltms/fleet/mcp/FleetMcpTest.java

@@ -1,10 +1,13 @@
 package dev.ltms.fleet.mcp;
 
+import dev.ltms.fleet.auth.CallerResolver;
+import dev.ltms.fleet.auth.MemberRegistry;
 import dev.ltms.fleet.auth.Principal;
 import dev.ltms.fleet.config.FleetConfig;
 import dev.ltms.fleet.guard.SubscriptionGuard;
 import dev.ltms.fleet.herdr.AgentControl;
 import dev.ltms.fleet.herdr.FakeHerdr;
+import dev.ltms.fleet.herdr.PaneLocator;
 import dev.ltms.fleet.herdr.WorkspaceControl;
 import dev.ltms.fleet.inject.Injector;
 import dev.ltms.fleet.msg.MessageService;
@@ -1024,6 +1027,87 @@ class FleetMcpTest {
         assertTrue(textOf(res).contains("architect, dev, reviewer"), textOf(res));
     }
 
+    // ── CB-619 / fleetd #123: a spawn asking for a role its profile has no slot for must be
+    //    refused, never silently demoted with the roster still lying about it ───────────────────
+
+    /** Two profiles on one launcher, so a role's pool can name one and exclude the other. */
+    private static ClaudeCodeLauncher architectCapableLauncher(FakeHerdr h) {
+        FleetConfig.Profile opus = new FleetConfig.Profile(
+                "opus", "http://gx00.gw:8000", "coder", null, "FLEETD_WORKER_TOKEN", null,
+                "tab", "fleetd-workers", "worker: {profile} #{n}", null, null, null);
+        FleetConfig.Profile sonnet = new FleetConfig.Profile(
+                "sonnet", "http://gx00.gw:8000", "coder", null, "FLEETD_WORKER_TOKEN", null,
+                "tab", "fleetd-workers", "worker: {profile} #{n}", null, null, null);
+        return new ClaudeCodeLauncher(new AgentControl(h), new WorkspaceControl(h),
+                new SubscriptionGuard(Set.of("gx00.gw")), Map.of("opus", opus, "sonnet", sonnet),
+                "sonnet", _ -> "tok");
+    }
+
+    /** {@code fleet.architects} carries only {@code opus} — {@code sonnet} has no matching slot. */
+    private static MemberRegistry architectRegistry() {
+        return new MemberRegistry(new FleetConfig.Fleet(Map.of(),
+                Map.of("opus", new FleetConfig.Slot("opus")), Map.of(), Map.of(), null));
+    }
+
+    /**
+     * The literal defect (fleetd #123): {@code role=architect, profile=sonnet}, where
+     * {@code fleet.architects} carries only {@code opus}. Drives the real path —
+     * {@link FleetMcp#spawn} calls {@link SessionManager#acquire}, which must refuse before ever
+     * reaching the real {@link ClaudeCodeLauncher} — never {@link MemberRegistry#bind} called
+     * directly, which would walk around the gate under test.
+     */
+    @Test
+    void spawnRefusesAnArchitectWithNoMatchingSlotAndNeverTouchesTheLauncher() {
+        FakeHerdr h = new FakeHerdr();
+        SessionManager sessions = new SessionManager(architectCapableLauncher(h));
+        sessions.setMemberLifecycle(architectRegistry());
+
+        McpSchema.CallToolResult res = FleetMcp.spawn(sessions, "sonnet", "architect",
+                null, null, null, null, null, null);
+
+        assertEquals(Boolean.TRUE, res.isError(), textOf(res));
+        String msg = textOf(res);
+        assertTrue(msg.contains("architect"), "names the role asked for: " + msg);
+        assertTrue(msg.contains("sonnet"), "names the profile: " + msg);
+        assertTrue(msg.contains("opus"), "names the pool that does carry the role: " + msg);
+        assertTrue(sessions.roster().isEmpty(), "a refused spawn must register no session");
+        assertTrue(h.calls.stream().noneMatch(c -> c.method().equals("agent.start")),
+                "a refused spawn must never reach the launcher — no process should ever start");
+    }
+
+    /**
+     * Positive control / parity check: when the profile DOES carry a slot, the spawn succeeds, and
+     * {@code GET /members} ({@link FleetMcp#listFleet}) and {@code fleet_whoami}
+     * ({@link FleetMcp#whoami}) — resolved through the SAME live {@link MemberRegistry} binding via
+     * a real {@link CallerResolver}, exactly as the daemon resolves a real MCP caller — must never
+     * disagree about this one live member's role.
+     */
+    @Test
+    void rosterAndWhoamiAgreeOnceTheArchitectSlotBinds() {
+        FakeHerdr h = new FakeHerdr();
+        // Pin the spawn onto the one pane FakeHerdr's canned pane.process_info maps to WORKER_PID,
+        // so a CallerResolver can resolve THIS session's own terminal, not a fixture double.
+        h.pinNextStarts(1, "term_a", "w2:p7");
+        SessionManager sessions = new SessionManager(architectCapableLauncher(h));
+        MemberRegistry members = architectRegistry();
+        sessions.setMemberLifecycle(members);
+
+        McpSchema.CallToolResult spawnRes = FleetMcp.spawn(sessions, "opus", "architect",
+                null, null, null, null, null, null);
+        assertNotEquals(Boolean.TRUE, spawnRes.isError(), textOf(spawnRes));
+        assertTrue(textOf(spawnRes).contains("\"role\":\"architect\""), textOf(spawnRes));
+
+        String roster = textOf(FleetMcp.listFleet(architectCapableLauncher(h), sessions, Map.of(), ""));
+        assertTrue(roster.contains("\"role\":\"architect\""), "GET /members: " + roster);
+
+        ConnectionIdentity identity = new ConnectionIdentity(new PaneLocator(h), _ -> FakeHerdr.WORKER_PID);
+        CallerResolver resolver = CallerResolver.withLeadsAndMembers(identity, false, null, Map::of, members);
+        Principal caller = resolver.resolve("127.0.0.1", 42, null);
+        assertTrue(caller.isArchitect(), "fleet_whoami's own resolver must agree the terminal is bound");
+        String whoami = textOf(FleetMcp.whoami(caller, sessions));
+        assertTrue(whoami.contains("\"role\":\"architect\""), "fleet_whoami: " + whoami);
+    }
+
     // ── CB-584: fleet_spawn accepts sessionName/resumeSessionId; roster shows agentSessionId ──
 
     @Test

fleetd/src/test/java/dev/ltms/fleet/member/ClaudeCodeLauncherTest.java

@@ -20,8 +20,10 @@ import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 import org.slf4j.LoggerFactory;
 
+import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.attribute.PosixFilePermissions;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -31,6 +33,7 @@ import java.util.function.Function;
 import java.util.function.Supplier;
 
 import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
 /** The step-4 launch-flag injection: the bridge MCP + reply charter are appended to the argv. */
 class ClaudeCodeLauncherTest {
@@ -1751,4 +1754,184 @@ class ClaudeCodeLauncherTest {
 
         assertEquals(List.of("dev: sonnet #1", "[sonnet] dev 2"), tabLabels(herdr));
     }
+
+    // ── fleetd #222: the charter file must not land under fleetd's own java.io.tmpdir when the ──
+    // ── member pane runs as a different OS user ─────────────────────────────────────────────────
+
+    /** A profile that mounts the bridge MCP (so a reply charter is always generated). */
+    private static FleetConfig.Profile charterCfg() {
+        return new FleetConfig.Profile(
+                "ltms-local", "http://gx00.gw:8000", "coder", null, "FLEETD_WORKER_TOKEN",
+                List.of("claude"), "tab", "fleetd-workers", "worker: {profile} #{n}",
+                "http://127.0.0.1:8765/mcp", null, null);
+    }
+
+    /** A config with {@code memberHerdrSocket:} set, and optionally {@code worktreeRoot:}/{@code worktreeGroup:}. */
+    private static FleetConfig configWithMemberHerdrSocket(String worktreeRoot, String worktreeGroup) {
+        return new FleetConfig(
+                null,                    // bind
+                null,                    // herdrSocket
+                "/tmp/other-user.sock",  // memberHerdrSocket
+                Map.of(),                // profiles
+                null,                    // guard
+                worktreeRoot,            // worktreeRoot
+                null,                    // lifecycle
+                null,                    // spawnReadyTimeoutMs
+                null,                    // spawnReadyPollMs
+                null,                    // broker
+                null,                    // primary
+                null,                    // fleet
+                null,                    // leadHeartbeat
+                null,                    // health
+                null,                    // placement
+                null,                    // auth
+                null,                    // configReload
+                null,                    // quarantineCooldownSeconds
+                null,                    // memberCredentials
+                null,                    // coordinator
+                worktreeGroup,           // worktreeGroup
+                null                     // memberLoginShell
+        ).withDefaults();
+    }
+
+    private static ClaudeCodeLauncher serviceWithConfig(FakeHerdr herdr, FleetConfig.Profile cfg,
+                                                          Supplier<FleetConfig> config) {
+        return new ClaudeCodeLauncher(new AgentControl(herdr), new WorkspaceControl(herdr),
+                new SubscriptionGuard(Set.of("gx00.gw")), Map.of(cfg.profile(), cfg), cfg.profile(), _ -> null,
+                0, System::currentTimeMillis, () -> { }, null, null, null, config);
+    }
+
+    /**
+     * The current process's REAL primary group — resolved via {@code id -gn}, never by reading a
+     * directory's owning group (fleetd #225). Those two coincide only by accident: a directory's
+     * group is whichever group happened to own the path Maven was started from — {@code staff} in
+     * a home checkout, {@code wheel} under {@code /private/tmp} on macOS — and the fix-up this test
+     * exercises then fails for real when the operator is not a member of that borrowed group,
+     * exactly the case {@code assumeTrue(view != null, ...)} never covered (it only detects a
+     * filesystem with no POSIX groups at all, not a resolvable-but-wrong one). Skips (never fails)
+     * when {@code id} is unavailable or its primary group cannot be resolved on this host.
+     */
+    private static String currentUserGroup() {
+        String out;
+        boolean ok;
+        try {
+            Process p = new ProcessBuilder("id", "-gn").redirectErrorStream(true).start();
+            try (java.io.BufferedReader r = new java.io.BufferedReader(
+                    new java.io.InputStreamReader(p.getInputStream(), java.nio.charset.StandardCharsets.UTF_8))) {
+                out = r.lines().collect(java.util.stream.Collectors.joining("\n")).trim();
+            }
+            ok = p.waitFor(5, java.util.concurrent.TimeUnit.SECONDS) && p.exitValue() == 0 && !out.isBlank();
+        } catch (IOException e) {
+            out = null;
+            ok = false;
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            out = null;
+            ok = false;
+        }
+        assumeTrue(ok, "cannot resolve this process's real primary group via `id -gn` on this host "
+                + "— skipping a POSIX-group-dependent test rather than failing it");
+        return out;
+    }
+
+    /**
+     * fleetd #222 acceptance criterion 1: with {@code memberHerdrSocket} configured and both
+     * {@code worktreeRoot}/{@code worktreeGroup} set, the charter file lives in a fresh per-spawn
+     * directory under {@code worktreeRoot} — NEVER under {@code java.io.tmpdir} (fleetd's own 0700
+     * temp dir, unreadable by the member's different OS user) — and that directory is shared
+     * read-only with the group via the SAME mechanism (fleetd #213/#219's {@link
+     * EnvAllowListScrub#shareWithGroup}) the ZDOTDIR scrub and the opencode config directory use.
+     */
+    @Test
+    void memberHerdrSocketWithWorktreeRootAndGroupPutsCharterUnderWorktreeRootAndSharesIt(
+            @TempDir Path worktreeRoot) throws Exception {
+        String group = currentUserGroup();
+        FakeHerdr herdr = new FakeHerdr();
+        serviceWithConfig(herdr, charterCfg(),
+                () -> configWithMemberHerdrSocket(worktreeRoot.toString(), group)).spawn();
+
+        List<String> args = spawnedArgs(herdr);
+        int fileFlag = args.indexOf("--append-system-prompt-file");
+        assertTrue(fileFlag >= 0, "the charter is still mounted via file: " + args);
+        Path charterFile = Path.of(args.get(fileFlag + 1));
+        Path dir = charterFile.getParent();
+
+        // NOTE: JUnit's own @TempDir provider places worktreeRoot itself under java.io.tmpdir on this
+        // host, so "not under java.io.tmpdir" is not a meaningful assertion here (it would hold by
+        // accident of the fixture, not by anything this method does). What this fix actually promises
+        // is that the directory is created UNDER worktreeRoot specifically — never resolved from the
+        // no-argument Files.createTempFile default (java.io.tmpdir) the pre-fix code always used — so
+        // that is the assertion: the parent is exactly worktreeRoot, whatever directory JUnit gave it.
+        assertEquals(worktreeRoot.toAbsolutePath().normalize(), dir.getParent(),
+                "the generated directory's parent must be worktreeRoot, not java.io.tmpdir — got "
+                        + "parent " + dir.getParent());
+
+        assertEquals("rwxr-x---", PosixFilePermissions.toString(Files.getPosixFilePermissions(dir)),
+                "the directory must be group-traversable+readable, owner-only writable");
+        assertEquals("rw-r-----", PosixFilePermissions.toString(Files.getPosixFilePermissions(charterFile)),
+                "the charter file must be group-readable, never group-writable");
+        assertTrue(Files.readString(charterFile).contains("fleet_reply"),
+                "the charter content itself is unaffected by where it is written");
+    }
+
+    /**
+     * fleetd #222 acceptance criterion 2: with {@code memberHerdrSocket} configured but NEITHER
+     * {@code worktreeRoot} nor {@code worktreeGroup} set, the launcher must refuse the spawn rather
+     * than hand the member a {@code --append-system-prompt-file} path under {@code java.io.tmpdir}
+     * it cannot read — the member's whole turn contract would never reach it.
+     */
+    @Test
+    void memberHerdrSocketWithoutWorktreeRootOrGroupRefusesTheSpawn() {
+        FakeHerdr herdr = new FakeHerdr();
+        ClaudeCodeLauncher launcher = serviceWithConfig(herdr, charterCfg(),
+                () -> configWithMemberHerdrSocket(null, null));
+
+        IllegalStateException ex = assertThrows(IllegalStateException.class, launcher::spawn,
+                "a missing worktreeRoot/worktreeGroup must refuse the spawn, not write an unreadable charter");
+        assertTrue(ex.getMessage().contains("worktreeRoot"),
+                "the refusal must name the missing config key — got: " + ex.getMessage());
+        assertFalse(herdr.called("agent.start"),
+                "the spawn must be refused BEFORE the member is ever started — got calls: " + herdr.calls);
+    }
+
+    /**
+     * fleetd #222 acceptance criterion 2 (the other missing half): {@code worktreeRoot} set but
+     * {@code worktreeGroup} missing must ALSO refuse — either one alone is not enough to guarantee
+     * the member's OS user can read the charter file.
+     */
+    @Test
+    void memberHerdrSocketWithWorktreeRootButNoGroupRefusesTheSpawn(@TempDir Path worktreeRoot) {
+        FakeHerdr herdr = new FakeHerdr();
+        ClaudeCodeLauncher launcher = serviceWithConfig(herdr, charterCfg(),
+                () -> configWithMemberHerdrSocket(worktreeRoot.toString(), null));
+
+        IllegalStateException ex = assertThrows(IllegalStateException.class, launcher::spawn);
+        assertTrue(ex.getMessage().contains("worktreeGroup"),
+                "worktreeRoot alone is not enough — got: " + ex.getMessage());
+    }
+
+    /**
+     * fleetd #222 acceptance criterion 3: with {@code memberHerdrSocket} ABSENT — even when a live,
+     * non-null {@code config} supplier is threaded through (not merely {@code config == null}, which
+     * every other test in this file already exercises) — the charter file must still be created
+     * directly under {@code java.io.tmpdir} via the same no-directory-argument
+     * {@code Files.createTempFile} call as before this fix, byte-identical to today.
+     */
+    @Test
+    void memberHerdrSocketAbsentStaysUnderJavaIoTmpdirEvenWithALiveConfigSupplier() throws Exception {
+        FakeHerdr herdr = new FakeHerdr();
+        FleetConfig config = new FleetConfig(null, null, null, Map.of(), null, null, null, null, null,
+                null, null, null, null, null, null, null, null, null, null, null, null, null).withDefaults();
+        serviceWithConfig(herdr, charterCfg(), () -> config).spawn();
+
+        List<String> args = spawnedArgs(herdr);
+        int fileFlag = args.indexOf("--append-system-prompt-file");
+        assertTrue(fileFlag >= 0);
+        Path charterFile = Path.of(args.get(fileFlag + 1));
+        assertTrue(charterFile.startsWith(Path.of(System.getProperty("java.io.tmpdir"))),
+                "with memberHerdrSocket absent, the charter file must still land directly under "
+                        + "java.io.tmpdir, unchanged from before this fix");
+        assertTrue(charterFile.getFileName().toString().startsWith("fleetd-role-charter-"),
+                "same file-naming scheme as before this fix (no wrapping directory): " + charterFile);
+    }
 }

fleetd/src/test/java/dev/ltms/fleet/session/SessionManagerTest.java

@@ -4,6 +4,7 @@ import ch.qos.logback.classic.Level;
 import ch.qos.logback.classic.LoggerContext;
 import ch.qos.logback.classic.spi.ILoggingEvent;
 import ch.qos.logback.core.read.ListAppender;
+import dev.ltms.fleet.auth.MemberRegistry;
 import dev.ltms.fleet.config.FleetConfig;
 import dev.ltms.fleet.guard.SubscriptionGuard;
 import dev.ltms.fleet.herdr.AgentControl;
@@ -333,6 +334,57 @@ class SessionManagerTest {
         }
     }
 
+    /**
+     * CB-619 / fleetd #123: {@code requireSlotFor} closes the config-gap case (no slot at all
+     * carries the profile) before anything spawns, but a profile that DOES carry a slot can still
+     * lose the bind to a concurrent spawn racing for the same slot. This drives that residual case
+     * through the REAL path — {@link SessionManager#acquire} against the real {@link
+     * dev.ltms.fleet.member.ClaudeCodeLauncher} and {@link FakeHerdr} — never {@link
+     * dev.ltms.fleet.auth.MemberRegistry#bind} directly for the session under test (only the
+     * precondition uses it, to occupy the slot before the real spawn happens). The session that
+     * loses the race must be held as a plain {@code dev}, never left claiming {@code architect} in
+     * the roster, and the daemon log must say so at WARN.
+     */
+    @Test
+    void aSecondArchitectOnAnAlreadyBoundProfileIsHeldAsDevNotArchitectAndWarnsLoudly() {
+        LoggerContext ctx = (LoggerContext) LoggerFactory.getILoggerFactory();
+        ch.qos.logback.classic.Logger registryLog = (ch.qos.logback.classic.Logger)
+                LoggerFactory.getLogger(MemberRegistry.class);
+        ListAppender<ILoggingEvent> appender = new ListAppender<>();
+        appender.setContext(ctx);
+        appender.start();
+        registryLog.addAppender(appender);
+        registryLog.setLevel(Level.WARN);
+        try {
+            FakeHerdr herdr = new FakeHerdr();
+            SessionManager sessions = sessionManager(herdr);
+            MemberRegistry members = new MemberRegistry(
+                    new FleetConfig.Fleet(Map.of(), Map.of("opus", new FleetConfig.Slot("ltms-local")),
+                            Map.of(), Map.of(), null));
+            assertTrue(members.bind("architect:opus", "term_already_bound"),
+                    "precondition: occupy the sole architect slot before the real spawn under test");
+            sessions.setMemberLifecycle(members);
+
+            MemberSession session = sessions.acquire("ltms-local", MemberRole.ARCHITECT, null,
+                    "/caller", "term_primary", null);
+
+            assertEquals(MemberRole.DEV, session.role(),
+                    "the slot is taken, so this session must be held as a plain member, never a lie");
+            assertEquals("dev", SessionManager.rosterView(session, null).get("role"),
+                    "the roster must report what this session actually holds, not what it asked for");
+
+            String warn = appender.list.stream()
+                    .filter(e -> e.getLevel().equals(Level.WARN))
+                    .map(ILoggingEvent::getFormattedMessage)
+                    .findFirst()
+                    .orElse("no slot-exhaustion WARN logged");
+            assertTrue(warn.contains("ltms-local"), "the log names the profile: " + warn);
+            assertTrue(warn.contains(session.terminalId()), "the log names the terminal: " + warn);
+        } finally {
+            registryLog.detachAppender(appender);
+        }
+    }
+
     @Test
     void rosterReflectsAcquiredMinusReleased() {
         FakeHerdr herdr = new FakeHerdr();