@agentmessier/openclaw-agent-messier 0.3.11 → 0.4.0

package/index.ts

@@ -1,9 +1,9 @@
 import type { AnyAgentTool, OpenClawPluginApi } from "openclaw/plugin-sdk/core";
-import { memberTools, venuesTool, agentIdOf, identityOf, venueUrl, type PluginCfg } from "./src/tools.js";
-import { defaultVenueTools, defaultRealtimeVenue, joinVenue } from "./src/generate.js";
+import { memberTools, venuesTool, agentIdOf, identityOf, venueUrl, type PluginCfg, type GameSpec } from "./src/tools.js";
+import { defaultVenueTools, defaultRealtimeVenues, hasBakedVenuePrefix, joinVenue, setVenueState, type Venue } from "./src/generate.js";
 import { startObserveWatcher } from "./src/watcher.js";
-import { session } from "./src/state.js";
-import { runAutoplayTurn, STRICT_JSON_DIRECTIVE } from "./src/decide.js";
+import { session, createSession, type RuntimeSession } from "./src/state.js";
+import { runAutoplayTurn, postDecisionReport, STRICT_JSON_DIRECTIVE } from "./src/decide.js";
 
 /** A lobby row is "ours" if it references our agentId anywhere (soccer puts it in
  *  sides.home/away; a generic venue may shape it differently). Deep, shape-blind. */
