@agentmessier/openclaw-agent-messier 0.3.10 → 0.3.12

package/index.ts

@@ -3,7 +3,7 @@ import { memberTools, venuesTool, agentIdOf, identityOf, venueUrl, type PluginCf
 import { defaultVenueTools, defaultRealtimeVenue, joinVenue } 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 { 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. */
@@ -55,6 +55,10 @@ export default function register(api: OpenClawPluginApi) {
 
   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`,
@@ -75,11 +79,18 @@ export default function register(api: OpenClawPluginApi) {
 
         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 (msg) => {
+          async ({ system, user, tick, clock }) => {
             if (!sessionKey) {
               ctx.logger.warn(`[${label}] no sessionKey configured; cannot deliver move prompts.`);
               return;
@@ -90,30 +101,58 @@ export default function register(api: OpenClawPluginApi) {
             // 2-decisions-in-157s). soccer_play stays registered for interactive
             // chat play; only AUTOPLAY changes to 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 —
+            // and the session transcript is the full per-match request log. `turn`
+            // is kept only for the idempotency key and the context-growth cap.
             const turn = move++;
+            const matchSessionKey = `${sessionKey}:${seat.id}`;
             const idempotencyKey = `agentnet:${venue.id}:${seat.id}:${agentId}:${turn}`;
+            const did = session.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();
             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: sys,
               // Steer the agent to reply with ONLY the moves JSON (no tool call).
-              message: `${msg}${STRICT_JSON_DIRECTIVE}`,
+              message: msg,
               // 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).
               timeoutMs: 45_000,
               matchId: seat.id!,
               cfg,
-              did: session.did ?? agentId,
+              did,
               token: session.token,
               base,
               logger: ctx.logger,
             });
+            // 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: session.token, 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
@@ -182,6 +221,10 @@ export default function register(api: OpenClawPluginApi) {
       if (poller) { clearInterval(poller); poller = null; }
       controller?.abort();
       controller = null;
+      if (activeSessionKey) {
+        api.runtime.subagent.deleteSession({ sessionKey: activeSessionKey }).catch(() => {});
+        activeSessionKey = null;
+      }
       session.joinAndWatch = null;
       session.matchId = null;
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentmessier/openclaw-agent-messier",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "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",

package/src/decide.ts

@@ -35,7 +35,9 @@ export type Move = {
   type: string;
   dir?: Vec2;
   power?: number;
-  zone?: number;
+  /** Zone is now a NAME (e.g. "att-left"); an integer is accepted for back-compat
+   *  and forwarded as-is (the server normalizes name→id). */
+  zone?: string | number;
   say?: string;
 };
 
@@ -60,10 +62,11 @@ export class DecideError extends Error {
 export const STRICT_JSON_DIRECTIVE =
   `\n\nDo NOT call any tool. Reply with ONLY a JSON object — no prose, no markdown ` +
   `fences — in exactly this shape, one entry per player you control:\n` +
-  `{"moves":[{"playerId":"<id>","type":"<action>","dir":{"x":1,"y":0},"power":0.8,"zone":11,"say":"optional"}]}\n` +
+  `{"moves":[{"playerId":"<id>","type":"<action>","dir":{"x":1,"y":0},"power":0.8,"zone":"att-left","say":"optional"}]}\n` +
   `Valid action types: ${ACTION_TYPES.join(", ")}. ` +
-  `"run"/"kick" need dir {x,y}; "kick" also needs power 0..1; "push" needs zone 1..12; ` +
-  `"press"/"cover" may add zone 1..12. Omit fields an action does not need. Return the moves JSON now.`;
+  `"run"/"kick" need dir {x,y}; "kick" also needs power 0..1; "push" needs a zone NAME; ` +
+  `"press"/"cover" may add a zone NAME. Use the zone names from the board. ` +
+  `Omit fields an action does not need. Return the moves JSON now.`;
 
 // ── tolerant JSON extraction (ported from driver.ts) ─────────────────────────
 
@@ -167,7 +170,11 @@ export function parseMoves(text: string): Move[] {
     const dir = coerceDir(r.dir);
     if (dir) move.dir = dir;
     if (typeof r.power === "number" && Number.isFinite(r.power)) move.power = r.power;
-    if (Number.isInteger(r.zone) && (r.zone as number) >= 1 && (r.zone as number) <= 12) move.zone = r.zone as number;
+    // Zones are now NAMES (e.g. "att-left"); accept a non-empty string and pass
+    // it through verbatim (the server is the authority — no client-side name
+    // validation). Still accept an integer for back-compat. Anything else drops.
+    if (typeof r.zone === "string" && r.zone.trim() !== "") move.zone = r.zone;
+    else if (Number.isInteger(r.zone)) move.zone = r.zone as number;
     if (typeof r.say === "string") move.say = r.say;
     moves.push(move);
   }
@@ -196,8 +203,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];
@@ -263,14 +272,76 @@ export async function executeMoves(
   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 to deliver to the agent. */
+  /** The strict-JSON move prompt (the per-tick board) to deliver to the agent. */
   message: string;
+  /** The static game rulebook (spec.instructions.system), delivered on the run's
+   *  SYSTEM channel rather than concatenated into the per-tick board. */
+  extraSystemPrompt?: string;
   /** Backstop ceiling for waitForRun (the watcher watchdog is the latch backstop). */
   timeoutMs: number;
   matchId: string;
@@ -281,10 +352,29 @@ export type AutoplayTurnDeps = {
   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.
@@ -296,11 +386,21 @@ export async function runAutoplayTurn(deps: AutoplayTurnDeps): Promise<AutoplayT
   // 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;
+
+  // 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({
     sessionKey: deps.sessionKey,
     message: deps.message,
+    ...(deps.extraSystemPrompt ? { extraSystemPrompt: deps.extraSystemPrompt } : {}),
     deliver: false,
     idempotencyKey: deps.idempotencyKey,
   });
@@ -308,28 +408,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).
+  // 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 (session.lastActAt !== actAtBefore) {
-    return { acted: true, via: "tool" };
+    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, {
@@ -339,5 +447,5 @@ export async function runAutoplayTurn(deps: AutoplayTurnDeps): Promise<AutoplayT
     token: deps.token,
     decisionMs,
   });
-  return { acted: true, via: "post", posted };
+  return { acted: true, via: "post", posted, outcome: "acted", rawText: text, moves, latencyMs: decisionMs };
 }

package/src/watcher.ts

@@ -100,36 +100,52 @@ export function parseSseBlock(block: string): { event?: string; data?: string }
   return event !== undefined ? { event, ...(data !== undefined ? { data } : {}) } : (data !== undefined ? { data } : {});
 }
 
-export function prompt(v: TeamView & { summary?: string }, mode: "easy" | "advanced" | "both", strategyFile?: string, spec?: GameSpec | null, actTool = "soccer_play"): string {
+/** A delivered turn, split so the rulebook can ride the model's SYSTEM channel.
+ *  - `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.
+ *  - `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 — ` +
+  `every time you are prompted, even if the plan is unchanged. The order holds until you change it, ` +
+  `so if you go quiet your team freezes on stale orders. Never reply without acting.`;
+
+export function prompt(v: TeamView & { summary?: string }, mode: "easy" | "advanced" | "both", strategyFile?: string, spec?: GameSpec | null, actTool = "soccer_play"): DeliverPrompt {
   const standing = strategyText(strategyFile);
   const stratBlock = standing ? `## Your manager's standing instructions\n${standing}\n\n` : "";
   const ins = spec?.instructions;
   if (ins && ins.system && ins.play && v.summary) {
     // Generic GSP path: the server authored the instructions AND rendered the
-    // situation — the plugin only concatenates. Tool-calling host, so the
-    // direct-JSON `output` contract is replaced by a generic tool-act line
-    // (host concern, not game knowledge).
-    return (
-      `${ins.system}\n\n` +
-      stratBlock +
-      `${v.summary}\n\n` +
-      `${ins.play}\n\n` +
-      `Decide and act NOW: make ONE ${actTool} call with a move for every player you control — ` +
-      `every time you are prompted, even if the plan is unchanged. The order holds until you change it, ` +
-      `so if you go quiet your team freezes on stale orders. Never reply without acting.`
-    );
+    // situation. The rulebook (static) rides the SYSTEM channel; the board
+    // (per-tick) is the user message. Tool-calling host, so the direct-JSON
+    // `output` contract is replaced by a generic tool-act line (host concern,
+    // not game knowledge).
+    return {
+      system: ins.system,
+      user:
+        stratBlock +
+        `${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
   // the soccer-specific renderer — only valid for a TeamView; for any other
   // venue with no server instructions, dump the raw view rather than crash.
+  // No server-authored rulebook here, so the system channel is empty.
   const rendered = Array.isArray(v.mine) ? describeTeam(v, mode) : JSON.stringify(v);
-  return (
-    stratBlock +
-    `${rendered}\n\n` +
-    `Decide and act NOW: make ONE ${actTool} call with a move for every player you control — ` +
-    `every time you are prompted, even if the plan is unchanged. The order holds until you change it, ` +
-    `so if you go quiet your team freezes on stale orders. Never reply without acting.`
-  );
+  return {
+    system: "",
+    user: stratBlock + `${rendered}\n\n` + actDirective(actTool),
+    tick: v.tick,
+    clock: v.clock,
+  };
 }
 
 /** The observe path for a venue, from spec.routes ({matchId}/{did} substituted),
@@ -143,7 +159,7 @@ export function observeUrl(spec: GameSpec | null, matchId: string, did: string):
 
 export async function startObserveWatcher(
   cfg: WatcherCfg,
-  deliver: (msg: string) => void | Promise<void>,
+  deliver: (p: DeliverPrompt) => void | Promise<void>,
   options: WatcherOptions = {},
 ): Promise<void> {
   const { signal, logger } = options;