@vibevibes/mcp 0.2.0 → 0.3.1

package/hooks/logic.js

@@ -0,0 +1,258 @@
+/**
+ * Pure decision logic for the vibevibes-agent Stop hook.
+ * No I/O, no HTTP, no file system — just functions.
+ */
+// ── Helpers ────────────────────────────────────────────────
+/** Format a timestamp as HH:MM:SS */
+function fmtTime(ts) {
+    if (ts == null || ts <= 0)
+        return "";
+    const d = new Date(ts);
+    return d.toISOString().slice(11, 19);
+}
+/** Truncate a JSON string intelligently — preserves structure when possible */
+function smartTruncate(input, maxLen = 150) {
+    let str;
+    try {
+        str = JSON.stringify(input) ?? "undefined";
+    }
+    catch {
+        str = String(input);
+    }
+    if (str.length <= maxLen)
+        return str;
+    // Try to find a natural break point (closing brace/bracket)
+    const cutoff = maxLen - 3;
+    const slice = str.slice(0, cutoff);
+    // If we're in the middle of a string value, close it
+    const lastQuote = slice.lastIndexOf('"');
+    const lastComma = slice.lastIndexOf(",");
+    if (lastComma > lastQuote && lastComma > cutoff - 30) {
+        return slice.slice(0, lastComma) + "…}";
+    }
+    return slice + "…";
+}
+// ── Public API ─────────────────────────────────────────────
+/**
+ * Format an agent context into a readable prompt string.
+ * This is what Claude sees as the "reason" when the Stop hook blocks exit.
+ *
+ * Layout priority (most actionable first):
+ *   1. Errors (browser, tool, observe)
+ *   2. Observation (curated state — the "what matters")
+ *   3. Chat messages (human communication)
+ *   4. Other events (raw details)
+ *   5. Room/tick/participant context
+ *   6. Instructions
+ */
+export function formatPrompt(ctx) {
+    const parts = [];
+    // ── 1. Errors (highest priority) ──────────────────────
+    // Browser errors — experience crashed in the viewer
+    if (ctx.browserErrors && ctx.browserErrors.length > 0) {
+        parts.push(`BROWSER ERROR(S) — the experience crashed in the viewer:`);
+        for (const e of ctx.browserErrors) {
+            parts.push(`  ${e.message}`);
+        }
+        parts.push(`Fix the experience source code and rebuild if needed.`);
+        parts.push("");
+    }
+    // Last error from the agent's own tool call — show first for immediate feedback
+    if (ctx.lastError) {
+        parts.push(`Your last action failed:`);
+        // Sanitize error strings to prevent prompt injection via newlines
+        const safeError = String(ctx.lastError.error || "").replace(/[\x00-\x1f\x7f]/g, " ").slice(0, 500);
+        const safeTool = String(ctx.lastError.tool || "").replace(/[\x00-\x1f\x7f]/g, " ").slice(0, 100);
+        parts.push(`  ${safeTool} → ${safeError}`);
+        parts.push("");
+    }
+    // Observe function error — the experience's observe() is broken
+    if (ctx.observeError) {
+        const safeObsError = String(ctx.observeError).replace(/[\x00-\x1f\x7f]/g, " ").slice(0, 500);
+        parts.push(`Warning: observe() threw an error: ${safeObsError}`);
+        parts.push("");
+    }
+    // ── 2. Observation (curated state — most valuable signal) ──
+    if (ctx.observation && Object.keys(ctx.observation).length > 0) {
+        let obsStr;
+        try {
+            obsStr = JSON.stringify(ctx.observation, null, 2);
+        }
+        catch {
+            obsStr = String(ctx.observation);
+        }
+        if (!obsStr)
+            obsStr = "[unserializable observation]";
+        // If observation is small, inline it. If large, indent it as a block.
+        if (obsStr.length <= 200) {
+            parts.push(`Observation: ${obsStr}`);
+        }
+        else {
+            parts.push(`Observation:`);
+            // Indent each line of the JSON
+            for (const line of obsStr.split("\n")) {
+                parts.push(`  ${line}`);
+            }
+        }
+        parts.push("");
+    }
+    // ── 3. Events (what happened since last wake-up) ──────
+    if (ctx.events && ctx.events.length > 0) {
+        // Filter out noise: _behavior.* (setup), tick engine events (_tick-engine / _system)
+        const visibleEvents = ctx.events.filter((e) => !(e.tool || "").startsWith("_behavior.") &&
+            e.actorId !== "_tick-engine" &&
+            e.owner !== "_system");
+        // Separate chat messages from other events for prominent display
+        const chatEvents = visibleEvents.filter((e) => e.tool === "_chat.send");
+        const otherEvents = visibleEvents.filter((e) => e.tool !== "_chat.send" && e.tool !== "_chat.team");
+        if (chatEvents.length > 0) {
+            parts.push(`CHAT MESSAGE${chatEvents.length > 1 ? "S" : ""}:`);
+            for (const e of chatEvents) {
+                const actor = e.role || e.owner || (e.actorId ? e.actorId.split("-")[0] : "unknown");
+                const roomTag = e.roomId ? `[${e.roomId}] ` : "";
+                const time = fmtTime(e.ts);
+                const input = e.input;
+                // Sanitize chat messages to prevent prompt injection via newlines, ANSI escapes, control chars
+                const safeMsg = (input?.message || "").replace(/[\x00-\x1f\x7f]/g, " ").slice(0, 500);
+                parts.push(`  ${time} ${roomTag}${actor}: "${safeMsg}"`);
+            }
+            parts.push("");
+        }
+        // Team chat messages (from _chat.team tool calls)
+        const teamChatEvents = visibleEvents.filter((e) => e.tool === "_chat.team");
+        if (teamChatEvents.length > 0) {
+            // Group by team
+            const byTeam = new Map();
+            for (const e of teamChatEvents) {
+                const input = e.input;
+                const team = (input?.team || "unknown").replace(/[\x00-\x1f\x7f]/g, " ").slice(0, 50);
+                if (!byTeam.has(team))
+                    byTeam.set(team, []);
+                byTeam.get(team).push(e);
+            }
+            for (const [team, events] of byTeam) {
+                parts.push(`TEAM CHAT (${team}):`);
+                for (const e of events) {
+                    const actor = e.role || e.owner || (e.actorId ? e.actorId.split("-")[0] : "unknown");
+                    const time = fmtTime(e.ts);
+                    const input = e.input;
+                    const safeMsg = (input?.message || "").replace(/[\x00-\x1f\x7f]/g, " ").slice(0, 500);
+                    parts.push(`  ${time} ${actor}: "${safeMsg}"`);
+                }
+                parts.push("");
+            }
+        }
+        if (otherEvents.length > 0) {
+            // Detect multi-room activity
+            const roomIds = new Set(otherEvents.map((e) => e.roomId).filter(Boolean));
+            const multiRoom = roomIds.size > 1;
+            const header = multiRoom
+                ? `${otherEvents.length} event(s) across ${roomIds.size} rooms:`
+                : `${otherEvents.length} event(s) since your last action:`;
+            parts.push(header);
+            for (const e of otherEvents) {
+                const actor = e.role || e.owner || (e.actorId ? e.actorId.split("-")[0] : "unknown");
+                const inputStr = smartTruncate(e.input);
+                const roomTag = e.roomId ? `[${e.roomId}] ` : "";
+                const time = fmtTime(e.ts);
+                parts.push(`  ${time} ${roomTag}[${actor}] ${e.tool}(${inputStr})`);
+            }
+        }
+    }
+    // ── 4. Context (rooms, tick engines, participants) ─────
+    // Room info — show what rooms exist and their experiences
+    if (ctx.rooms && Object.keys(ctx.rooms).length > 1) {
+        parts.push("");
+        parts.push(`Rooms:`);
+        for (const [roomId, info] of Object.entries(ctx.rooms)) {
+            const p = info.participants?.length || 0;
+            parts.push(`  ${roomId} (${info.experience}, ${p} participant${p !== 1 ? "s" : ""})`);
+        }
+    }
+    // Tick engine status — only show if something interesting
+    if (ctx.tickEngines) {
+        const activeEngines = Object.entries(ctx.tickEngines).filter(([, status]) => status.enabled && status.behaviorsActive > 0);
+        if (activeEngines.length > 0) {
+            parts.push("");
+            for (const [roomId, status] of activeEngines) {
+                parts.push(`Tick engine [${roomId}]: ${status.behaviorsActive} behavior(s) active, ${status.tickCount} ticks`);
+            }
+        }
+    }
+    // Participants (deduplicated)
+    if (ctx.participants && ctx.participants.length > 0) {
+        const unique = [...new Set(ctx.participants)];
+        parts.push("");
+        parts.push(`Participants: ${unique.join(", ")}`);
+    }
+    // ── 5. Critical event detection ───────────────────────
+    if (ctx.events && ctx.events.length > 0) {
+        const criticalPatterns = /kill|destroy|tower|ace|gold|death|victory|defeat|eliminated|reset/i;
+        const criticalEvents = ctx.events.filter((e) => {
+            const toolStr = e.tool || "";
+            const outputStr = typeof e.output === "string" ? e.output : "";
+            return criticalPatterns.test(toolStr) || criticalPatterns.test(outputStr);
+        });
+        if (criticalEvents.length > 0) {
+            parts.push("");
+            const eventTypes = [...new Set(criticalEvents.map(e => e.tool || "event"))].slice(0, 5).join(", ");
+            parts.push(`CRITICAL EVENT DETECTED: ${eventTypes}. Consider adjusting your behavior preset via _behavior.activate to adapt to the new situation.`);
+        }
+    }
+    // ── 6. Instructions ───────────────────────────────────
+    parts.push("");
+    parts.push("New activity in the experience. Use the act MCP tool with roomId to respond in the right room. If nothing requires a response, you may observe without acting.");
+    parts.push("COMMUNICATE: Use _chat.send to share strategy with all players. Use _chat.team for team-only coordination. Good agents communicate intentions before acting.");
+    parts.push("IMPORTANT: You are a game participant. ONLY use MCP tools (act, look, stream, memory). NEVER use Bash, rm, or any terminal/file commands.");
+    return parts.join("\n");
+}
+/**
+ * Decide whether to block Claude's exit and what to feed back.
+ *
+ * Returns null to allow exit (no state file = not in agent mode).
+ * Returns a StopDecision to block exit and feed context to Claude.
+ */
+export function makeDecision(ctx, iteration, agentState) {
+    // No state file — allow normal exit
+    if (ctx === null)
+        return null;
+    // Behavior-only agents never produce stop decisions — they run autonomously via tick engine
+    if (agentState?.agentMode === "behavior")
+        return null;
+    // Only count non-system events (tick engine events are noise)
+    const realEvents = ctx.events?.filter((e) => !(e.tool || "").startsWith("_behavior.") &&
+        e.actorId !== "_tick-engine" &&
+        e.owner !== "_system") || [];
+    const hasEvents = realEvents.length > 0;
+    const hasError = !!ctx.lastError;
+    const hasBrowserErrors = ctx.browserErrors != null && ctx.browserErrors.length > 0;
+    const hasObserveError = !!ctx.observeError;
+    // Experience signaled completion — allow exit (agent file already deleted by stop-hook)
+    if (ctx.observation?.done)
+        return null;
+    // Nothing to react to — allow exit silently (zero wasted tokens)
+    if (!hasEvents && !hasError && !hasBrowserErrors && !hasObserveError)
+        return null;
+    const reason = formatPrompt(ctx);
+    const iter = iteration || 0;
+    // Build richer systemMessage with experience + role context
+    const mode = agentState?.agentMode || "hybrid";
+    const parts = [`vibevibes iteration ${iter}`];
+    if (agentState?.roomId)
+        parts.push(`Room: ${agentState.roomId}`);
+    if (agentState?.role)
+        parts.push(`Role: ${agentState.role}`);
+    parts.push(`Mode: ${mode}`);
+    if (mode === "manual") {
+        parts.push(`You are a manual agent. Use act() for all decisions. No behaviors. Communicate strategy via chat.`);
+    }
+    else {
+        parts.push(`You are a live participant. Fast brain: _behavior.set for reactive per-tick actions. Slow brain: act() for strategic decisions. Communicate strategy via chat. Adapt behaviors on critical events.`);
+    }
+    parts.push(`ONLY use MCP tools. NEVER use Bash, rm, or any terminal/file commands.`);
+    return {
+        decision: "block",
+        reason,
+        systemMessage: parts.join(" | "),
+    };
+}