@@ -19,109 +19,155 @@ export default function register(api: OpenClawPluginApi) {
   const cfg = (api.pluginConfig ?? {}) as PluginCfg;
 
   // 1. Tools: per-venue lifecycle tools GENERATED from each venue's spec
-  //    (soccer_matches/join/observe/play, work_observe/act, …) + soccer member
-  //    perks (skins/rename/claim) + the platform `venues` registry tool. A new
-  //    venue appears here from its spec with zero plugin code.
-  for (const tool of [...defaultVenueTools(cfg), ...memberTools(cfg), venuesTool(cfg)]) {
-    api.registerTool(tool as AnyAgentTool);
-  }
+  //    (soccer_matches/join/observe/play, work_observe/act, …) + the platform
+  //    `venues` registry tool. A new venue appears here from its spec with zero
+  //    plugin code. The soccer member perks (skins/rename/identity) are
+  //    soccer-specific and hand-written, so they're registered ONLY when a soccer
+  //    venue is present — a non-soccer deployment doesn't see them.
+  const tools: AnyAgentTool[] = [...defaultVenueTools(cfg), venuesTool(cfg)];
+  if (hasBakedVenuePrefix("soccer")) tools.push(...memberTools(cfg));
+  for (const tool of tools) api.registerTool(tool as AnyAgentTool);
 
   // Capture the EFFECTIVE model of each decision from the gateway's llm_output
-  // hook (the provider/model of the call that just ran). vfetch sends it as
-  // x-agent-model, so the pitch records the model actually PLAYING — reflecting
-  // a mid-match /model switch, not a static configured default.
+  // hook (the provider/model of the call that just ran). It's process-wide (the
+  // hook can't attribute a model to a venue), so it lives on the global session;
+  // vfetch/executeMoves send it as x-agent-model so the pitch records the model
+  // actually PLAYING — reflecting a mid-match /model switch.
   api.registerHook("llm_output", ((event: { provider?: string; model?: string }) => {
     if (event?.model) session.lastModel = event.provider ? `${event.provider}/${event.model}` : event.model;
   }) as Parameters<typeof api.registerHook>[1]);
 
-  // 2. Autoplay watcher. It drives ONE realtime venue (streams observations,
-  //    seats the agent, offers hands-free play) entirely from {venue, spec} —
-  //    seating via spec.client.join, observe/act endpoints via spec.routes, the
-  //    move prompt naming spec.client.act.tool. No venue is hardcoded here;
-  //    soccer is simply the only realtime venue today. Seatless/poll venues
-  //    (taskmarket) have no autoplay loop, so the service no-ops for them.
-  const realtime = defaultRealtimeVenue();
-  if (!realtime) return;
-  const { venue, spec } = realtime;
+  // 2. Autoplay watchers — ONE per realtime venue (streams observations, seats the
+  //    agent, offers hands-free play), each with its OWN runtime state so multiple
+  //    games (soccer + a future golf) never clobber each other. Seating via
+  //    spec.client.join, observe/act via spec.routes, the prompt naming
+  //    spec.client.act.tool. No venue is hardcoded; soccer is just the only
+  //    realtime venue today. The FIRST realtime venue reuses the global session so
+  //    the interactive/cosmetic tools (which read it) stay in sync; the rest get a
+  //    fresh isolated state.
+  const realtime = defaultRealtimeVenues();
+  const sessionKey =
+    cfg.sessionKey ??
+    ((api.config.hooks as Record<string, unknown> | undefined)?.defaultSessionKey as string | undefined);
+
+  realtime.forEach(({ venue, spec }, i) => {
+    const state = i === 0 ? session : createSession();
+    setVenueState(venue.id, state); // the generated act tool stamps THIS instance
+    registerVenueService(api, cfg, venue, spec, state, sessionKey);
+  });
+}
+
+/** Register the autoplay service for one realtime venue. All seating/observe/act
+ *  is driven from {venue, spec} + the venue's own RuntimeSession. */
+function registerVenueService(
+  api: OpenClawPluginApi,
+  cfg: PluginCfg,
+  venue: Venue,
+  spec: GameSpec,
+  state: RuntimeSession,
+  sessionKey: string | undefined,
+) {
   const label = venue.id;
   const actTool = spec.client!.act.tool;
   const lobbyRoute = spec.client?.lobby?.route;
   const roomIdField = spec.client?.join?.seat.id ?? "id";
   const base = venueUrl(venue.origin, cfg);
 
-  const sessionKey =
-    cfg.sessionKey ??
-    ((api.config.hooks as Record<string, unknown> | undefined)?.defaultSessionKey as string | undefined);
-
   let controller: AbortController | null = null;
   let poller: ReturnType<typeof setInterval> | null = null;
+  // The per-match session key currently in play. We persist ONE session per match
+  // (so the agent accumulates its own decision history); on LEAVING a match we
+  // delete it so a new match starts fresh and stale transcripts don't pile up.
+  let activeSessionKey: string | null = null;
 
   api.registerService({
     id: `agentnet-${venue.id}-watcher`,
 
     start: async (ctx) => {
       const agentId = agentIdOf(cfg);
-      // Config-derived join body. For soccer these are teamSize/team/identity; a
-      // venue whose spec doesn't use them simply leaves the cfg fields unset and
-      // the server ignores the extras. joinVenue itself stays venue-agnostic.
-      const joinExtra = (): Record<string, unknown> => ({ teamSize: cfg.teamSize, team: cfg.team, identity: identityOf(cfg) });
+      // Config-derived join body: a generic identity object plus any venue join
+      // params (cfg.join — teamSize/team for soccer, holes for golf, …). A venue
+      // whose spec doesn't use a field simply leaves it unset; the server ignores
+      // extras. joinVenue itself stays venue-agnostic.
+      const joinExtra = (): Record<string, unknown> => ({ ...(cfg.join ?? {}), identity: identityOf(cfg) });
 
       // Seat into a room (matchId omitted = quickmatch find-or-create) and
-      // (re)start the observation loop. Installed into shared state so the
+      // (re)start the observation loop. Installed into this venue's state so the
       // generated *_join tool / chat handoff can drive it.
-      session.joinAndWatch = async (matchId, params) => {
+      state.joinAndWatch = async (matchId, params) => {
         const seat = await joinVenue(venue, spec, cfg, { matchId, params: params ?? {}, extra: joinExtra() });
         ctx.logger.info(`[${label}] ${agentId} seated in ${seat.id} (${seat.controls?.length ?? 0} to control)${seat.started ? " — live" : " — waiting for opponent"}`);
 
         controller?.abort(); // leaving a previous room
         controller = new AbortController();
+        // Leaving the previous match → drop its persistent session so the new
+        // match starts with fresh context (and stale transcripts don't pile up).
+        if (sessionKey && activeSessionKey && activeSessionKey !== `${sessionKey}:${seat.id}`) {
+          api.runtime.subagent.deleteSession({ sessionKey: activeSessionKey }).catch(() => {});
+        }
+        // ONE persistent session for THIS match, stable across all its turns.
+        activeSessionKey = sessionKey ? `${sessionKey}:${seat.id}` : null;
         let move = 0;
         // Fire-and-forget: the watcher runs until aborted or the gateway stops.
         void startObserveWatcher(
           { serverUrl: cfg.serverUrl, matchId: seat.id!, agentId, mode: cfg.mode, strategyFile: cfg.strategyFile, actTool, label },
-          async ({ system, user }) => {
+          async ({ system, user, tick, clock }) => {
             if (!sessionKey) {
               ctx.logger.warn(`[${label}] no sessionKey configured; cannot deliver move prompts.`);
               return;
             }
             // Option A (docs/design/agent-bridge-plugin.md §2): force ONE agent
             // turn per situation and PARSE its JSON reply — no longer wait for the
-            // agent to proactively call soccer_play (that reliance caused m171's
-            // 2-decisions-in-157s). soccer_play stays registered for interactive
-            // chat play; only AUTOPLAY changes to this server-driven loop.
+            // agent to proactively call the act tool (that reliance caused m171's
+            // 2-decisions-in-157s). The act tool stays registered for interactive
+            // chat play; only AUTOPLAY uses this server-driven loop.
             //
-            // Fresh session per move: each prompt is a complete snapshot, so the
-            // agent needs no history — keeps context from overflowing.
+            // ONE persistent session per MATCH (sessionKey:matchId, stable across
+            // turns) so the agent accumulates context — its own prior decisions.
             const turn = move++;
+            const matchSessionKey = `${sessionKey}:${seat.id}`;
             const idempotencyKey = `agentnet:${venue.id}:${seat.id}:${agentId}:${turn}`;
+            const did = state.did ?? agentId;
+            const sys = system || undefined;
+            const msg = `${user}${STRICT_JSON_DIRECTIVE}`;
             // Mark when this prompt was handed to the agent: x-agent-decision-ms is
             // the prompt→reply latency measured inside runAutoplayTurn.
-            session.promptDeliveredAt = Date.now();
+            state.promptDeliveredAt = Date.now();
             const result = await runAutoplayTurn({
               runtime: api.runtime,
-              sessionKey: `${sessionKey}:${turn}`,
+              sessionKey: matchSessionKey,
+              turn,
               idempotencyKey,
               // The static rulebook (spec.instructions.system) rides the SYSTEM
-              // channel; the per-tick board is the user message. '' on the
-              // fallback path → no extra system prompt.
-              extraSystemPrompt: system || undefined,
-              // Steer the agent to reply with ONLY the moves JSON (no tool call).
-              message: `${user}${STRICT_JSON_DIRECTIVE}`,
-              // 45s ceiling, matching the watcher's per-delivery watchdog backstop:
-              // a run that hasn't produced a decision by then is treated as stalled
-              // (was 300s, which let one hung run silence the team for 5 min — m171).
+              // channel; the per-tick board is the user message.
+              extraSystemPrompt: sys,
+              message: msg,
               timeoutMs: 45_000,
               matchId: seat.id!,
               cfg,
-              did: session.did ?? agentId,
-              token: session.token,
+              did,
+              token: state.token,
               base,
+              state,
               logger: ctx.logger,
             });
-            // act-verification by the natural signal: did we parse+post (or did the
-            // model act via the tool)? A parse-miss = "responded without acting" —
-            // log, keep standing orders, continue (never freeze). The watcher's own
-            // lastActAt check stays correct because executeMoves/soccer_play stamp it.
+            // Report EVERY decision to the pitch — acted AND no-response — so the
+            // decision inspector sees no-response turns too. Best-effort, off the
+            // hot path, never throws.
+            void postDecisionReport(
+              {
+                tick,
+                clock,
+                prompt: { ...(sys ? { system: sys } : {}), user: msg },
+                outcome: result.outcome,
+                ...(result.reason ? { reason: result.reason } : {}),
+                ...(result.moves ? { moves: result.moves } : {}),
+                rawText: result.rawText,
+                latencyMs: result.latencyMs,
+                ...(session.lastModel ? { model: session.lastModel } : {}),
+              },
+              { base, matchId: seat.id!, agentId: did, token: state.token, logger: ctx.logger },
+            );
             if (!result.acted) {
               ctx.logger.warn(`[${label}] agent responded without acting (turn ${turn}): ${result.reason}`);
             }
@@ -129,6 +175,7 @@ export default function register(api: OpenClawPluginApi) {
           {
             signal: controller.signal,
             logger: ctx.logger,
+            state,
             onReclaim: async () => {
               // Server restarted and forgot us — re-seat into the same room via
               // seatRoute, or (room gone) quickmatch into a fresh one.
@@ -139,7 +186,7 @@ export default function register(api: OpenClawPluginApi) {
                 if (!cfg.autoJoin) throw e;
                 const q = await joinVenue(venue, spec, cfg, { extra: joinExtra() });
                 ctx.logger.info(`[${label}] room ${seat.id} gone — re-quickmatched into ${q.id}`);
-                if (q.id !== seat.id) void session.joinAndWatch!(undefined);
+                if (q.id !== seat.id) void state.joinAndWatch!(undefined);
               }
             },
           },
@@ -150,8 +197,8 @@ export default function register(api: OpenClawPluginApi) {
       // Startup seating: a pinned matchId seats that room; autoJoin quick-matches
       // (find-or-create, atomic server-side); otherwise idle until asked.
       try {
-        if (cfg.matchId) await session.joinAndWatch(cfg.matchId);
-        else if (cfg.autoJoin) await session.joinAndWatch(undefined);
+        if (cfg.matchId) await state.joinAndWatch(cfg.matchId);
+        else if (cfg.autoJoin) await state.joinAndWatch(undefined);
         else ctx.logger.info(`[${label}] idle — ask me to join or create a game.`);
       } catch (e) { ctx.logger.error(`[${label}] startup seating failed: ${String(e)}`); }
 
@@ -160,11 +207,11 @@ export default function register(api: OpenClawPluginApi) {
       // venue's lobby for a non-ended room referencing our agentId and adopt it.
       // Driven by spec.client.lobby.route — no hardcoded /matches path. Skipped
       // when a match is pinned (explicit room wins) or the venue has no lobby.
-      // Critically it only adopts while idle (session.matchId empty): once we're
-      // in a match it must NOT yank us into some other (e.g. stale) room.
+      // Critically it only adopts while idle (state.matchId empty): once we're in
+      // a match it must NOT yank us into some other (e.g. stale) room.
       if (lobbyRoute && !cfg.matchId) {
         poller = setInterval(async () => {
-          if (session.matchId) return; // already seated/playing → nothing to adopt
+          if (state.matchId) return; // already seated/playing → nothing to adopt
           try {
             const res = await fetch(`${base}${lobbyRoute}`);
             if (!res.ok) return;
@@ -174,7 +221,7 @@ export default function register(api: OpenClawPluginApi) {
             const id = mine?.id ?? mine?.[roomIdField];
             if (id) {
               ctx.logger.info(`[${label}] found my seat in ${id} (taken elsewhere) — starting to play`);
-              await session.joinAndWatch!(id);
+              await state.joinAndWatch!(id);
             }
           } catch { /* server down — the watcher's own backoff handles it */ }
         }, 10_000);
@@ -186,8 +233,12 @@ export default function register(api: OpenClawPluginApi) {
       if (poller) { clearInterval(poller); poller = null; }
       controller?.abort();
       controller = null;
-      session.joinAndWatch = null;
-      session.matchId = null;
+      if (activeSessionKey) {
+        api.runtime.subagent.deleteSession({ sessionKey: activeSessionKey }).catch(() => {});
+        activeSessionKey = null;
+      }
+      state.joinAndWatch = null;
+      state.matchId = null;
     },
   });
 }

package/openclaw.plugin.json

@@ -3,107 +3,65 @@
   "kind": "tool",
   "uiHints": {
     "serverUrl": {
-      "label": "Pitch Server URL",
+      "label": "Server URL",
       "placeholder": "http://localhost:3010",
-      "help": "Base URL of the agent-soccer pitch service"
+      "help": "Base URL of the AgentNet platform / venue service (the pitch for soccer)"
     },
     "sessionKey": {
       "label": "Agent identity",
-      "placeholder": "my-team",
-      "help": "Stable id for this agent's seat in a room (also the chat session key)"
+      "placeholder": "my-agent",
+      "help": "Stable id for this agent's seat (also the chat session key)"
     },
     "mode": {
       "label": "Tool tier",
       "placeholder": "easy",
-      "help": "easy = high-level intents (server computes geometry); advanced = raw run/kick; both = all tools"
+      "help": "easy = high-level intents (server computes detail); advanced = raw low-level actions; both = all tools"
     },
     "matchId": {
       "label": "Auto-join room (optional)",
       "placeholder": "m1",
       "help": "Join this room at startup; normally leave empty and ask your agent to find/create a game"
     },
-    "team": {
-      "label": "Side preference (optional)",
-      "placeholder": "home",
-      "help": "Preferred side when auto-joining"
-    },
-    "teamName": {
-      "label": "Team name",
-      "placeholder": "\u84dd\u9e70",
-      "help": "Default team name (human can rename at runtime via chat)"
-    },
-    "nation": {
-      "label": "Nation (ISO code)",
-      "placeholder": "NL",
-      "help": "Shown as a flag in the viewer"
-    },
-    "clan": {
-      "label": "Clan",
-      "placeholder": "\u9b54\u517d\u5de5\u4f1a",
-      "help": "Guild/clan tag shown with the team"
-    },
-    "style": {
-      "label": "Playing style",
-      "placeholder": "\u5168\u653b\u5168\u5b88 total football",
-      "help": "Fed into the agent's prompts \u2014 shapes actual play"
-    },
     "autoJoin": {
       "label": "Auto quick-match",
       "placeholder": "true",
-      "help": "Find-or-create a game at startup (zero-touch bot team)"
+      "help": "Find-or-create a game at startup (zero-touch bot agent)"
+    },
+    "identity": {
+      "label": "Display identity",
+      "placeholder": "{ \"name\": \"蓝鹰\", \"nation\": \"NL\" }",
+      "help": "Venue-neutral identity sent on join (soccer: name/nation/clan/style; shown in the viewer). Human can change it at runtime via chat where supported."
+    },
+    "join": {
+      "label": "Join options",
+      "placeholder": "{ \"teamSize\": 5, \"team\": \"home\" }",
+      "help": "Venue join params merged into the join body — soccer: teamSize/team; golf: holes; etc. Unknown fields are ignored by the server."
+    },
+    "apiKey": {
+      "label": "AgentNet API key (optional)",
+      "placeholder": "ak_…",
+      "help": "Sent as a Bearer token so the server can verify identity (REQUIRE_AUTH deployments)"
     },
-    "teamSize": {
-      "label": "Preferred team size",
-      "placeholder": "5",
-      "help": "Players per side for quick-match / created rooms"
+    "strategyFile": {
+      "label": "Strategy file (optional)",
+      "placeholder": "~/strategy.md",
+      "help": "Path to a human-editable markdown file injected into the agent's move prompt"
     }
   },
   "configSchema": {
     "type": "object",
-    "additionalProperties": false,
+    "additionalProperties": true,
     "properties": {
-      "serverUrl": {
-        "type": "string"
-      },
-      "sessionKey": {
-        "type": "string"
-      },
-      "mode": {
-        "type": "string",
-        "enum": [
-          "easy",
-          "advanced",
-          "both"
-        ]
-      },
-      "matchId": {
-        "type": "string"
-      },
-      "team": {
-        "type": "string",
-        "enum": [
-          "home",
-          "away"
-        ]
-      },
-      "teamName": {
-        "type": "string"
-      },
-      "nation": {
-        "type": "string"
-      },
-      "clan": {
-        "type": "string"
-      },
-      "style": {
-        "type": "string"
-      },
-      "autoJoin": {
-        "type": "boolean"
-      },
-      "teamSize": {
-        "type": "number"
-      }
+      "serverUrl": { "type": "string" },
+      "sessionKey": { "type": "string" },
+      "apiKey": { "type": "string" },
+      "accountsUrl": { "type": "string" },
+      "mode": { "type": "string", "enum": ["easy", "advanced", "both"] },
+      "matchId": { "type": "string" },
+      "autoJoin": { "type": "boolean" },
+      "strategyFile": { "type": "string" },
+      "identity": { "type": "object", "additionalProperties": true },
+      "join": { "type": "object", "additionalProperties": true }
     },
     "required": []
   }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@agentmessier/openclaw-agent-messier",
-  "version": "0.3.11",
+  "version": "0.4.0",
   "description": "Agent Messier multi-venue client for OpenClaw \u2014 play games and work tasks on the AgentNet platform (soccer today; venues discovered from the marketplace registry)",
   "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/agentmessier-ai/agent-messier-plugins.git",
-    "directory": "openclaw-agent-soccer"
+    "directory": "openclaw-agent-messier"
   },
   "keywords": [
     "openclaw",

package/src/decide.ts

@@ -24,9 +24,15 @@
  * we parse that text and POST ourselves. Either way the cycle results in exactly
  * one set of moves.
  */
+import os from "node:os";
 import type { PluginRuntime } from "openclaw/plugin-sdk/core";
 import { apiKeyOf, type PluginCfg } from "./tools.js";
-import { session } from "./state.js";
+import { session, type RuntimeSession } from "./state.js";
+
+/** Agent host OS + version — sent as x-agent-os so the pitch records the platform
+ *  (NOT the machine name: os.platform/release/version/arch carry os/version/arch
+ *  only, never the hostname). Computed once (static per host); Windows-safe. */
+const AGENT_OS = `${os.platform()} ${os.release()} (${os.version()}) ${os.arch()}`;
 
 export type Vec2 = { x: number; y: number };
 
@@ -203,8 +209,10 @@ function blockText(content: unknown): string {
 }
 
 /** The text of the LAST assistant message in a getSessionMessages transcript.
- *  A fresh per-turn session yields one user + one assistant record, so this is
- *  trivially that assistant reply. Returns "" when there is no assistant text. */
+ *  With a PERSISTENT per-match session the transcript GROWS across turns
+ *  (user/assistant pairs accumulate), so we scan from the end and return the
+ *  most recent assistant reply — never an earlier turn's. Returns "" when there
+ *  is no assistant text. */
 export function lastAssistantText(messages: unknown[]): string {
   for (let i = messages.length - 1; i >= 0; i -= 1) {
     const m = messages[i];
@@ -227,6 +235,9 @@ export type ExecuteDeps = {
   token?: string | null | undefined;
   /** Reported as x-agent-decision-ms — the prompt→reply latency (ms). */
   decisionMs?: number;
+  /** Per-venue runtime session (defaults to the global one). Its lastModel rides
+   *  the header and its lastActAt is stamped on a successful POST. */
+  state?: RuntimeSession;
   /** Test seam; defaults to global fetch. */
   fetch?: typeof fetch;
 };
@@ -244,6 +255,7 @@ export async function executeMoves(
   deps: ExecuteDeps,
 ): Promise<{ posted: number; results: { playerId: string; status: number }[] }> {
   const f = deps.fetch ?? fetch;
+  const state = deps.state ?? session;
   const base = deps.base.replace(/\/$/, "");
   const results: { playerId: string; status: number }[] = [];
   for (const m of moves) {
@@ -256,25 +268,87 @@ export async function executeMoves(
       "Content-Type": "application/json",
       "x-caller-did": deps.did,
       "x-agent-runtime": "openclaw-plugin/autoplay",
+      "x-agent-os": AGENT_OS,
     };
     if (deps.token) headers["x-agent-token"] = deps.token;
+    // Model is process-wide (the llm_output hook writes the GLOBAL session), so
+    // the header reads it globally; only lastActAt below is per-venue.
     if (session.lastModel) headers["x-agent-model"] = session.lastModel;
     if (deps.decisionMs !== undefined) headers["x-agent-decision-ms"] = String(Math.max(0, Math.round(deps.decisionMs)));
     const key = apiKeyOf(deps.cfg);
     if (key) headers.Authorization = `Bearer ${key}`;
     const url = `${base}/matches/${encodeURIComponent(matchId)}/players/${encodeURIComponent(m.playerId)}/action`;
     const res = await f(url, { method: "POST", headers, body: JSON.stringify(body) });
-    if (res.ok) session.lastActAt = Date.now(); // act-verification: the team was moved this cycle
+    if (res.ok) state.lastActAt = Date.now(); // act-verification: the team was moved this cycle
     results.push({ playerId: m.playerId, status: res.status });
   }
   return { posted: results.length, results };
 }
 
+// ── decision reporting: POST every turn's decision to the pitch ──────────────
+
+export type DecisionReportDeps = {
+  base: string;
+  matchId: string;
+  /** Reporting agentId (session.did ?? agentId). */
+  agentId: string;
+  /** Seat token — sent as x-agent-token (same auth as executeMoves). */
+  token?: string | null | undefined;
+  fetch?: typeof fetch;
+  logger?: { warn: (m: string) => void };
+};
+
+export type DecisionReport = {
+  tick: number;
+  clock: number;
+  prompt: { system?: string; user: string };
+  outcome: "acted" | "no_response";
+  reason?: string;
+  moves?: Move[];
+  rawText?: string;
+  latencyMs?: number;
+  model?: string;
+};
+
+/**
+ * POST a decision report to `/matches/:id/agents/:agentId/decision` so EVERY
+ * turn — acted AND no-response — reaches the pitch's decision inspector. Auth is
+ * the seat token (x-agent-token), same as executeMoves. Best-effort and off the
+ * hot path: it NEVER throws (caller fires it `.catch`-free via this swallow) so a
+ * reporting failure can't disrupt play.
+ */
+export async function postDecisionReport(report: DecisionReport, deps: DecisionReportDeps): Promise<void> {
+  const f = deps.fetch ?? fetch;
+  const base = deps.base.replace(/\/$/, "");
+  const url = `${base}/matches/${encodeURIComponent(deps.matchId)}/agents/${encodeURIComponent(deps.agentId)}/decision`;
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  if (deps.token) headers["x-agent-token"] = deps.token;
+  try {
+    await f(url, { method: "POST", headers, body: JSON.stringify(report) });
+  } catch (e) {
+    deps.logger?.warn(`decision report POST failed: ${String(e)}`);
+  }
+}
+
 // ── the full autoplay turn: run → wait → read → parse → post ─────────────────
 
+/** Context-growth safety cap. A persistent per-match session accumulates the
+ *  agent's whole decision history (good: it remembers its own prior orders), but
+ *  a long match would otherwise grow the transcript without bound. OpenClaw
+ *  auto-compacts, but as a hard backstop we RESET the session (deleteSession +
+ *  start fresh) once a single match exceeds this many turns. Tradeoff: the agent
+ *  loses its accumulated in-match memory at the reset boundary, but context can
+ *  never grow unbounded. Keep it generous enough that most matches never hit it. */
+export const SESSION_RESET_TURN_CAP = 60;
+
 export type AutoplayTurnDeps = {
   runtime: PluginRuntime;
+  /** Stable PER-MATCH session key — persists across turns so the agent
+   *  accumulates context (its own prior decisions) and the transcript is the
+   *  full per-match request log. Reset only on leave/new-match/cap. */
   sessionKey: string;
+  /** This match's turn ordinal (0-based). Used for the reset cap only. */
+  turn: number;
   idempotencyKey: string;
   /** The strict-JSON move prompt (the per-tick board) to deliver to the agent. */
   message: string;
@@ -288,13 +362,37 @@ export type AutoplayTurnDeps = {
   did: string;
   token?: string | null;
   base: string;
+  /** Per-venue runtime session (defaults to the global one). Its lastActAt is the
+   *  act-verification signal — read for the baseline + tool-call detection, and
+   *  stamped by executeMoves on a direct post. The generated act tool stamps the
+   *  SAME instance (via generate.stateOf), so all three writers agree per venue. */
+  state?: RuntimeSession;
   logger?: { info: (m: string) => void; warn: (m: string) => void; error: (m: string) => void };
 };
 
-export type AutoplayTurnResult =
-  | { acted: true; via: "post"; posted: number }
-  | { acted: true; via: "tool" }                 // the model called soccer_play itself
-  | { acted: false; reason: string };            // responded without acting (parse miss / empty reply)
+/** Everything a decision REPORT needs, returned alongside the act outcome so the
+ *  caller (index.ts) can POST one /decision report per turn — for acted AND
+ *  no-response turns — using the tick/clock it has from the delivered frame. */
+export type AutoplayTurnObservability = {
+  /** "acted" when the team was moved this cycle (direct post OR the model's own
+   *  tool call); "no_response" when the run finished without a usable decision. */
+  outcome: "acted" | "no_response";
+  /** No-act reason (parse miss / empty reply); undefined when acted. */
+  reason?: string;
+  /** The agent's raw reply text (last assistant message), "" if unreadable. */
+  rawText: string;
+  /** Parsed moves (present only when we parsed + posted; undefined on tool/miss). */
+  moves?: Move[];
+  /** Measured prompt→reply latency (ms). */
+  latencyMs: number;
+};
+
+export type AutoplayTurnResult = AutoplayTurnObservability &
+  (
+    | { acted: true; via: "post"; posted: number }
+    | { acted: true; via: "tool" }                 // the model called soccer_play itself
+    | { acted: false }                             // responded without acting (parse miss / empty reply)
+  );
 
 /**
  * Force exactly one agent turn for a delivered situation and act on its reply.
@@ -303,9 +401,19 @@ export type AutoplayTurnResult =
  */
 export async function runAutoplayTurn(deps: AutoplayTurnDeps): Promise<AutoplayTurnResult> {
   const { runtime } = deps;
-  // act-verification baseline: if soccer_play runs during this turn it advances
-  // session.lastActAt past this — our cue to NOT double-post.
-  const actAtBefore = session.lastActAt;
+  const state = deps.state ?? session;
+  // act-verification baseline: if the act tool runs during this turn it advances
+  // this venue's lastActAt past this — our cue to NOT double-post.
+  const actAtBefore = state.lastActAt;
+
+  // Context-growth backstop: once a single match's persistent session exceeds the
+  // cap, drop it so the next run starts fresh — bounds transcript size at the
+  // cost of the agent's accumulated in-match memory (see SESSION_RESET_TURN_CAP).
+  if (deps.turn > 0 && deps.turn % SESSION_RESET_TURN_CAP === 0) {
+    await runtime.subagent.deleteSession({ sessionKey: deps.sessionKey }).catch(() => {});
+    deps.logger?.info(`session reset at turn ${deps.turn} (cap ${SESSION_RESET_TURN_CAP}) — context bounded`);
+  }
+
   const startedAt = Date.now();
 
   const { runId } = await runtime.subagent.run({
@@ -319,28 +427,36 @@ export async function runAutoplayTurn(deps: AutoplayTurnDeps): Promise<AutoplayT
   const decisionMs = Math.max(0, Date.now() - startedAt);
 
   // The model called the act tool itself (it POSTed + stamped lastActAt). Treat
-  // the cycle as acted; do NOT parse+post again (would double-apply).
-  if (session.lastActAt !== actAtBefore) {
-    return { acted: true, via: "tool" };
+  // the cycle as acted; do NOT parse+post again (would double-apply). The
+  // session PERSISTS — no deleteSession here; it's the per-match request log.
+  if (state.lastActAt !== actAtBefore) {
+    return { acted: true, via: "tool", outcome: "acted", rawText: "", latencyMs: decisionMs };
   }
 
   let text = "";
   try {
+    // The persistent transcript GROWS each turn; we read the most recent slice
+    // and lastAssistantText returns the LATEST assistant reply (not an old one).
     const { messages } = await runtime.subagent.getSessionMessages({ sessionKey: deps.sessionKey, limit: 10 });
     text = lastAssistantText(messages);
   } catch (e) {
     deps.logger?.warn(`getSessionMessages failed: ${String(e)}`);
-  } finally {
-    // Fresh session per turn → drop it so transcripts don't accumulate. Cleanup
-    // failure is non-fatal (the run already happened).
-    runtime.subagent.deleteSession({ sessionKey: deps.sessionKey }).catch(() => {});
   }
+  // NOTE: no per-turn deleteSession — the session persists for the whole match so
+  // the agent accumulates its own decision history. Reset happens only on
+  // leave/new-match (index.ts) or the turn cap above.
 
   let moves: Move[];
   try {
     moves = parseMoves(text);
   } catch (e) {
-    return { acted: false, reason: e instanceof DecideError ? e.message : String(e) };
+    return {
+      acted: false,
+      outcome: "no_response",
+      reason: e instanceof DecideError ? e.message : String(e),
+      rawText: text,
+      latencyMs: decisionMs,
+    };
   }
 
   const { posted } = await executeMoves(deps.matchId, moves, {
@@ -349,6 +465,7 @@ export async function runAutoplayTurn(deps: AutoplayTurnDeps): Promise<AutoplayT
     did: deps.did,
     token: deps.token,
     decisionMs,
+    state,
   });
-  return { acted: true, via: "post", posted };
+  return { acted: true, via: "post", posted, outcome: "acted", rawText: text, moves, latencyMs: decisionMs };
 }

package/src/generate.ts

@@ -14,17 +14,26 @@
 import { Type } from "@sinclair/typebox";
 import type { AnyAgentTool } from "openclaw/plugin-sdk/core";
 import { ok, err, venueUrl, agentIdOf, apiKeyOf, rememberDid, rememberToken, type GameSpec, type PluginCfg } from "./tools.js";
-import { session } from "./state.js";
+import { session, type RuntimeSession } from "./state.js";
 
 export type Venue = { id: string; origin: string; specUrl?: string };
 export type Seat = { id?: string; token?: string; controls?: string[]; agentId?: string; started?: boolean; managerUrl?: string };
 
-// Seat per venue (id/token/controls/agentId). The soccer seat is mirrored into
-// `session` so the existing service watcher + seat-poller keep working.
+// Seat per venue (id/token/controls/agentId).
 const seats = new Map<string, Seat>();
 export function _resetSeats(): void { seats.clear(); }
 export function seatOf(venueId: string): Seat | undefined { return seats.get(venueId); }
 
+// Per-venue runtime state. The autoplay service registers each realtime venue's
+// RuntimeSession here so the GENERATED act tool stamps the SAME lastActAt the
+// venue's watcher + decision core read (act-verification agreement across all
+// three writers). Unregistered venues (interactive-only) fall back to the global
+// session, preserving single-venue behaviour.
+const venueStates = new Map<string, RuntimeSession>();
+export function setVenueState(venueId: string, state: RuntimeSession): void { venueStates.set(venueId, state); }
+export function _resetVenueStates(): void { venueStates.clear(); }
+function stateOf(venueId: string): RuntimeSession { return venueStates.get(venueId) ?? session; }
+
 function sub(route: string, kv: Record<string, string>): string {
   return Object.entries(kv).reduce((r, [k, v]) => r.replace(`{${k}}`, encodeURIComponent(v)), route);
 }
@@ -95,8 +104,10 @@ export async function joinVenue(
   // seat.id ends up undefined and the observe loop hits /…//… → 404 → reclaim.
   const seat: Seat = { id: d[sm.id] ?? opts.matchId, token: d[sm.token], controls: d[sm.controls] ?? [], agentId: d.did ?? meId, started: d.started, managerUrl: d.managerUrl };
   seats.set(venue.id, seat);
-  // soccer back-compat: the service watcher + seat-poller read `session`.
-  session.matchId = seat.id ?? null; session.players = seat.controls ?? []; session.token = seat.token ?? null; session.did = seat.agentId ?? null;
+  // Mirror into this venue's runtime state (the global session when none is
+  // registered) so the watcher/seat-poller and interactive tools see the seat.
+  const st = stateOf(venue.id);
+  st.matchId = seat.id ?? null; st.players = seat.controls ?? []; st.token = seat.token ?? null; st.did = seat.agentId ?? null;
   return seat;
 }
 
@@ -164,15 +175,15 @@ export function generateVenueTools(venue: Venue, spec: GameSpec, cfg: PluginCfg)
         description: desc + " Set actions for ALL players you control in ONE call: pass moves=[{player, type, …}], one per player.",
         parameters: paramsSchema({}, { moves: { type: "array", items: paramsSchema(s.params ?? {}, { player: { type: "string", description: "your player id, e.g. home-9" }, type: { type: "string", enum: enumList, description: "the action" } }, ["player", "type"]) } }, ["moves"]),
         async execute(_id, params) {
-          const seat = seats.get(venue.id) ?? {}; const d = did(venue.id, cfg);
+          const seat = seats.get(venue.id) ?? {}; const d = did(venue.id, cfg); const st = stateOf(venue.id);
           const applied: unknown[] = [];
           for (const m of ((params as any).moves ?? []) as Record<string, unknown>[]) {
             const action = String(m.type ?? "").trim();
             if (!enumList.includes(action)) { applied.push({ player: m.player, error: `type must be one of ${JSON.stringify(enumList)}` }); continue; }
             const path = sub(actRoute, { matchId: seat.id ?? "", did: d, playerId: String(m.player ?? "") });
-            const body = { agentId: d, type: action, ...whitelist(m, s.params ?? {}), ...(session.lockstep ? { turn: session.turn } : {}) };
+            const body = { agentId: d, type: action, ...whitelist(m, s.params ?? {}), ...(st.lockstep ? { turn: st.turn } : {}) };
             const r = await vfetch(base, path, { cfg, did: d, method: "POST", body, token: seat.token });
-            if (r.ok) session.lastActAt = Date.now(); // act-verification: the agent moved its team this turn
+            if (r.ok) st.lastActAt = Date.now(); // act-verification: the agent moved its team this turn
             applied.push(r.ok ? { player: m.player, type: action } : { player: m.player, error: r.data?.error ?? r.status });
           }
           return ok({ applied });
@@ -187,7 +198,7 @@ export function generateVenueTools(venue: Venue, spec: GameSpec, cfg: PluginCfg)
           const path = sub(actRoute, { matchId: seat.id ?? "", did: d, playerId: String(p.player ?? "") });
           const r = await vfetch(base, path, { cfg, did: d, method: "POST", body: { type: action, ...whitelist(p, s.params ?? {}) }, token: seat.token });
           if (!r.ok) return ok({ error: r.data?.error ?? `act ${r.status}` });
-          session.lastActAt = Date.now(); // act-verification: the agent acted this turn
+          stateOf(venue.id).lastActAt = Date.now(); // act-verification: the agent acted this turn
           return ok({ type: action, result: r.data });
         } } as AnyAgentTool);
     }
@@ -204,7 +215,8 @@ export function generateVenueTools(venue: Venue, spec: GameSpec, cfg: PluginCfg)
         const path = sub(s.route, { matchId: seat.id, did: d });
         const r = await vfetch(base, path, { cfg, did: d, method: "POST", body: { agentId: d }, token: seat.token });
         // Clear our seat either way — a failed leave shouldn't leave us wedged.
-        seats.delete(venue.id); session.matchId = null; session.players = []; session.token = null;
+        seats.delete(venue.id);
+        { const st = stateOf(venue.id); st.matchId = null; st.players = []; st.token = null; }
         if (!r.ok) return ok({ error: r.data?.error ?? `leave ${r.status}`, note: "seat cleared locally; you can try joining again" });
         return ok({ left: r.data?.left ?? seat.id, ...r.data, hint: `you're free — ${c.join?.tool ?? "join"} another room` });
       } } as AnyAgentTool);
@@ -298,9 +310,25 @@ export function isRealtimeVenue(spec?: GameSpec | null): boolean {
  *  (register() is sync). Null when none is realtime. Drives seating/observe/act
  *  entirely from {venue, spec} — no soccer literals in the service. */
 export function defaultRealtimeVenue(): { venue: Venue; spec: GameSpec } | null {
+  return defaultRealtimeVenues()[0] ?? null;
+}
+
+/** EVERY realtime venue from the baked defaults — the service starts one watcher
+ *  per entry, each with its own runtime state, so multiple games (soccer + a
+ *  future golf) play concurrently without clobbering each other. Soccer is simply
+ *  the only realtime venue today; nothing here is soccer-specific. */
+export function defaultRealtimeVenues(): { venue: Venue; spec: GameSpec }[] {
+  const out: { venue: Venue; spec: GameSpec }[] = [];
   for (const venue of DEFAULT_VENUES) {
     const spec = DEFAULT_SPECS[venue.id];
-    if (isRealtimeVenue(spec)) return { venue, spec };
+    if (isRealtimeVenue(spec)) out.push({ venue, spec });
   }
-  return null;
+  return out;
+}
+
+/** Whether a venue with this client prefix is among the baked defaults — used to
+ *  gate soccer-only member tools (skins/rename/identity) so they aren't offered
+ *  on a deployment with no soccer venue. register() is sync, hence the baked set. */
+export function hasBakedVenuePrefix(prefix: string): boolean {
+  return DEFAULT_VENUES.some((v) => DEFAULT_SPECS[v.id]?.client?.prefix === prefix);
 }

package/src/probe/contention-probe.ts

@@ -0,0 +1,172 @@
+/**
+ * Watcher contention probe — diagnostic harness (NOT production code).
+ *
+ * Drives a real pitch match through the REAL watcher mechanism
+ * (startObserveWatcher: same single-in-flight latch + deliverTimeoutMs watchdog)
+ * and only swaps the `deliver` callback — exactly as production swaps in
+ * runAutoplayTurn. Confirms or disproves hypothesis B: that decisions freeze
+ * because the shared single-slot epyc2 model (llama.cpp --parallel 1) is busy.
+ *
+ * Reuses watcher.ts read-only; touches no production behaviour. Stub seats only,
+ * no paid gateways. See docs/design/watcher-contention-probe.md.
+ *
+ * Usage:
+ *   tsx src/probe/contention-probe.ts --mode fast --decisions 6
+ *   tsx src/probe/contention-probe.ts --mode slow:3000 --deliver-timeout-ms 2000
+ *   tsx src/probe/contention-probe.ts --mode real
+ *   tsx src/probe/contention-probe.ts --mode real+load:2
+ */
+import { startObserveWatcher, type DeliverPrompt } from '../watcher.js'
+import type { WatcherLogger } from '../watcher.js'
+
+// ── args ─────────────────────────────────────────────────────────────────────
+const arg = (k: string, d?: string) => {
+  const hit = process.argv.find(a => a.startsWith(`--${k}=`)) ?? process.argv[process.argv.indexOf(`--${k}`) + 1]
+  if (process.argv.includes(`--${k}`)) return process.argv[process.argv.indexOf(`--${k}`) + 1] ?? d
+  return hit?.startsWith('--') ? d : (hit?.includes('=') ? hit.split('=')[1] : d)
+}
+const BASE = process.env.BASE_URL ?? 'http://localhost:3010'
+const MODE = arg('mode', 'real')!                      // fast | slow:<ms> | real | real+load:<N>
+const DECISIONS = Number(arg('decisions', '6'))
+const TEAM_SIZE = Number(arg('team-size', '11'))
+const DELIVER_TIMEOUT_MS = Number(arg('deliver-timeout-ms', '45000'))
+const MODEL_URL = process.env.MODEL_URL ?? 'http://10.0.0.226:8080/v1'  // epyc2-local
+const MODEL_NAME = process.env.MODEL_NAME ?? 'gemma-4'
+const LOAD_CONC = Number((MODE.match(/real\+load:(\d+)/) ?? [])[1] ?? arg('load-conc', '2'))
+
+const nowMs = () => Number(process.hrtime.bigint() / 1_000_000n)
+
+// ── model backend (the injected "subagent run") ───────────────────────────────
+type LlamaTimings = { prompt_ms?: number; predicted_ms?: number }
+type Turn = { rawText: string; timings?: LlamaTimings; runStartedAt: number; completedAt: number }
+
+async function callModel(p: DeliverPrompt): Promise<Turn> {
+  const runStartedAt = nowMs()
+  const res = await fetch(`${MODEL_URL}/chat/completions`, {
+    method: 'POST', headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      model: MODEL_NAME, max_tokens: 256, temperature: 0.3,
+      messages: [{ role: 'system', content: p.system || 'You are a soccer coach.' }, { role: 'user', content: p.user }],
+    }),
+  })
+  const j = await res.json() as { choices?: { message?: { content?: string } }[]; timings?: LlamaTimings }
+  return { rawText: j.choices?.[0]?.message?.content ?? '', timings: j.timings, runStartedAt, completedAt: nowMs() }
+}
+
+function makeBackend(mode: string): (p: DeliverPrompt) => Promise<Turn> {
+  if (mode === 'fast') return async () => ({ rawText: '{"moves":{}}', runStartedAt: nowMs(), completedAt: nowMs() })
+  const slow = mode.match(/^slow:(\d+)/)
+  if (slow) {
+    const ms = Number(slow[1])
+    return async () => { const s = nowMs(); await new Promise(r => setTimeout(r, ms)); return { rawText: '{"moves":{}}', runStartedAt: s, completedAt: nowMs() } }
+  }
+  return callModel // 'real' and 'real+load:N' both call the model; load runs separately
+}
+
+// ── load generator: occupy the SAME model slot (the independent variable) ──────
+function startLoadGen(concurrency: number, signal: AbortSignal): void {
+  const oneLoop = async () => {
+    while (!signal.aborted) {
+      try {
+        await fetch(`${MODEL_URL}/chat/completions`, {
+          method: 'POST', headers: { 'content-type': 'application/json' }, signal,
+          // Long generation mimics a real interactive/reasoning turn that holds
+          // the --parallel 1 slot for many seconds (env LOAD_TOKENS to tune).
+          body: JSON.stringify({ model: MODEL_NAME, max_tokens: Number(process.env.LOAD_TOKENS ?? '1500'), temperature: 0.7,
+            messages: [{ role: 'user', content: 'Write a long, detailed essay about deep-sky astronomy and galaxy formation.' }] }),
+        }).then(r => r.json()).catch(() => {})
+      } catch { /* aborted */ }
+    }
+  }
+  for (let i = 0; i < concurrency; i++) void oneLoop()
+}
+
+// ── sample + report ────────────────────────────────────────────────────────────
+type Sample = { seq: number; queueWaitMs: number; inferenceMs: number; totalMs: number; timedOut: boolean }
+const samples: Sample[] = []
+let timeoutWarns = 0
+
+const pct = (xs: number[], p: number) => { if (!xs.length) return NaN; const s = [...xs].sort((a, b) => a - b); return s[Math.min(s.length - 1, Math.floor(p / 100 * s.length))]! }
+const r0 = (n: number) => Number.isFinite(n) ? Math.round(n) : NaN
+
+function report(): void {
+  const inf = samples.map(s => s.inferenceMs).filter(Number.isFinite)
+  const qw = samples.map(s => s.queueWaitMs).filter(Number.isFinite)
+  const tot = samples.map(s => s.totalMs)
+  const frozen = samples.filter(s => s.timedOut).length
+  console.log(`\n${'═'.repeat(64)}`)
+  console.log(`  CONTENTION PROBE — mode=${MODE}  watchdog=${DELIVER_TIMEOUT_MS}ms  n=${samples.length}`)
+  console.log(`${'═'.repeat(64)}`)
+  const row = (label: string, xs: number[]) => console.log(`  ${label.padEnd(22)} p50=${String(r0(pct(xs, 50))).padStart(7)}  p95=${String(r0(pct(xs, 95))).padStart(7)}  max=${String(xs.length ? r0(Math.max(...xs)) : NaN).padStart(7)}`)
+  if (inf.length) row('inference (compute) ms', inf)
+  if (qw.length) row('queue-wait ms', qw)
+  row('total ms', tot)
+  console.log(`  ${'─'.repeat(60)}`)
+  console.log(`  watchdog timeouts (freezes): ${frozen}/${samples.length}  ·  warn lines: ${timeoutWarns}`)
+  const verdict =
+    frozen > 0 && inf.length && pct(qw, 50) > pct(inf, 50)
+      ? '⚠ B SUPPORTED — queue-wait dominates; decisions starved by a busy slot'
+      : frozen > 0
+      ? '⚠ freezes occurred — inspect split (could be slow model, not contention)'
+      : '✓ no freezes in this run'
+  console.log(`  VERDICT: ${verdict}`)
+  console.log(`${'═'.repeat(64)}\n`)
+}
+
+// ── bootstrap a stub match (no LLM) ────────────────────────────────────────────
+async function bootstrap(): Promise<{ matchId: string; did: string; token: string; playerIds: string[] }> {
+  const agentId = `probe-${MODE.replace(/[^a-z0-9]/gi, '')}-${TEAM_SIZE}`
+  const res = await fetch(`${BASE}/quickmatch`, {
+    method: 'POST', headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ agentId, teamSize: TEAM_SIZE, name: `probe ${MODE}` }),
+  })
+  const j = await res.json() as { matchId: string; did?: string; token: string; playerIds: string[] }
+  return { matchId: j.matchId, did: j.did ?? agentId, token: j.token, playerIds: j.playerIds }
+}
+
+async function postChase(matchId: string, playerId: string, token: string): Promise<void> {
+  await fetch(`${BASE}/matches/${matchId}/players/${playerId}/action`, {
+    method: 'POST', headers: { 'content-type': 'application/json', 'x-agent-token': token },
+    body: JSON.stringify({ type: 'chase' }),
+  }).catch(() => {})
+}
+
+// ── run ─────────────────────────────────────────────────────────────────────
+async function main(): Promise<void> {
+  const { matchId, did, token, playerIds } = await bootstrap()
+  console.log(`[probe] match=${matchId} did=${did} players=${playerIds.length} mode=${MODE} → driving via REAL startObserveWatcher`)
+
+  const ac = new AbortController()
+  if (MODE.startsWith('real+load')) { startLoadGen(LOAD_CONC, ac.signal); console.log(`[probe] load generator: ${LOAD_CONC} concurrent loops on ${MODEL_URL}`) }
+
+  const backend = makeBackend(MODE)
+  const logger: WatcherLogger = {
+    info: () => {},
+    warn: (m) => { if (/exceeded \d+ms/.test(m)) timeoutWarns++ },
+    error: (m) => console.error(`[deliver error] ${m}`),
+  }
+
+  const deliver = async (p: DeliverPrompt): Promise<void> => {
+    const deliveredAt = nowMs()
+    let turn: Turn
+    try { turn = await backend(p) } catch (e) { console.error('[backend]', String(e)); return }
+    const totalMs = turn.completedAt - deliveredAt
+    const inferenceMs = turn.timings ? (turn.timings.prompt_ms ?? 0) + (turn.timings.predicted_ms ?? 0) : (MODE.startsWith('real') ? NaN : totalMs)
+    const queueWaitMs = Number.isFinite(inferenceMs) ? Math.max(0, totalMs - inferenceMs) : NaN
+    const timedOut = totalMs >= DELIVER_TIMEOUT_MS
+    samples.push({ seq: p.tick, queueWaitMs, inferenceMs, totalMs, timedOut })
+    await postChase(matchId, playerIds[1] ?? playerIds[0]!, token) // keep the seat live
+    console.log(`  decision #${samples.length} tick=${p.tick} total=${r0(totalMs)}ms infer=${r0(inferenceMs)}ms queue=${r0(queueWaitMs)}ms${timedOut ? '  ⚠TIMEOUT' : ''}`)
+    if (samples.length >= DECISIONS) ac.abort()
+  }
+
+  await startObserveWatcher(
+    { serverUrl: BASE, matchId, agentId: did, mode: 'easy', deliverTimeoutMs: DELIVER_TIMEOUT_MS },
+    deliver,
+    { signal: ac.signal, logger },
+  )
+  report()
+  process.exit(0)
+}
+
+main().catch((e) => { console.error(e); process.exit(1) })

package/src/state.ts

@@ -1,15 +1,20 @@
 /**
- * Shared plugin state, module-level so all parts of the plugin (watcher, tools,
- * service) see the same values.
+ * Per-venue autoplay runtime state.
  *
- * - `matchId`: the room this agent is currently in (set by the matchmaking
- *   tools; null until the human asks their agent to join/create a game).
- * - `players`: the player ids this agent controls (its WHOLE side).
- * - `joinAndWatch`: installed by the service at startup; matchmaking tools call
- *   it to join a room and start the observation loop.
+ * ONE `RuntimeSession` per venue the agent is actively playing. The autoplay
+ * service creates a separate instance per realtime venue (soccer, golf, …) and
+ * threads it through the watcher + decision core, so two venues running at once
+ * never clobber each other's matchId/players/token/counters. The seat itself
+ * (id/token/controls/agentId) is the per-venue `seats` map in generate.ts; this
+ * holds the loop's mutable bookkeeping. Mirrors the pitch's session-keyed
+ * decision capture (DecisionCapture keys by matchId:agentId).
+ *
+ * - `matchId`: the room this venue's loop is in (null until seated).
+ * - `players`: the player ids this agent controls at this venue (its WHOLE side).
+ * - `joinAndWatch`: installed by the service; seat into a room and start the loop.
  * - `turn`/`lockstep`: lockstep-mode bookkeeping.
  */
-export const session: {
+export type RuntimeSession = {
   matchId: string | null
   players: string[]
   /** Seat token issued by the server at join (proof of identity for actions). */
@@ -38,4 +43,18 @@ export const session: {
    *  find-or-create) and start the observe/act loop. `params` are venue join params
    *  (e.g. teamSize/team for soccer). Returns the seat the loop is now driving. */
   joinAndWatch: ((matchId?: string, params?: Record<string, unknown>) => Promise<{ id?: string; controls?: string[]; started?: boolean }>) | null
-} = { matchId: null, players: [], token: null, did: null, turn: 0, lockstep: false, lastModel: null, lastActAt: null, noActTurns: 0, promptDeliveredAt: null, joinAndWatch: null }
+}
+
+/** A fresh per-venue runtime session (all fields zeroed). */
+export function createSession(): RuntimeSession {
+  return { matchId: null, players: [], token: null, did: null, turn: 0, lockstep: false, lastModel: null, lastActAt: null, noActTurns: 0, promptDeliveredAt: null, joinAndWatch: null }
+}
+
+/**
+ * The DEFAULT/global runtime session. It backs the interactive, soccer-specific
+ * tools (pitchClient, member perks) and is the default `state` everywhere a
+ * per-venue instance isn't threaded in — so single-venue callers (and the whole
+ * existing test suite) keep working unchanged. The autoplay service overrides it
+ * per realtime venue.
+ */
+export const session: RuntimeSession = createSession()

package/src/tools.ts

@@ -19,15 +19,11 @@ const PLUGIN_VERSION: string = (() => {
 
 export type PluginCfg = {
   serverUrl?: string;
-  /** Auto quick-match at startup: find a waiting room (teamSize) or create one.
-   *  The standard zero-touch way to get a demo/bot team playing. */
+  /** Auto quick-match at startup: find-or-create a room. The standard zero-touch
+   *  way to get a demo/bot agent playing. */
   autoJoin?: boolean;
-  /** Preferred players-per-side for quick-match / created rooms (default 5). */
-  teamSize?: number;
   /** Optional: pin a specific room at startup (overrides autoJoin). */
   matchId?: string;
-  /** Optional side preference. */
-  team?: "home" | "away";
   sessionKey?: string;
   /** AgentNet API key — sent as Bearer on join so the server can verify identity
    *  (REQUIRE_AUTH). Falls back to the AGENTNET_API_KEY env var. */
@@ -35,18 +31,21 @@ export type PluginCfg = {
   /** AgentNet accounts service (person plane) — used to redeem owner claim codes. */
   accountsUrl?: string;
   mode?: "easy" | "advanced" | "both";
-  /** Default team identity (changeable at runtime via soccer_set_identity). */
-  teamName?: string;
-  nation?: string; // ISO code like NL/IT/CN → flag shown in the viewer
-  clan?: string;   // e.g. 魔兽工会-style guild tag
-  style?: string;  // playing identity, e.g. 全攻全守 total football — shapes play
   /** Path to a human-editable strategy.md injected into the watcher move prompt
    *  (Phase 5). Capped ~1k chars, mtime-cached so edits apply mid-match. */
   strategyFile?: string;
+  /** Venue-neutral display identity sent on join — e.g. {name,nation,clan,style}
+   *  for soccer; any venue's identity fields. Changeable at runtime where the
+   *  venue supports it (e.g. soccer_set_identity). */
+  identity?: Record<string, unknown>;
+  /** Venue join params merged into the join body — e.g. {teamSize,team} for
+   *  soccer, {holes} for golf. Whitelisted server-side against the venue's spec,
+   *  so unknown fields are ignored, not rejected. */
+  join?: Record<string, unknown>;
 };
 
 export function identityOf(cfg: PluginCfg): Record<string, unknown> {
-  return { name: cfg.teamName, nation: cfg.nation, clan: cfg.clan, style: cfg.style };
+  return cfg.identity ?? {};
 }
 
 // ── /spec manifest (Phase 4 — generate tools from the published action schema) ──
@@ -151,7 +150,7 @@ export function agentIdOf(cfg: PluginCfg): string {
 /** Per-agent tmp caches shared across processes (the gateway joins; chat-turn
  *  processes need the same token + DID to act). Keyed on the stable idKey. */
 function cachePath(kind: string, key: string): string {
-  return joinPath(tmpdir(), `agentnet-soccer-${kind}-${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`);
+  return joinPath(tmpdir(), `agentnet-messier-${kind}-${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`);
 }
 export function rememberToken(cfg: PluginCfg, token: string): void {
   session.token = token;
@@ -227,7 +226,7 @@ export function pitchClient(cfg: PluginCfg) {
       const res = await fetch(`${base}/quickmatch`, {
         method: "POST",
         headers: { "Content-Type": "application/json", ...RUNTIME, ...bearer() },
-        body: JSON.stringify({ agentId, teamSize: opts.teamSize ?? cfg.teamSize ?? 5, team: opts.team, identity: identityOf(cfg) }),
+        body: JSON.stringify({ agentId, teamSize: opts.teamSize ?? (cfg.join?.teamSize as number | undefined) ?? 5, team: opts.team ?? (cfg.join?.team as "home" | "away" | undefined), identity: identityOf(cfg) }),
       });
       if (!res.ok) throw new Error(`pitch quickmatch: ${res.status} ${await res.text()}`);
       const data = (await res.json()) as any;
@@ -326,6 +325,10 @@ export function venueUrl(origin: string, cfg: PluginCfg): string {
   // configured serverUrl). Short names fall back to a baked default. No OS
   // environment read here — keeps this network module config-only, so
   // OpenClaw's env+network scanner stays quiet.
+  // NOTE: a NEW venue (e.g. golf) must advertise its origin as a full http(s)
+  // URL in the registry; an unknown short name has no entry in VENUE_DEFAULTS and
+  // would fall through to the pitch URL (wrong host). Full-URL origins are the
+  // contract for any venue not co-located with the pitch.
   if (origin.startsWith("http://") || origin.startsWith("https://")) return origin;
   if (origin === "pitch") return (cfg.serverUrl ?? "http://localhost:3010").replace(/\/$/, "");
   return VENUE_DEFAULTS[origin] ?? (cfg.serverUrl ?? "http://localhost:3010");

package/src/watcher.ts

@@ -19,7 +19,7 @@
 import { statSync, readFileSync } from "node:fs";
 import { describeTeam, type TeamView } from "./format.js";
 import { fetchMatchSpec, type GameSpec, type PluginCfg } from "./tools.js";
-import { session } from "./state.js";
+import { session, type RuntimeSession } from "./state.js";
 
 export type WatcherCfg = {
   serverUrl?: string;
@@ -83,6 +83,10 @@ export type WatcherOptions = {
   /** Called when the server no longer knows our claim (404 — e.g. it restarted).
    *  Should re-claim players; the watcher then reconnects. */
   onReclaim?: () => Promise<void>;
+  /** Per-venue runtime session (defaults to the global one). The act-verification
+   *  baseline (lastActAt), the controlled-players list, and the no-act counter all
+   *  live here, so two venues' watchers don't clobber each other. */
+  state?: RuntimeSession;
 };
 
 /** One SSE block → {event?, data?}. Named events carry the per-match spec
@@ -104,8 +108,10 @@ export function parseSseBlock(block: string): { event?: string; data?: string }
  *  - `system`: the STATIC game rules (spec.instructions.system) — passed as
  *    subagent.run's extraSystemPrompt. Empty on the fallback path (no spec).
  *  - `user`: the PER-TICK board — strategy + rendered situation + play guidance
- *    + the act/JSON directive. This is what changes every tick. */
-export type DeliverPrompt = { system: string; user: string };
+ *    + the act/JSON directive. This is what changes every tick.
+ *  - `tick`/`clock`: the delivered frame's game time, threaded through so the
+ *    deliver callback can stamp the per-turn decision report. */
+export type DeliverPrompt = { system: string; user: string; tick: number; clock: number };
 
 const actDirective = (actTool: string) =>
   `Decide and act NOW: make ONE ${actTool} call with a move for every player you control — ` +
@@ -129,6 +135,8 @@ export function prompt(v: TeamView & { summary?: string }, mode: "easy" | "advan
         `${v.summary}\n\n` +
         `${ins.play}\n\n` +
         actDirective(actTool),
+      tick: v.tick,
+      clock: v.clock,
     };
   }
   // Fallback (pre-envelope server or handshake not yet arrived). describeTeam is
@@ -139,6 +147,8 @@ export function prompt(v: TeamView & { summary?: string }, mode: "easy" | "advan
   return {
     system: "",
     user: stratBlock + `${rendered}\n\n` + actDirective(actTool),
+    tick: v.tick,
+    clock: v.clock,
   };
 }
 
@@ -157,6 +167,7 @@ export async function startObserveWatcher(
   options: WatcherOptions = {},
 ): Promise<void> {
   const { signal, logger } = options;
+  const state = options.state ?? session;    // per-venue runtime (default: global)
   const base = (cfg.serverUrl ?? "http://localhost:3010").replace(/\/$/, "");
   const tag = cfg.label ?? "agentnet";       // venue-derived log prefix
   const actTool = cfg.actTool ?? "soccer_play";
@@ -196,7 +207,7 @@ export async function startObserveWatcher(
     const obs = latest;
     // Act-verification baseline: if the act tool doesn't stamp lastActAt past
     // this during the run, the agent was prompted but never moved its team.
-    const actAtBefore = session.lastActAt;
+    const actAtBefore = state.lastActAt;
 
     // The watchdog and the deliver race for the latch. Whichever fires FIRST
     // owns the release; `settled` makes the loser a no-op, so a slow deliver that
@@ -213,9 +224,9 @@ export async function startObserveWatcher(
       busy = false;
       if (onTimeout) {
         logger?.warn(`[${tag}] deliver exceeded ${deliverTimeoutMs}ms — releasing latch, agent may be stalled`);
-      } else if (session.lastActAt === actAtBefore) {
+      } else if (state.lastActAt === actAtBefore) {
         // The run finished but no action was POSTed — surfaced, never gated.
-        session.noActTurns++;
+        state.noActTurns++;
         logger?.warn(`[${tag}] agent responded without acting (turn ${seq})`);
       }
       maybeDeliver();
@@ -273,7 +284,7 @@ export async function startObserveWatcher(
           ensureSpec(); // protection: frame before handshake → fetch via API
           // The team stream is authoritative for which players we control, so
           // a live ratio change on the server is followed without reconnecting.
-          session.players = v.mine.map((p) => p.id);
+          state.players = v.mine.map((p) => p.id);
           latest = v;
           latestSeq++;
           maybeDeliver();