CB-105: connection-based MCP caller identity (peer PID → herdr pane)

Resolve who is calling an MCP tool from the connection, not a spoofable argument (per docs/MCP-Contract.md). ConnectionIdentity ties the loopback peer PID (LsofPeerPidLookup) to a herdr pane (PaneLocator via pane.list/pane.process_info) → the caller's terminal_id; a caller owning no pane is the primary. bridge_reply now takes only content and resolves the worker from the connection (no sessionId). Live-verified: real PID→pane (contract test), and a non-pane MCP caller correctly gets a workers-only error. Single-host; the token path stays the split-host fallback. 58 tests green, IDE-clean.

bridged/src/test/java/dev/ltms/bridged/herdr/FakeHerdr.java

@@ -16,6 +16,9 @@ public final class FakeHerdr implements HerdrClient {
     public record Call(String method, Object params) {
     }
 
+    /** The foreground PID of the one agent pane (term_a) in the canned {@code pane.process_info}. */
+    public static final long WORKER_PID = 4242;
+
     private final ObjectMapper mapper = new ObjectMapper();
     public final List<Call> calls = new ArrayList<>();
     private boolean healthy = true;
@@ -142,6 +145,21 @@ public final class FakeHerdr implements HerdrClient {
                 case "pane.get" -> mapper.readTree("""
                         {"type":"pane_info","pane":{"pane_id":"w9:pW","workspace_id":"w9",
                           "tab_id":"w9:t2","agent_status":"idle"}}""");
+                case "pane.list" -> mapper.readTree("""
+                        {"type":"pane_list","panes":[
+                          {"pane_id":"w2:p7","terminal_id":"term_a","workspace_id":"w2","tab_id":"w2:t7","agent":"claude"},
+                          {"pane_id":"w2:p9","terminal_id":"term_shell","workspace_id":"w2","tab_id":"w2:t8"}]}""");
+                case "pane.process_info" -> {
+                    Object paneId = params instanceof java.util.Map<?, ?> m ? m.get("pane_id") : null;
+                    yield "w2:p7".equals(paneId)
+                            ? mapper.readTree(("""
+                                {"type":"pane_process_info","process_info":{"pane_id":"w2:p7","shell_pid":%d,
+                                  "foreground_processes":[{"pid":%d,"name":"node","argv0":"claude"}]}}""")
+                                    .formatted(WORKER_PID, WORKER_PID))
+                            : mapper.readTree("""
+                                {"type":"pane_process_info","process_info":{"pane_id":"w2:p9","shell_pid":9001,
+                                  "foreground_processes":[]}}""");
+                }
                 case "pane.close" -> {
                     if (paneCloseErrorCode != null) {
                         throw new HerdrException("herdr error [" + paneCloseErrorCode + "]: pane.close failed",

bridged/src/test/java/dev/ltms/bridged/herdr/PaneLocatorContractTest.java

@@ -0,0 +1,43 @@
+package dev.ltms.bridged.herdr;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+import java.nio.file.Files;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+
+/**
+ * Contract test for the herdr half of connection-based identity against a REAL herdr: spawn a
+ * harmless probe, read its actual {@code shell_pid} from {@code pane.process_info}, and confirm
+ * {@link PaneLocator} resolves that PID back to the probe's own {@code terminal_id}.
+ *
+ * <p>Tagged {@code contract}; run with {@code mvn test -Pcontract}.
+ */
+@Tag("contract")
+class PaneLocatorContractTest {
+
+    @Test
+    void resolvesTheTerminalOwningARealProcessPid() throws Exception {
+        assumeTrue(Files.exists(UnixSocketHerdrClient.defaultSocketPath()), "no herdr socket — skipping");
+        try (UnixSocketHerdrClient herdr = UnixSocketHerdrClient.connect()) {
+            AgentControl agents = new AgentControl(herdr);
+            Agent probe = agents.start("__pidprobe__", List.of("bash", "-c", "sleep 20"), Map.of());
+            try {
+                JsonNode info = herdr.call("pane.process_info", Map.of("pane_id", probe.paneId()))
+                        .path("process_info");
+                long shellPid = info.path("shell_pid").asLong(-1);
+                assertTrue(shellPid > 0, "probe pane should report a shell pid");
+
+                assertEquals(probe.terminalId(), new PaneLocator(herdr).terminalForPid(shellPid),
+                        "a real PID must resolve back to its own pane's terminal_id");
+            } finally {
+                agents.close(probe.paneId());
+            }
+        }
+    }
+}

bridged/src/test/java/dev/ltms/bridged/herdr/PaneLocatorTest.java

@@ -0,0 +1,27 @@
+package dev.ltms.bridged.herdr;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/** Unit tests for PID → pane resolution (the herdr half of connection-based MCP identity). */
+class PaneLocatorTest {
+
+    private final PaneLocator loc = new PaneLocator(new FakeHerdr());
+
+    @Test
+    void resolvesTerminalForAForegroundPid() {
+        assertEquals("term_a", loc.terminalForPid(FakeHerdr.WORKER_PID));
+    }
+
+    @Test
+    void nullForAPidInNoPane() {
+        assertNull(loc.terminalForPid(999_999));
+    }
+
+    @Test
+    void nullForNonPositivePid() {
+        assertNull(loc.terminalForPid(0));
+        assertNull(loc.terminalForPid(-1));
+    }
+}

bridged/src/test/java/dev/ltms/bridged/mcp/ConnectionIdentityTest.java

@@ -0,0 +1,34 @@
+package dev.ltms.bridged.mcp;
+
+import dev.ltms.bridged.herdr.FakeHerdr;
+import dev.ltms.bridged.herdr.PaneLocator;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/** Connection → caller-identity resolution, with the OS peer-PID lookup faked. */
+class ConnectionIdentityTest {
+
+    private final FakeHerdr herdr = new FakeHerdr();
+
+    private ConnectionIdentity with(PeerPidLookup pids) {
+        return new ConnectionIdentity(new PaneLocator(herdr), pids);
+    }
+
+    @Test
+    void resolvesWorkerFromLoopbackPeerPid() {
+        assertEquals("term_a", with(_ -> FakeHerdr.WORKER_PID).callerTerminal("127.0.0.1", 55555));
+    }
+
+    @Test
+    void nullForOffHostCaller() {
+        // A non-loopback peer can't be an on-host worker → treat as primary/unknown.
+        assertNull(with(_ -> FakeHerdr.WORKER_PID).callerTerminal("10.0.0.9", 55555));
+    }
+
+    @Test
+    void nullWhenPidOwnsNoPane() {
+        // e.g. the primary — its PID maps to no worker pane.
+        assertNull(with(_ -> 999_999).callerTerminal("127.0.0.1", 55555));
+    }
+}