package/hooks/stop-hook.js

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+/**
+ * vibevibes Stop Hook
+ *
+ * Scans .claude/vibevibes-agents/ for agent files, discovers AI agents from
+ * the server, polls each for events, and returns to Claude when there's activity.
+ *
+ * Self-healing: reconciles agent files against server, cleans stale files,
+ * and exits gracefully when no AI participants remain.
+ *
+ * Shipped with @vibevibes/mcp.
+ */
+import { readFileSync, writeFileSync, existsSync, unlinkSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { execSync } from "node:child_process";
+import { makeDecision } from "./logic.js";
+// ── Helpers ────────────────────────────────────────────────
+/** Resolve project root: git root or cwd */
+function resolveProjectRoot() {
+    try {
+        return execSync("git rev-parse --show-toplevel", { encoding: "utf-8", timeout: 3000 }).trim();
+    }
+    catch {
+        return process.cwd();
+    }
+}
+const PROJECT_ROOT = resolveProjectRoot();
+const AGENTS_DIR = process.env.VIBEVIBES_AGENTS_DIR || resolve(PROJECT_ROOT, ".claude", "vibevibes-agents");
+const DEFAULT_TIMEOUT = 5000;
+/** Read JSON from stdin (Claude Code passes hook context here) */
+function readStdin() {
+    return new Promise((res) => {
+        let data = "";
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => (data += chunk));
+        process.stdin.on("end", () => {
+            try {
+                res(JSON.parse(data));
+            }
+            catch {
+                res({});
+            }
+        });
+        if (process.stdin.isTTY)
+            res({});
+    });
+}
+/** Load all agent files from AGENTS_DIR. Returns array of session objects. */
+function loadAgentFiles() {
+    if (!existsSync(AGENTS_DIR))
+        return [];
+    try {
+        return readdirSync(AGENTS_DIR)
+            .filter((f) => f.endsWith(".json"))
+            .map((f) => {
+            try {
+                const data = JSON.parse(readFileSync(resolve(AGENTS_DIR, f), "utf-8"));
+                data._filename = f; // Track filename for iteration updates
+                return data;
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((x) => x !== null);
+    }
+    catch {
+        return [];
+    }
+}
+/** Increment and persist the iteration counter in an agent file */
+function bumpIteration(agent) {
+    const iter = (agent.iteration || 0) + 1;
+    try {
+        const filePath = resolve(AGENTS_DIR, agent._filename || `${agent.owner}.json`);
+        // Use in-memory agent data instead of re-reading from disk to avoid
+        // race conditions with concurrent stop-hook processes.
+        const data = { ...agent };
+        delete data._filename; // internal field, not persisted
+        data.iteration = iter;
+        writeFileSync(filePath, JSON.stringify(data, null, 2));
+    }
+    catch {
+        // Non-fatal — iteration tracking is best-effort
+    }
+    return iter;
+}
+/** Delete owned agent files and exit.
+ *  If no filenames specified, deletes all agent files (fallback for SIGINT/SIGTERM). */
+let _cleaningUp = false;
+function cleanupAndExit(ownedFilenames) {
+    if (_cleaningUp)
+        process.exit(0);
+    _cleaningUp = true;
+    if (existsSync(AGENTS_DIR)) {
+        try {
+            if (ownedFilenames && ownedFilenames.length > 0) {
+                // Only delete agent files owned by this stop-hook invocation
+                for (const f of ownedFilenames) {
+                    try {
+                        unlinkSync(resolve(AGENTS_DIR, f));
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+            else {
+                // Fallback: delete all (SIGINT/SIGTERM where ourAgents is unknown)
+                for (const f of readdirSync(AGENTS_DIR).filter((f) => f.endsWith(".json"))) {
+                    try {
+                        unlinkSync(resolve(AGENTS_DIR, f));
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+        }
+        catch { /* ignore */ }
+    }
+    process.exit(0);
+}
+/** Delete a specific agent file by owner name */
+function deleteAgentFile(owner) {
+    try {
+        unlinkSync(resolve(AGENTS_DIR, `${owner}.json`));
+    }
+    catch { /* ignore */ }
+}
+// Session end cleanup — SIGINT (Ctrl+C), SIGTERM (process kill)
+process.on("SIGINT", () => cleanupAndExit());
+process.on("SIGTERM", () => cleanupAndExit());
+// ── Main ───────────────────────────────────────────────────
+async function main() {
+    await readStdin();
+    // H1. Read agent files
+    const agents = loadAgentFiles();
+    if (agents.length === 0) {
+        process.exit(0);
+    }
+    // Use the first agent file for server/room info (all should be same server)
+    const session = agents[0];
+    // H2. Reconciliation — verify agents exist on server, clean stale files.
+    try {
+        const sUrl = session.serverUrl;
+        const rId = session.roomId;
+        const participantsUrl = rId
+            ? `${sUrl}/rooms/${rId}/participants`
+            : `${sUrl}/participants`;
+        const res = await fetch(participantsUrl, { signal: AbortSignal.timeout(3000) });
+        if (res.ok) {
+            const data = await res.json();
+            if (Array.isArray(data?.participants)) {
+                const serverActorIds = new Set(data.participants.map((p) => p.actorId));
+                for (const agent of agents) {
+                    if (agent.actorId && !serverActorIds.has(agent.actorId)) {
+                        deleteAgentFile(agent.owner);
+                    }
+                }
+                if (!data.participants.some((p) => p.type === "ai")) {
+                    cleanupAndExit();
+                }
+            }
+        }
+    }
+    catch {
+        // Server unreachable — proceed to poll (don't delete files)
+    }
+    // In-memory cursor per agent (not written to disk)
+    const cursors = new Map(); // actorId → lastEventCursor
+    // Track last-seen phase per agent for subscription: "phase" filtering
+    const lastPhase = new Map(); // owner → last phase value
+    // Build the list of OUR agents from agent files (not all AI agents on server).
+    // Each Claude Code workspace only polls its own agents — prevents cross-terminal
+    // observation merging that causes identity confusion (wrong myClaimedHero, wrong role).
+    // Reuse the already-loaded agents array — reconciliation may have deleted stale files,
+    // so filter to only those whose files still exist on disk.
+    const ourAgents = agents
+        .filter(a => existsSync(resolve(AGENTS_DIR, a._filename || `${a.owner}.json`)))
+        .map((a) => ({
+        actorId: a.actorId,
+        owner: a.owner,
+        role: a.role || undefined,
+        iteration: a.iteration || 0,
+        _filename: a._filename,
+        serverUrl: a.serverUrl || session.serverUrl,
+        roomId: a.roomId || undefined,
+        subscription: a.subscription || "all",
+        agentMode: a.agentMode || undefined,
+        lastPhase: a.lastPhase,
+    }));
+    // Initialize lastPhase from persisted agent files (survives across invocations)
+    for (const agent of ourAgents) {
+        if (agent.subscription === "phase" && agent.lastPhase !== undefined) {
+            lastPhase.set(agent.owner, agent.lastPhase ?? null);
+        }
+    }
+    if (ourAgents.length === 0) {
+        cleanupAndExit(agents.map(a => a._filename || `${a.owner}.json`));
+        return;
+    }
+    // Poll loop — runs until events arrive or no agents remain.
+    // Wall-clock limit: exit after 55 seconds to stay within Claude Code's hook timeout.
+    const POLL_DEADLINE_MS = 55_000;
+    const pollStart = Date.now();
+    while (true) {
+        // Wall-clock guard — exit cleanly before Claude Code kills us
+        const elapsed = Date.now() - pollStart;
+        if (elapsed > POLL_DEADLINE_MS) {
+            process.exit(0);
+        }
+        // Cap poll timeout to remaining time minus buffer, so we don't overshoot the deadline
+        const remainingMs = POLL_DEADLINE_MS - elapsed;
+        const pollTimeout = Math.min(DEFAULT_TIMEOUT, Math.max(1000, remainingMs - 3000));
+        // Poll only OUR agents (from agent files) in parallel
+        const results = await Promise.all(ourAgents.map(async (agent) => {
+            const ctx = await pollAgent(agent.serverUrl, agent.roomId, agent, cursors, pollTimeout);
+            return { agent, ctx };
+        }));
+        // Update cursors from server responses
+        for (const { agent, ctx } of results) {
+            if (ctx?.eventCursor != null && agent.actorId) {
+                cursors.set(agent.actorId, ctx.eventCursor);
+            }
+        }
+        // Handle done signals — clean up agent file if experience says done
+        const doneOwners = new Set();
+        for (const { agent, ctx } of results) {
+            if (!ctx)
+                continue;
+            if (ctx.observation?.done) {
+                deleteAgentFile(agent.owner);
+                doneOwners.add(agent.owner);
+            }
+        }
+        // Check if any agent got null context (possibly evicted from server or network blip)
+        const stillAlive = results.filter((r) => r.ctx !== null);
+        if (stillAlive.length === 0) {
+            // Don't delete agent files on transient failure — just exit quietly so retry can succeed
+            process.exit(0);
+            return;
+        }
+        // Filter to agents with actionable events
+        let live = results.filter((r) => r.ctx && ((r.ctx.events && r.ctx.events.length > 0) ||
+            r.ctx.lastError ||
+            r.ctx.observeError ||
+            (r.ctx.browserErrors != null && r.ctx.browserErrors.length > 0)));
+        // Filter out behavior-only agents — they run autonomously via tick engine, never need waking
+        live = live.filter((r) => r.agent.agentMode !== "behavior");
+        // Apply subscription filtering: "phase" agents only wake on phase changes or errors
+        live = live.filter((r) => {
+            if (r.agent.subscription !== "phase")
+                return true; // "all" passes through
+            // Always extract and persist current phase (even on error wakeups)
+            const currentPhase = typeof r.ctx?.observation?.phase === "string"
+                ? r.ctx.observation.phase : null;
+            const prevPhase = lastPhase.get(r.agent.owner) ?? null;
+            lastPhase.set(r.agent.owner, currentPhase);
+            // Always wake on errors
+            if (r.ctx?.lastError || r.ctx?.observeError ||
+                (r.ctx?.browserErrors != null && r.ctx.browserErrors.length > 0))
+                return true;
+            // Phase changed — wake
+            if (currentPhase !== prevPhase)
+                return true;
+            // Check for phase-related events from agent's own room only
+            const phaseEvents = r.ctx?.events?.filter((e) => {
+                if (e.roomId && r.agent.roomId && e.roomId !== r.agent.roomId)
+                    return false;
+                return /phase|start|reset|end|finish/i.test(e.tool || "");
+            }) || [];
+            if (phaseEvents.length > 0)
+                return true;
+            return false; // Not a phase change — skip
+        });
+        // Persist lastPhase for phase-subscription agents across invocations.
+        // Update agent.lastPhase in memory (bumpIteration writes it for woken agents).
+        // For filtered-out agents, write to disk here so next invocation sees the correct phase.
+        const liveOwners = new Set(live.map((r) => r.agent.owner));
+        for (const { agent } of results) {
+            if (agent.subscription !== "phase")
+                continue;
+            if (!lastPhase.has(agent.owner))
+                continue;
+            const phaseVal = lastPhase.get(agent.owner) ?? null;
+            agent.lastPhase = phaseVal;
+            if (!liveOwners.has(agent.owner)) {
+                try {
+                    const filePath = resolve(AGENTS_DIR, agent._filename || `${agent.owner}.json`);
+                    const data = { ...agent };
+                    delete data._filename;
+                    writeFileSync(filePath, JSON.stringify(data, null, 2));
+                }
+                catch { /* Non-fatal — best-effort persistence */ }
+            }
+        }
+        if (live.length > 0) {
+            if (live.length > 1) {
+                process.stderr.write(`[vibevibes] Warning: ${live.length} agent files found but expected 1. Using first agent only.\n`);
+            }
+            const { agent, ctx } = live[0];
+            const iteration = doneOwners.has(agent.owner) ? (agent.iteration || 0) + 1 : bumpIteration(agent);
+            const agentState = {
+                roomId: agent.roomId || session.roomId,
+                role: agent.role,
+                iteration,
+                agentMode: agent.agentMode,
+            };
+            const decision = makeDecision(ctx, iteration, agentState);
+            if (decision) {
+                process.stdout.write(JSON.stringify(decision));
+            }
+            process.exit(0);
+        }
+        // No events — loop again (the server's long-poll IS the delay)
+    }
+}
+/** Poll a single agent's server for events */
+async function pollAgent(serverUrl, roomId, agent, cursors, timeout = DEFAULT_TIMEOUT) {
+    const { actorId, owner } = agent;
+    if (!actorId)
+        return null;
+    const since = cursors.get(actorId) || 0;
+    const ownerParam = owner ? `&owner=${encodeURIComponent(owner)}` : "";
+    const roomP = roomId ? `&roomId=${encodeURIComponent(roomId)}` : "";
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout + 1000);
+    try {
+        const url = `${serverUrl}/agent-context?since=${since}&actorId=${encodeURIComponent(actorId)}&timeout=${timeout}${ownerParam}${roomP}`;
+        const res = await fetch(url, { signal: controller.signal });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+main().catch(() => {
+    process.exit(0);
+});