@vibevibes/mcp 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,21 +1,112 @@
 /**
- * vibevibes-mcp — standalone MCP server for joining vibevibes experiences.
+ * vibevibes-mcp — MCP server for agent participation in vibevibes experiences.
  *
- * Works with both local dev servers and remote shared tunnels.
- * Identity is read from the state file written by setup.js — MCP never calls /join.
+ * The `connect` tool is the single entry point: it joins the server, writes
+ * the state file (for the stop hook to poll), and returns room info.
  *
- * Usage:
- *   npx vibevibes-mcp                          # defaults to http://localhost:4321
- *   npx vibevibes-mcp https://xyz.trycloudflare.com  # join a shared room
- *   VIBEVIBES_SERVER_URL=https://... npx vibevibes-mcp
- *
- * 11 tools: connect, act, stream, spawn_room, list_rooms, list_experiences, room_config_schema, memory, screenshot, blob_set, blob_get
+ * 4 tools: connect, act, look, disconnect
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { readFileSync, existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, readdirSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn, spawnSync } from "node:child_process";
+/** Extract error message from unknown catch value. */
+function toErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+// ── Server auto-start ──────────────────────────────────────
+let serverStarted = false;
+/**
+ * Check if the server is reachable. If not, start it in a child process.
+ * The server loads the experience from the given project root.
+ */
+async function ensureServerRunning(projectRoot) {
+    if (serverStarted)
+        return;
+    // Check if server is already running
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 2000);
+        const res = await fetch(`${SERVER_URL}/state`, { signal: controller.signal });
+        clearTimeout(timer);
+        if (res.ok) {
+            serverStarted = true;
+            return;
+        }
+    }
+    catch {
+        // Server not running — start it
+    }
+    // Find the server entry point (in mcp/dist/ or mcp/src/)
+    const serverScript = resolve(MCP_ROOT, "dist/server.js");
+    const serverTs = resolve(MCP_ROOT, "src/server.ts");
+    // Start server as a child process using a small bootstrap script
+    const bootstrapCode = `
+    import("${serverScript.replace(/\\/g, "/")}").then(m => {
+      m.startServer({ projectRoot: "${projectRoot.replace(/\\/g, "/")}" });
+    }).catch(e => {
+      // Fallback: try tsx for .ts source
+      import("${serverTs.replace(/\\/g, "/")}").then(m => {
+        m.startServer({ projectRoot: "${projectRoot.replace(/\\/g, "/")}" });
+      }).catch(e2 => {
+        console.error("Failed to start server:", e2.message);
+        process.exit(1);
+      });
+    });
+  `;
+    const child = spawn(process.execPath, ["--input-type=module", "-e", bootstrapCode], {
+        stdio: ["pipe", "pipe", "pipe"],
+        detached: true,
+        env: { ...process.env, PORT: new URL(SERVER_URL).port || "4321" },
+    });
+    child.unref();
+    // Store child for cleanup
+    serverChild = child;
+    child.stderr?.on("data", (chunk) => {
+        const msg = chunk.toString().trim();
+        if (msg)
+            console.error(`[server] ${msg}`);
+    });
+    // Wait for server to become available (up to 15 seconds)
+    const deadline = Date.now() + 15000;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 500));
+        try {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 1500);
+            const res = await fetch(`${SERVER_URL}/state`, { signal: controller.signal });
+            clearTimeout(timer);
+            if (res.ok) {
+                serverStarted = true;
+                return;
+            }
+        }
+        catch {
+            // Keep waiting
+        }
+    }
+    throw new Error(`Server failed to start within 15 seconds at ${SERVER_URL}`);
+}
+let serverChild = null;
+// Cleanup server on exit
+process.on("exit", () => { if (serverChild)
+    try {
+        serverChild.kill();
+    }
+    catch { } });
+process.on("SIGINT", () => { if (serverChild)
+    try {
+        serverChild.kill();
+    }
+    catch { } process.exit(0); });
+process.on("SIGTERM", () => { if (serverChild)
+    try {
+        serverChild.kill();
+    }
+    catch { } process.exit(0); });
 // Resolve server URL: CLI arg > env var > localhost default
 const RAW_SERVER_URL = process.argv[2] ||
     process.env.VIBEVIBES_SERVER_URL ||
@@ -25,27 +116,118 @@ const parsedUrl = new URL(RAW_SERVER_URL);
 const ROOM_TOKEN = parsedUrl.searchParams.get("token");
 // Strip the token param from the base URL so it isn't duplicated in request paths
 parsedUrl.searchParams.delete("token");
-const SERVER_URL = parsedUrl.toString().replace(/\/$/, ""); // remove trailing slash
-// ── State ──────────────────────────────────────────────────
+let SERVER_URL = parsedUrl.toString().replace(/\/$/, ""); // remove trailing slash
+/** All active connections in this MCP session. Multiple subagents can each connect independently. */
+const connections = new Map(); // actorId → slot
+/** The most recently connected identity — used as default when only one connection exists. */
 let currentActorId = null;
 let currentOwner = null;
-const STATE_FILE = resolve(process.cwd(), ".claude/vibevibes-agent.local.json");
+/** Resolve the effective identity for a tool call. If actorId is provided, use that connection.
+ *  If only one connection exists, use it. If multiple exist and no actorId given, error. */
+function resolveIdentity(actorId) {
+    if (actorId) {
+        const slot = connections.get(actorId);
+        if (!slot)
+            throw new Error(`Unknown actorId '${actorId}'. Connected actors: ${[...connections.keys()].join(", ") || "none"}`);
+        return slot;
+    }
+    if (connections.size === 1) {
+        return connections.values().next().value;
+    }
+    if (connections.size > 1) {
+        throw new Error(`Multiple agents connected. You MUST pass actorId to identify yourself.\n` +
+            `Connected actors: ${[...connections.keys()].join(", ")}`);
+    }
+    // No connections — fall back to currentActorId for backward compat (e.g. loadIdentity)
+    if (currentActorId && currentOwner) {
+        return { actorId: currentActorId, owner: currentOwner };
+    }
+    throw new Error("Not connected. Call the connect tool first.");
+}
+// Derive paths from this module's location.
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// mcp/src/ or mcp/dist/ → MCP package root is ..
+const MCP_ROOT = resolve(__dirname, "..");
+// Project root = cwd (where the experience lives)
+const PROJECT_ROOT = process.cwd();
+const AGENTS_DIR = resolve(PROJECT_ROOT, ".claude/vibevibes-agents");
+const SETTINGS_PATH = resolve(PROJECT_ROOT, ".claude/settings.json");
+// ── Dynamic Hook Registration ─────────────────────────────────────
 /**
- * Load identity from the state file written by setup.js.
- * Setup.js is the sole identity authority — MCP never calls /join.
+ * Ensure the Stop hook is registered in .claude/settings.json.
+ * Called on connect. Idempotent — skips if already present.
+ * Uses absolute path because hook CWD may differ from project root.
  */
-function loadIdentity() {
-    if (!existsSync(STATE_FILE)) {
-        throw new Error("Not in agent mode. Use /vibevibes-join first.");
+function ensureStopHook() {
+    try {
+        const hookScript = resolve(MCP_ROOT, "hooks/stop-hook.js");
+        const command = `node "${hookScript}"`;
+        let settings = {};
+        if (existsSync(SETTINGS_PATH)) {
+            settings = JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+        }
+        const hooks = (settings.hooks ?? {});
+        const stopHooks = (hooks.Stop ?? []);
+        const alreadyRegistered = stopHooks.some((entry) => entry.hooks?.some((h) => h.type === "command" && h.command === command));
+        if (alreadyRegistered)
+            return;
+        stopHooks.push({
+            hooks: [{ type: "command", command, timeout: 60 }],
+        });
+        hooks.Stop = stopHooks;
+        settings.hooks = hooks;
+        // Ensure directory exists
+        const settingsDir = dirname(SETTINGS_PATH);
+        if (!existsSync(settingsDir))
+            mkdirSync(settingsDir, { recursive: true });
+        writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
     }
-    const raw = readFileSync(STATE_FILE, "utf-8");
-    const state = JSON.parse(raw);
-    if (!state.active || !state.actorId) {
-        throw new Error("Agent loop not active. Use /vibevibes-join first.");
+    catch {
+        // Hook registration is best-effort
     }
-    currentActorId = state.actorId;
-    currentOwner = state.owner || state.actorId.split("-")[0];
-    return { actorId: state.actorId, serverUrl: state.serverUrl, owner: currentOwner };
+}
+function removeStopHook() {
+    try {
+        if (!existsSync(SETTINGS_PATH))
+            return;
+        const hookScript = resolve(MCP_ROOT, "hooks/stop-hook.js");
+        const command = `node "${hookScript}"`;
+        const settings = JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+        const hooks = (settings.hooks ?? {});
+        const stopHooks = (hooks.Stop ?? []);
+        hooks.Stop = stopHooks.filter((entry) => !entry.hooks?.some((h) => h.type === "command" && h.command === command));
+        settings.hooks = hooks;
+        writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+    }
+    catch {
+        // Best-effort cleanup
+    }
+}
+function loadIdentity() {
+    if (currentOwner && currentActorId) {
+        return { actorId: currentActorId, serverUrl: SERVER_URL, owner: currentOwner };
+    }
+    throw new Error("Not connected. Call the connect tool first.");
+}
+// ── Name Generator ─────────────────────────────────────────
+const ADJECTIVES = [
+    "swift", "brave", "calm", "bold", "keen",
+    "wild", "sly", "warm", "cool", "bright",
+    "quick", "sharp", "wise", "kind", "fair",
+    "proud", "free", "dark", "lost", "glad",
+];
+const ANIMALS = [
+    "fox", "wolf", "bear", "hawk", "lynx",
+    "deer", "owl", "crow", "hare", "pike",
+    "dove", "wren", "newt", "moth", "orca",
+    "lion", "toad", "crab", "swan", "mole",
+];
+function generateName() {
+    const adj = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
+    const animal = ANIMALS[Math.floor(Math.random() * ANIMALS.length)];
+    const suffix = Math.random().toString(36).slice(2, 6);
+    return `${adj}-${animal}-${suffix}`;
 }
 // ── Helpers ────────────────────────────────────────────────
 async function fetchJSON(path, opts) {
@@ -67,6 +249,17 @@ async function fetchJSON(path, opts) {
             headers,
         });
         const text = await res.text();
+        if (!res.ok) {
+            // Try to parse error JSON, fall back to status text
+            let message = `HTTP ${res.status}: ${res.statusText}`;
+            try {
+                const j = JSON.parse(text);
+                if (j.error)
+                    message = `HTTP ${res.status}: ${j.error}`;
+            }
+            catch { }
+            throw new Error(message);
+        }
         try {
             return JSON.parse(text);
         }
@@ -75,7 +268,7 @@ async function fetchJSON(path, opts) {
         }
     }
     catch (err) {
-        if (err.name === "AbortError") {
+        if (err instanceof Error && err.name === "AbortError") {
             throw new Error(`Request timed out after ${timeoutMs}ms: ${path}`);
         }
         throw err;
@@ -89,9 +282,10 @@ function formatToolList(tools) {
         return "No tools available.";
     return tools
         .map((t) => {
-        const schema = t.input_schema?.properties
-            ? Object.entries(t.input_schema.properties)
-                .map(([k, v]) => `${k}: ${v.type || "any"}`)
+        const props = t.input_schema?.properties;
+        const schema = props && typeof props === "object"
+            ? Object.entries(props)
+                .map(([k, v]) => `${k}: ${typeof v.type === "string" ? v.type : "any"}`)
                 .join(", ")
             : "{}";
         return `  ${t.name} (${t.risk || "low"}) — ${t.description}\n    input: { ${schema} }`;
@@ -115,77 +309,235 @@ const server = new McpServer({
     version: "0.4.0",
 });
 // ── Tool: connect ──────────────────────────────────────────
-server.tool("connect", `Connect to the running experience.
-
-Returns: available tools, current state, participants, and the browser URL.
-
-Identity is read from the state file written by /vibevibes-join. MCP never calls /join — setup.js owns identity.
-
-Call this first, then use act to interact. The stop hook keeps you present.`, {}, async () => {
+server.tool("connect", `Connect to the running experience.
+
+Joins the server as an AI participant, creates a session file for the stop hook,
+and returns available tools, current state, participants, and the browser URL.
+
+Call this first, then use act to interact. The stop hook keeps you present.`, {
+    url: z.string().optional().describe("Server URL to connect to. Defaults to the MCP server's configured URL."),
+    role: z.string().optional().describe("Preferred participant slot role to request (e.g. 'Blue Tank', 'Red ADC'). Server assigns the first available slot if omitted."),
+    subscription: z.enum(["all", "phase"]).optional().describe("Event subscription mode. 'all' (default) wakes on every event. 'phase' wakes only on phase changes — use for orchestrator agents."),
+    agentMode: z.enum(["behavior", "manual", "hybrid"]).optional().describe("Agent operating mode. 'behavior': autonomous via tick engine (no stop hook). 'manual': all decisions via act(). 'hybrid' (default): both behaviors and act()."),
+    metadata: z.record(z.string()).optional().describe("Arbitrary metadata (model, team, tags). Flows to server and viewer. E.g. { model: 'haiku', team: 'blue' }"),
+}, async ({ url, role: requestedRole, subscription, agentMode, metadata }) => {
     try {
-        const identity = loadIdentity();
-        // GET /state to fetch tools, state, participants — no POST /join
-        const state = await fetchJSON("/state", { timeoutMs: 10000 });
-        const output = [
+        if (url) {
+            SERVER_URL = url.replace(/\/$/, "");
+        }
+        // Auto-start server if not running
+        await ensureServerRunning(PROJECT_ROOT);
+        // Check if already connected (same process re-calling connect)
+        let identity = null;
+        if (currentOwner && existsSync(AGENTS_DIR)) {
+            const agentFiles = readdirSync(AGENTS_DIR).filter(f => f.endsWith(".json"));
+            for (const file of agentFiles) {
+                try {
+                    const session = JSON.parse(readFileSync(resolve(AGENTS_DIR, file), "utf-8"));
+                    if (session.owner !== currentOwner)
+                        continue;
+                    // Verify the agent still exists on the server
+                    let networkError = false;
+                    try {
+                        const controller = new AbortController();
+                        const timer = setTimeout(() => controller.abort(), 3000);
+                        const verifyHeaders = {};
+                        if (ROOM_TOKEN)
+                            verifyHeaders["Authorization"] = `Bearer ${ROOM_TOKEN}`;
+                        const verifyRes = await fetch(`${SERVER_URL}/participants`, { signal: controller.signal, headers: verifyHeaders });
+                        clearTimeout(timer);
+                        if (verifyRes.ok) {
+                            const data = await verifyRes.json();
+                            const alive = data.participants?.some((p) => p.actorId === session.actorId);
+                            if (alive) {
+                                identity = { actorId: session.actorId, owner: session.owner, id: session.owner };
+                                currentActorId = session.actorId;
+                                currentOwner = session.owner;
+                                break;
+                            }
+                        }
+                    }
+                    catch {
+                        networkError = true;
+                    }
+                    if (!identity && !networkError) {
+                        try {
+                            unlinkSync(resolve(AGENTS_DIR, file));
+                        }
+                        catch { }
+                    }
+                }
+                catch {
+                    try {
+                        unlinkSync(resolve(AGENTS_DIR, file));
+                    }
+                    catch { }
+                }
+            }
+        }
+        let joinData = null;
+        if (!identity) {
+            const id = generateName();
+            const joinBody = { username: id, actorType: "ai", owner: id };
+            if (requestedRole)
+                joinBody.role = requestedRole;
+            if (agentMode)
+                joinBody.agentMode = agentMode;
+            if (metadata && Object.keys(metadata).length > 0)
+                joinBody.metadata = metadata;
+            joinData = await fetchJSON("/join", {
+                method: "POST",
+                body: JSON.stringify(joinBody),
+                timeoutMs: 10000,
+            });
+            if (joinData.error) {
+                throw new Error(joinData.error);
+            }
+            // Write agent file
+            if (!existsSync(AGENTS_DIR)) {
+                mkdirSync(AGENTS_DIR, { recursive: true });
+            }
+            const sessionData = {
+                serverUrl: SERVER_URL,
+                owner: id,
+                actorId: joinData.actorId,
+                role: joinData.role || undefined,
+            };
+            if (subscription && subscription !== "all") {
+                sessionData.subscription = subscription;
+            }
+            if (agentMode) {
+                sessionData.agentMode = agentMode;
+            }
+            writeFileSync(resolve(AGENTS_DIR, `${id}.json`), JSON.stringify(sessionData, null, 2));
+            identity = { actorId: joinData.actorId, owner: id, id };
+            currentActorId = joinData.actorId;
+            currentOwner = id;
+            connections.set(joinData.actorId, {
+                actorId: joinData.actorId,
+                owner: id,
+            });
+        }
+        // Fetch state
+        const wroteNewFile = joinData !== null;
+        let state;
+        try {
+            state = await fetchJSON("/state", { timeoutMs: 10000 });
+        }
+        catch (stateErr) {
+            if (wroteNewFile && identity?.owner) {
+                try {
+                    unlinkSync(resolve(AGENTS_DIR, `${identity.owner}.json`));
+                }
+                catch { }
+            }
+            throw stateErr;
+        }
+        // Fetch slot definitions to detect unfilled autoSpawn AI slots
+        let unfilledSlots = [];
+        try {
+            const slotsData = await fetchJSON("/slots", { timeoutMs: 5000 });
+            if (slotsData?.slots) {
+                const currentParticipants = slotsData.participantDetails || [];
+                for (const slot of slotsData.slots) {
+                    if (slot.type !== "ai" && slot.type !== "any")
+                        continue;
+                    if (!slot.autoSpawn)
+                        continue;
+                    const max = slot.maxInstances ?? 1;
+                    const filled = currentParticipants.filter(p => p.role === slot.role && p.type === "ai").length;
+                    if (filled < max) {
+                        unfilledSlots.push({ role: slot.role, autoSpawn: slot.autoSpawn, maxInstances: max });
+                    }
+                }
+            }
+        }
+        catch {
+            // Slots endpoint not available — skip silently
+        }
+        const outputParts = [
             `Connected as ${identity.actorId}`,
+            connections.size > 1
+                ? `IMPORTANT: Multiple agents connected (${connections.size}). Pass actorId="${identity.actorId}" in all act/look calls.`
+                : "",
             `Experience: ${state.experienceId || "unknown"}`,
-            `Browser: ${state.browserUrl || SERVER_URL}`,
-            `Server: ${SERVER_URL}`,
-            ``,
-            formatState(state.sharedState, state.observation),
-            `Participants: ${state.participants?.join(", ")}`,
-            `Room Config: ${JSON.stringify(state.config || {}, null, 2)}`,
-            ...(state.hasRoomConfig ? [`(This experience supports configurable rooms — use spawn_room to create configured sub-rooms)`] : []),
-            ``,
-            `Tools:`,
-            formatToolList(state.tools),
-            ``,
-            `You are now a live participant. The stop hook keeps you present — use act to interact.`,
-        ].join("\n");
-        return { content: [{ type: "text", text: output }] };
+        ];
+        const role = joinData?.role;
+        const systemPrompt = joinData?.systemPrompt;
+        if (role)
+            outputParts.push(`Role: ${role}`);
+        outputParts.push(`Browser: ${state.browserUrl || SERVER_URL}`, `Server: ${SERVER_URL}`, ``);
+        if (systemPrompt) {
+            outputParts.push(`Your instructions:`, systemPrompt, ``);
+        }
+        outputParts.push(formatState(state.sharedState, joinData?.observation || state.observation), `Participants: ${state.participants?.join(", ")}`, ``, `Tools:`, formatToolList(joinData?.tools || state.tools || []), ``);
+        // Surface unfilled autoSpawn slots
+        if (unfilledSlots.length > 0) {
+            outputParts.push(`UNFILLED AI SLOTS (autoSpawn):`, ...unfilledSlots.map(s => `  - ${s.role} (max ${s.maxInstances ?? 1})`), ``, `These roles need AI agents. Spawn independent teammates — each gets its own MCP session and identity.`, `  Agent(subagent_type="general-purpose", model="sonnet", run_in_background=true,`, `    prompt="Call connect with role='ROLE'. Then play your role.")`, ``);
+        }
+        // Mode-specific instructions
+        if (agentMode === "behavior") {
+            outputParts.push(`BEHAVIOR MODE:`, `  You are a behavior-only agent. All actions run autonomously via the tick engine.`, `  No stop hook — you will NOT receive wake-up events.`, `  Set up behaviors now, then disconnect. The tick engine runs them automatically.`, ``);
+        }
+        else if (agentMode === "manual") {
+            outputParts.push(`MANUAL MODE:`, `  You are a manual agent. Use act() for all decisions. No behaviors.`, `  The stop hook keeps you present — use act to interact.`, `  COMMUNICATE: Use _chat.send to share strategy. Use _chat.team for team-only coordination.`, ``);
+        }
+        else {
+            outputParts.push(`FAST BRAIN / SLOW BRAIN:`, `  Fast brain: Register behaviors via _behavior.set for reactive, per-tick actions that run automatically.`, `  Slow brain: Use act() for strategic decisions and adapting to new situations.`, `  Set up your fast brain FIRST, then use your slow brain to observe and adapt.`, `  COMMUNICATE: Use _chat.send to share strategy. Use _chat.team for team-only coordination.`, ``, `You are now a live participant. The stop hook keeps you present — use act to interact.`);
+        }
+        // Register the stop hook so Claude Code wakes us on events
+        ensureStopHook();
+        return { content: [{ type: "text", text: outputParts.filter(Boolean).join("\n") }] };
     }
     catch (err) {
         return {
             content: [{
                     type: "text",
-                    text: `Failed to connect to ${SERVER_URL}.\n\nIs the dev server running? (npm run dev)\nHave you run /vibevibes-join?\n\nError: ${err.message}`,
+                    text: `Failed to connect.\n\nIs the dev server running? (npm run dev)\n\nError: ${toErrorMessage(err)}`,
                 }],
         };
     }
 });
 // ── Tool: act ──────────────────────────────────────────────
-server.tool("act", `Execute a tool to mutate shared state. All state changes go through tools.
-
-Supports batching: pass a "batch" array to execute multiple tool calls sequentially in one round-trip.
-Each call sees the state left by the previous call, so order matters.
-
-Single call:
-  act(toolName="counter.increment", input={amount: 2})
-
-Batch call (multiple tools in one round-trip):
-  act(batch=[
-    {toolName: "counter.increment", input: {amount: 2}},
-    {toolName: "counter.increment", input: {amount: 3}},
-    {toolName: "phase.set", input: {phase: "playing"}}
-  ])
-
-Use roomId to interact with a specific room (e.g. a cross-experience spawned room).
-Defaults to the "local" (host) room if omitted.`, {
+server.tool("act", `Execute a tool to mutate shared state. All state changes go through tools.
+
+Supports batching: pass a "batch" array to execute multiple tool calls sequentially in one round-trip.
+Each call sees the state left by the previous call, so order matters.
+
+Single call:
+  act(toolName="counter.increment", input={amount: 2})
+
+Batch call (multiple tools in one round-trip):
+  act(batch=[
+    {toolName: "counter.increment", input: {amount: 2}},
+    {toolName: "counter.increment", input: {amount: 3}},
+    {toolName: "phase.set", input: {phase: "playing"}}
+  ])`, {
     toolName: z.string().optional().describe("Tool to call, e.g. 'counter.increment'. Required if batch is not provided."),
-    input: z.record(z.any()).optional().describe("Tool input parameters (for single call)"),
+    input: z.record(z.unknown()).optional().describe("Tool input parameters (for single call)"),
     batch: z.array(z.object({
         toolName: z.string().describe("Tool to call"),
-        input: z.record(z.any()).optional().describe("Tool input parameters"),
+        input: z.record(z.unknown()).optional().describe("Tool input parameters"),
     })).optional().describe("Array of tool calls to execute sequentially in one round-trip. Each call sees the state from the previous call."),
-    roomId: z.string().optional().describe("Target room ID (defaults to 'local')"),
-}, async ({ toolName, input, batch, roomId }) => {
+    actorId: z.string().optional().describe("Your actorId from the connect response. Required when multiple agents are connected in the same session."),
+}, async ({ toolName, input, batch, actorId }) => {
+    let slot;
     try {
-        loadIdentity();
+        slot = resolveIdentity(actorId);
     }
     catch (err) {
-        return { content: [{ type: "text", text: `Not connected: ${err.message}` }] };
+        try {
+            loadIdentity();
+        }
+        catch { }
+        try {
+            slot = resolveIdentity(actorId);
+        }
+        catch (err2) {
+            return { content: [{ type: "text", text: `Not connected: ${toErrorMessage(err2)}` }] };
+        }
     }
-    const targetRoom = roomId || "local";
+    const effectiveActorId = slot.actorId;
     // Build the list of calls: either from batch or single toolName+input
     const calls = batch && batch.length > 0
         ? batch
@@ -195,19 +547,25 @@ Defaults to the "local" (host) room if omitted.`, {
     if (calls.length === 0) {
         return { content: [{ type: "text", text: `Provide either toolName or batch.` }] };
     }
-    const results = [];
+    // Validate tool names to prevent path traversal
+    const SAFE_TOOL_NAME = /^[a-zA-Z0-9_.\-]+$/;
     for (const call of calls) {
+        if (!SAFE_TOOL_NAME.test(call.toolName)) {
+            return { content: [{ type: "text", text: `Invalid tool name: "${call.toolName}". Tool names may only contain letters, digits, dots, hyphens, and underscores.` }] };
+        }
+    }
+    const effectiveOwner = slot.owner || currentOwner || undefined;
+    const results = [];
+    if (calls.length === 1) {
+        const call = calls[0];
         try {
-            const idempotencyKey = `${currentActorId}-${call.toolName}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-            const toolPath = targetRoom === "local"
-                ? `/tools/${call.toolName}`
-                : `/rooms/${targetRoom}/tools/${call.toolName}`;
-            const result = await fetchJSON(toolPath, {
+            const idempotencyKey = `${effectiveActorId}-${call.toolName}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+            const result = await fetchJSON(`/tools/${call.toolName}`, {
                 method: "POST",
                 headers: { "X-Idempotency-Key": idempotencyKey },
                 body: JSON.stringify({
-                    actorId: currentActorId || "mcp-client",
-                    owner: currentOwner || undefined,
+                    actorId: effectiveActorId || "mcp-client",
+                    owner: effectiveOwner,
                     input: call.input || {},
                 }),
                 timeoutMs: 30000,
@@ -216,423 +574,260 @@ Defaults to the "local" (host) room if omitted.`, {
                 results.push({ toolName: call.toolName, error: result.error });
             }
             else {
-                results.push({ toolName: call.toolName, output: result.output });
+                results.push({ toolName: call.toolName, output: result.output, observation: result.observation });
             }
         }
         catch (err) {
-            results.push({ toolName: call.toolName, error: err.message });
+            results.push({ toolName: call.toolName, error: toErrorMessage(err) });
         }
     }
-    // Fetch final state after all calls
-    try {
-        const statePath = targetRoom === "local" ? "/state" : `/rooms/${targetRoom}`;
-        const state = await fetchJSON(statePath, { timeoutMs: 5000 });
-        const stateObj = state.sharedState || state;
-        const outputParts = [];
-        if (targetRoom !== "local")
-            outputParts.push(`[Room: ${targetRoom}]`);
-        for (const r of results) {
-            if (r.error) {
-                outputParts.push(`${r.toolName} → ERROR: ${r.error}`);
+    else {
+        try {
+            const batchResult = await fetchJSON(`/tools-batch`, {
+                method: "POST",
+                body: JSON.stringify({
+                    actorId: effectiveActorId || "mcp-client",
+                    owner: effectiveOwner,
+                    calls: calls.map(c => ({ tool: c.toolName, input: c.input || {} })),
+                }),
+                timeoutMs: 30000,
+            });
+            if (batchResult.results && Array.isArray(batchResult.results)) {
+                for (const r of batchResult.results) {
+                    if (r.error) {
+                        results.push({ toolName: r.tool, error: r.error });
+                    }
+                    else {
+                        results.push({ toolName: r.tool, output: r.output, observation: r.observation });
+                    }
+                }
             }
-            else {
-                outputParts.push(`${r.toolName} → ${JSON.stringify(r.output)}`);
+            else if (batchResult.error) {
+                results.push({ toolName: calls[0].toolName, error: batchResult.error });
             }
         }
-        outputParts.push(formatState(stateObj, state.observation));
-        return { content: [{ type: "text", text: outputParts.join("\n") }] };
-    }
-    catch (err) {
-        // Still return tool results even if state fetch fails
-        const outputParts = results.map(r => r.error ? `${r.toolName} → ERROR: ${r.error}` : `${r.toolName} → ${JSON.stringify(r.output)}`);
-        outputParts.push(`(State fetch failed: ${err.message})`);
-        return { content: [{ type: "text", text: outputParts.join("\n") }] };
-    }
-});
-// ── Tool: stream ───────────────────────────────────────────
-server.tool("stream", `Send a continuous state update via stream channel.
-
-Streams are high-frequency state mutations (brush strokes, sliders, cursors) that bypass the full tool pipeline.
-They validate input, merge into state, and broadcast — but don't create event log entries.
-
-Use this instead of act for high-frequency updates.`, {
-    name: z.string().describe("Stream name, e.g. 'brush.stroke'"),
-    input: z.record(z.any()).optional().describe("Stream input parameters"),
-    roomId: z.string().optional().describe("Target room ID (defaults to 'local')"),
-}, async ({ name, input, roomId }) => {
-    try {
-        loadIdentity();
-    }
-    catch (err) {
-        return { content: [{ type: "text", text: `Not connected: ${err.message}` }] };
-    }
-    const targetRoom = roomId || "local";
-    try {
-        const streamPath = targetRoom === "local"
-            ? `/streams/${name}`
-            : `/rooms/${targetRoom}/streams/${name}`;
-        const result = await fetchJSON(streamPath, {
-            method: "POST",
-            body: JSON.stringify({ actorId: currentActorId, input: input || {} }),
-            timeoutMs: 10000,
-        });
-        if (result.error) {
-            return { content: [{ type: "text", text: `Stream error: ${result.error}` }] };
+        catch (_batchErr) {
+            // Fallback: if batch endpoint fails, run calls individually
+            for (const call of calls) {
+                try {
+                    const result = await fetchJSON(`/tools/${call.toolName}`, {
+                        method: "POST",
+                        body: JSON.stringify({
+                            actorId: effectiveActorId || "mcp-client",
+                            owner: effectiveOwner,
+                            input: call.input || {},
+                        }),
+                        timeoutMs: 30000,
+                    });
+                    if (result.error) {
+                        results.push({ toolName: call.toolName, error: result.error });
+                    }
+                    else {
+                        results.push({ toolName: call.toolName, output: result.output, observation: result.observation });
+                    }
+                }
+                catch (e) {
+                    results.push({ toolName: call.toolName, error: toErrorMessage(e) });
+                }
+            }
         }
-        return { content: [{ type: "text", text: `Stream ${name} sent.` }] };
-    }
-    catch (err) {
-        return { content: [{ type: "text", text: `Stream failed: ${err.message}` }] };
     }
-});
-// ── Tool: spawn_room ──────────────────────────────────────
-server.tool("spawn_room", `Spawn a new configured room (sub-room).
-
-Each room is an instance of the experience with its own config.
-Think of it as: experience = game engine, config = level parameters.
-
-You can pass:
-  - experienceId: which experience to run in the new room (defaults to current experience)
-  - config: an object of config values (validated against the experience's schema)
-  - config: a preset name string (e.g. "boss-fight") to use predefined configs
-
-Use list_experiences to discover available experiences.
-Use room_config_schema with an experienceId to discover config fields before spawning.
-
-Returns the new room's ID, URL, and resolved config.`, {
-    experienceId: z.string().optional().describe("Experience to run in the new room (defaults to host experience). Use list_experiences to see available options."),
-    name: z.string().optional().describe("Room name (auto-generated if omitted)"),
-    config: z.union([z.record(z.any()), z.string()]).optional().describe("Config values object or preset name string"),
-    initialState: z.record(z.any()).optional().describe("Initial shared state for the new room"),
-    linkBack: z.boolean().optional().describe("Store parent roomId in child state"),
-    sourceRoomId: z.string().optional().describe("Parent room ID (defaults to 'local')"),
-}, async ({ experienceId, name, config, initialState, linkBack, sourceRoomId }) => {
-    try {
-        loadIdentity();
-    }
-    catch (err) {
-        return { content: [{ type: "text", text: `Not connected: ${err.message}` }] };
-    }
-    try {
-        const result = await fetchJSON("/rooms/spawn", {
-            method: "POST",
-            body: JSON.stringify({
-                experienceId,
-                name,
-                config,
-                initialState,
-                linkBack: linkBack ?? true,
-                sourceRoomId: sourceRoomId || "local",
-            }),
-            timeoutMs: 30000, // External experiences need time to bundle
-        });
-        if (result.error) {
-            const hint = result.error.includes("not found")
-                ? `\nUse list_experiences to see available experience IDs.`
-                : "";
-            return { content: [{ type: "text", text: `Spawn failed: ${result.error}${hint}` }] };
-        }
-        const output = [
-            `Room spawned successfully!`,
-            experienceId ? `  Experience: ${experienceId}` : "",
-            `  Room ID: ${result.roomId}`,
-            `  URL: ${result.url}`,
-            `  Config: ${JSON.stringify(result.config, null, 2)}`,
-            ``,
-            `The room is live. Participants can join at the URL above.`,
-            `Use act(roomId="${result.roomId}") to interact with this room.`,
-        ].filter(Boolean).join("\n");
-        return { content: [{ type: "text", text: output }] };
+    // Build compact response
+    const outputParts = [];
+    let lastObservation = null;
+    for (const r of results) {
+        if (r.error) {
+            outputParts.push(`${r.toolName} → ERROR: ${r.error}`);
+        }
+        else {
+            outputParts.push(`${r.toolName} → ${JSON.stringify(r.output)}`);
+            if (r.observation)
+                lastObservation = r.observation;
+        }
     }
-    catch (err) {
-        return {
-            content: [{
-                    type: "text",
-                    text: `Failed to spawn room: ${err.message}`,
-                }],
-        };
+    if (lastObservation) {
+        outputParts.push(`Observation: ${JSON.stringify(lastObservation)}`);
     }
+    return { content: [{ type: "text", text: outputParts.join("\n") }] };
 });
-// ── Tool: list_rooms ──────────────────────────────────────
-server.tool("list_rooms", `List all active rooms and their configs.
-
-Returns room IDs, participant counts, configs, and parent/child relationships.
-Use this to discover what rooms exist and how they're configured.`, {}, async () => {
+// ── Tool: look ─────────────────────────────────────────────
+server.tool("look", `Observe the current state without taking any action.
+
+Returns the observation (or raw state), participants, and available tools.
+Read-only — no mutations, no events created.
+
+Use this to orient yourself before deciding whether to act.`, {
+    actorId: z.string().optional().describe("Your actorId from connect. Required when multiple agents connected."),
+}, async ({ actorId }) => {
+    let slot;
     try {
-        loadIdentity();
+        slot = resolveIdentity(actorId);
     }
-    catch (err) {
-        return { content: [{ type: "text", text: `Not connected: ${err.message}` }] };
+    catch {
+        try {
+            loadIdentity();
+            slot = resolveIdentity(actorId);
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Not connected: ${toErrorMessage(err)}` }] };
+        }
     }
     try {
-        const rooms = await fetchJSON("/rooms", { timeoutMs: 5000 });
-        if (!Array.isArray(rooms) || rooms.length === 0) {
-            return { content: [{ type: "text", text: "No rooms found." }] };
-        }
-        const lines = rooms.map((r) => {
-            const configStr = Object.keys(r.config || {}).length > 0
-                ? `config: ${JSON.stringify(r.config)}`
-                : "config: (default)";
-            const parentStr = r.parentRoomId ? ` ← parent: ${r.parentRoomId}` : "";
-            const childStr = r.childRoomIds?.length > 0 ? ` → children: [${r.childRoomIds.join(", ")}]` : "";
-            return `  ${r.roomId} (${r.participants?.length || 0} participants, ${r.eventCount || 0} events) ${configStr}${parentStr}${childStr}`;
-        });
-        return {
-            content: [{
-                    type: "text",
-                    text: `${rooms.length} room(s):\n${lines.join("\n")}`,
-                }],
-        };
+        const actorParam = slot.actorId ? `?actorId=${encodeURIComponent(slot.actorId)}` : "";
+        const state = await fetchJSON(`/state${actorParam}`, { timeoutMs: 10000 });
+        const outputParts = [];
+        outputParts.push(`Experience: ${state.experienceId || "unknown"}`);
+        outputParts.push(formatState(state.sharedState, state.observation));
+        outputParts.push(`Participants: ${(state.participants || []).join(", ")}`);
+        return { content: [{ type: "text", text: outputParts.join("\n") }] };
     }
     catch (err) {
-        return {
-            content: [{
-                    type: "text",
-                    text: `Failed to list rooms: ${err.message}`,
-                }],
-        };
+        return { content: [{ type: "text", text: `Look failed: ${toErrorMessage(err)}` }] };
     }
 });
-// ── Tool: room_config_schema ──────────────────────────────
-server.tool("room_config_schema", `Get the room configuration schema for an experience.
-
-Shows what config values a room accepts, their types, defaults, and available presets.
-Use this before spawn_room to understand what config options are available.
-
-Pass experienceId to inspect an external experience's config (loads it on demand).`, {
-    experienceId: z.string().optional().describe("Experience ID to inspect (defaults to host experience)"),
-}, async ({ experienceId }) => {
-    try {
-        loadIdentity();
-    }
-    catch (err) {
-        return { content: [{ type: "text", text: `Not connected: ${err.message}` }] };
-    }
+// ── Tool: disconnect ────────────────────────────────────────
+server.tool("disconnect", `Disconnect from the current experience.
+
+Removes the agent as a participant, deletes the session file, and cleans up.
+After disconnecting, the stop hook will no longer fire.
+If the experience has locked agent participation (canDisconnect: false in observe()),
+the disconnect will be rejected unless force=true is passed.`, {
+    force: z.boolean().optional().describe("Force disconnect even if the experience has locked participation"),
+    actorId: z.string().optional().describe("Disconnect a specific agent by actorId. Defaults to most recent connection. Use 'all' to disconnect all agents."),
+}, async ({ force, actorId: disconnectActorId }) => {
     try {
-        const queryParam = experienceId ? `?experienceId=${encodeURIComponent(experienceId)}` : "";
-        const schema = await fetchJSON(`/rooms/config-schema${queryParam}`, { timeoutMs: 15000 });
-        if (!schema.hasConfig) {
-            return {
-                content: [{
-                        type: "text",
-                        text: `${experienceId ? `Experience "${experienceId}"` : "This experience"} does not define a room config schema. Rooms are spawned with default settings.`,
-                    }],
-            };
+        // Handle "disconnect all"
+        if (disconnectActorId === "all") {
+            const allSlots = [...connections.values()];
+            for (const s of allSlots) {
+                try {
+                    await fetchJSON("/leave", { method: "POST", body: JSON.stringify({ actorId: s.actorId }), timeoutMs: 5000 });
+                }
+                catch { }
+                try {
+                    unlinkSync(resolve(AGENTS_DIR, `${s.owner}.json`));
+                }
+                catch { }
+                connections.delete(s.actorId);
+            }
+            currentActorId = null;
+            currentOwner = null;
+            removeStopHook();
+            return { content: [{ type: "text", text: `Disconnected all ${allSlots.length} agent(s).` }] };
         }
-        const output = [
-            `Room Config Schema${experienceId ? ` (${experienceId})` : ""}:`,
-            schema.description ? `  ${schema.description}` : "",
-            ``,
-            `Schema: ${JSON.stringify(schema.schema, null, 2)}`,
-            ``,
-            `Defaults: ${JSON.stringify(schema.defaults, null, 2)}`,
-            ``,
-            `Presets: ${schema.presets.length > 0 ? schema.presets.join(", ") : "(none)"}`,
-            ``,
-            `Use spawn_room with config values or a preset name to create a configured room.`,
-        ].filter(Boolean).join("\n");
-        return { content: [{ type: "text", text: output }] };
-    }
-    catch (err) {
-        return {
-            content: [{
-                    type: "text",
-                    text: `Failed to get config schema: ${err.message}`,
-                }],
-        };
-    }
-});
-// ── Tool: list_experiences ─────────────────────────────────
-server.tool("list_experiences", `List available experiences that can be used to spawn rooms.
-
-Shows the host experience and any external experiences registered in vibevibes.registry.json.
-Use this to discover what experiences are available for cross-experience room spawning.
-
-Each experience can be used as an experienceId in spawn_room.`, {}, async () => {
-    try {
-        loadIdentity();
-    }
-    catch (err) {
-        return { content: [{ type: "text", text: `Not connected: ${err.message}` }] };
-    }
-    try {
-        const experiences = await fetchJSON("/experiences", { timeoutMs: 10000 });
-        if (!Array.isArray(experiences) || experiences.length === 0) {
-            return { content: [{ type: "text", text: "No experiences found." }] };
-        }
-        const lines = experiences.map((exp) => {
-            const tag = exp.source === "host" ? "[HOST]" : "[REGISTRY]";
-            const loaded = exp.loaded ? "" : " (not yet loaded — will bundle on first spawn)";
-            const config = exp.hasRoomConfig ? " [configurable]" : "";
-            return `  ${tag} ${exp.id} v${exp.version || "?"}${config}${loaded}\n    ${exp.title || ""} — ${exp.description || ""}`;
-        });
-        const output = [
-            `${experiences.length} experience(s) available:`,
-            ...lines,
-            ``,
-            `Use spawn_room(experienceId="...") to create a room running any of these.`,
-            `Use room_config_schema(experienceId="...") to inspect config options before spawning.`,
-        ].join("\n");
-        return { content: [{ type: "text", text: output }] };
-    }
-    catch (err) {
-        return {
-            content: [{
-                    type: "text",
-                    text: `Failed to list experiences: ${err.message}`,
-                }],
-        };
-    }
-});
-// ── Tool: memory ───────────────────────────────────────────
-server.tool("memory", `Persistent agent memory (per-session). Survives across tool calls.
-
-Actions:
-  get — Retrieve current memory
-  set — Merge updates into memory`, {
-    action: z.enum(["get", "set"]).describe("What to do"),
-    updates: z.record(z.any()).optional().describe("Key-value pairs to merge (for set)"),
-}, async ({ action, updates }) => {
-    const key = currentActorId
-        ? `local:${currentActorId}`
-        : "default";
-    if (action === "get") {
-        const data = await fetchJSON(`/memory?key=${encodeURIComponent(key)}`, { timeoutMs: 5000 });
-        return {
-            content: [{
-                    type: "text",
-                    text: `Memory: ${JSON.stringify(data, null, 2)}`,
-                }],
-        };
-    }
-    if (action === "set") {
-        if (!updates || Object.keys(updates).length === 0) {
-            return { content: [{ type: "text", text: "No updates provided." }] };
+        // Resolve which identity to disconnect
+        let identity;
+        if (disconnectActorId && connections.has(disconnectActorId)) {
+            const s = connections.get(disconnectActorId);
+            identity = { actorId: s.actorId, serverUrl: SERVER_URL, owner: s.owner };
         }
-        await fetchJSON("/memory", {
-            method: "POST",
-            body: JSON.stringify({ key, updates }),
-            timeoutMs: 5000,
-        });
-        return { content: [{ type: "text", text: `Memory updated: ${JSON.stringify(updates)}` }] };
-    }
-    return { content: [{ type: "text", text: `Unknown action: ${action}` }] };
-});
-// ── Tool: screenshot ──────────────────────────────────────
-server.tool("screenshot", `Capture a screenshot of the experience as seen in the browser.
-
-Returns the current visual state as a PNG image.
-Requires the browser viewer to be open.
-
-Use this to see what the user sees — inspect paintings, check layouts, read rendered text, etc.`, {
-    timeout: z.number().optional().describe("Max wait ms (default 10000)"),
-}, async ({ timeout }) => {
-    try {
-        const t = Math.min(timeout || 10000, 30000);
-        const screenshotHeaders = {};
-        if (ROOM_TOKEN) {
-            screenshotHeaders["Authorization"] = `Bearer ${ROOM_TOKEN}`;
+        else {
+            try {
+                identity = loadIdentity();
+            }
+            catch {
+                // Fallback: scan agent files on disk (handles MCP process restart)
+                const cleaned = [];
+                if (existsSync(AGENTS_DIR)) {
+                    for (const file of readdirSync(AGENTS_DIR).filter(f => f.endsWith(".json"))) {
+                        try {
+                            const agent = JSON.parse(readFileSync(resolve(AGENTS_DIR, file), "utf-8"));
+                            try {
+                                const sUrl = agent.serverUrl || SERVER_URL;
+                                await fetch(`${sUrl}/leave`, {
+                                    method: "POST",
+                                    headers: { "Content-Type": "application/json" },
+                                    body: JSON.stringify({ actorId: agent.actorId }),
+                                    signal: AbortSignal.timeout(3000),
+                                });
+                            }
+                            catch { }
+                            unlinkSync(resolve(AGENTS_DIR, file));
+                            cleaned.push(agent.owner || file);
+                        }
+                        catch {
+                            try {
+                                unlinkSync(resolve(AGENTS_DIR, file));
+                            }
+                            catch { }
+                            cleaned.push(file);
+                        }
+                    }
+                }
+                removeStopHook();
+                if (cleaned.length > 0) {
+                    return { content: [{ type: "text", text: `Recovered from stale state. Cleaned up ${cleaned.length} agent(s): ${cleaned.join(", ")}` }] };
+                }
+                return { content: [{ type: "text", text: `Not connected. No agent files found to clean up.` }] };
+            }
         }
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), t + 5000);
+        // Check canDisconnect via agent-context
+        if (!force) {
+            try {
+                const ownerParam = identity.owner ? `&owner=${encodeURIComponent(identity.owner)}` : "";
+                const ctxUrl = `/agent-context?timeout=0&actorId=${encodeURIComponent(identity.actorId)}${ownerParam}`;
+                const ctx = await fetchJSON(ctxUrl, { timeoutMs: 10000 });
+                if (ctx?.observation?.canDisconnect === false) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `The experience has locked agent participation (canDisconnect: false). The experience controls when agents can leave. Use force=true to override.`,
+                            }],
+                    };
+                }
+            }
+            catch {
+                // If we can't check, allow disconnect (server may be down)
+            }
+        }
+        // POST /leave to remove participant from server
         try {
-            const res = await fetch(`${SERVER_URL}/screenshot?timeout=${t}`, {
-                headers: screenshotHeaders,
-                signal: controller.signal,
+            await fetchJSON("/leave", {
+                method: "POST",
+                body: JSON.stringify({ actorId: identity.actorId }),
+                timeoutMs: 5000,
             });
-            if (!res.ok) {
-                const err = await res.json().catch(() => ({ error: res.statusText }));
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Screenshot failed: ${err.error || "Unknown error"}`,
-                        }],
-                };
+        }
+        catch {
+            // Server may already be down — continue with local cleanup
+        }
+        // Delete own agent file
+        if (identity.owner) {
+            try {
+                unlinkSync(resolve(AGENTS_DIR, `${identity.owner}.json`));
             }
-            const arrayBuffer = await res.arrayBuffer();
-            const base64 = Buffer.from(arrayBuffer).toString("base64");
-            return {
-                content: [{
-                        type: "image",
-                        data: base64,
-                        mimeType: "image/png",
-                    }],
-            };
+            catch { }
         }
-        finally {
-            clearTimeout(timer);
+        // Remove from connections map
+        connections.delete(identity.actorId);
+        // Clean up if no connections remain
+        if (connections.size === 0) {
+            removeStopHook();
+            currentActorId = null;
+            currentOwner = null;
+        }
+        else {
+            // Update current to the last remaining connection
+            const last = [...connections.values()].pop();
+            currentActorId = last.actorId;
+            currentOwner = last.owner;
         }
-    }
-    catch (err) {
         return {
             content: [{
                     type: "text",
-                    text: `Screenshot failed: ${err.message}. Is the dev server running? Is the browser open?`,
+                    text: connections.size === 0
+                        ? `Disconnected from experience. You are no longer a participant.`
+                        : `Disconnected ${identity.actorId}. ${connections.size} agent(s) still connected.`,
                 }],
         };
     }
-});
-// ── Tool: blob_set ─────────────────────────────────────────
-server.tool("blob_set", `Store a binary blob on the server. Returns the blob key.
-
-Data is sent as base64-encoded string. Use this for pixel buffers, audio data, etc.
-The blob is stored server-side and can be referenced in state by key.`, {
-    key: z.string().describe("Blob key/ID"),
-    data: z.string().describe("Base64-encoded binary data"),
-    roomId: z.string().optional().describe("Room ID (defaults to 'local')"),
-}, async ({ key, data, roomId }) => {
-    try {
-        loadIdentity();
-        const binaryData = Buffer.from(data, 'base64');
-        const headers = {
-            "Content-Type": "application/octet-stream",
-        };
-        if (ROOM_TOKEN)
-            headers["Authorization"] = `Bearer ${ROOM_TOKEN}`;
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 30000);
-        try {
-            const res = await fetch(`${SERVER_URL}/blobs/${encodeURIComponent(key)}?actorId=${encodeURIComponent(currentActorId || '')}`, { method: "POST", headers, body: binaryData, signal: controller.signal });
-            const result = await res.json();
-            if (result.error)
-                return { content: [{ type: "text", text: `Blob error: ${result.error}` }] };
-            return { content: [{ type: "text", text: `Blob stored: key=${key}, size=${result.size} bytes` }] };
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
     catch (err) {
-        return { content: [{ type: "text", text: `Blob set failed: ${err.message}` }] };
-    }
-});
-// ── Tool: blob_get ─────────────────────────────────────────
-server.tool("blob_get", `Retrieve a binary blob from the server by key.
-
-Returns base64-encoded data. Use this to read pixel buffers, audio data, etc.`, {
-    key: z.string().describe("Blob key/ID to retrieve"),
-}, async ({ key }) => {
-    try {
-        loadIdentity();
-        const headers = {};
-        if (ROOM_TOKEN)
-            headers["Authorization"] = `Bearer ${ROOM_TOKEN}`;
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 30000);
-        try {
-            const res = await fetch(`${SERVER_URL}/blobs/${encodeURIComponent(key)}`, { headers, signal: controller.signal });
-            if (!res.ok)
-                return { content: [{ type: "text", text: `Blob not found: ${key}` }] };
-            const buf = await res.arrayBuffer();
-            const base64 = Buffer.from(buf).toString('base64');
-            return { content: [{ type: "text", text: `Blob ${key} (${buf.byteLength} bytes):\n${base64}` }] };
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    catch (err) {
-        return { content: [{ type: "text", text: `Blob get failed: ${err.message}` }] };
+        return {
+            content: [{
+                    type: "text",
+                    text: `Disconnect failed: ${toErrorMessage(err)}`,
+                }],
+        };
     }
 });
 // ── Start ──────────────────────────────────────────────────
@@ -644,3 +839,27 @@ main().catch((err) => {
     console.error("MCP server failed:", err);
     process.exit(1);
 });
+// ── Exit handler: best-effort cleanup on process exit ──────
+let cleaned = false;
+function cleanup() {
+    if (cleaned)
+        return;
+    cleaned = true;
+    if (currentActorId) {
+        try {
+            const leaveUrl = `${SERVER_URL}/leave`;
+            const script = `fetch(process.argv[1],{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({actorId:process.argv[2]})}).catch(()=>{})`;
+            spawnSync("node", ["-e", script, leaveUrl, currentActorId], { timeout: 3000, stdio: "ignore" });
+        }
+        catch { }
+    }
+    if (currentOwner) {
+        try {
+            unlinkSync(resolve(AGENTS_DIR, `${currentOwner}.json`));
+        }
+        catch { }
+    }
+    removeStopHook();
+}
+process.on("SIGINT", () => { cleanup(); process.exit(0); });
+process.on("SIGTERM", () => { cleanup(); process.exit(0); });