@agentmessier/openclaw-agent-messier 0.3.10 → 0.3.11

package/index.ts

@@ -79,7 +79,7 @@ export default function register(api: OpenClawPluginApi) {
         // 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 }) => {
             if (!sessionKey) {
               ctx.logger.warn(`[${label}] no sessionKey configured; cannot deliver move prompts.`);
               return;
@@ -101,8 +101,12 @@ export default function register(api: OpenClawPluginApi) {
               runtime: api.runtime,
               sessionKey: `${sessionKey}:${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: `${msg}${STRICT_JSON_DIRECTIVE}`,
+              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).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentmessier/openclaw-agent-messier",
-  "version": "0.3.10",
+  "version": "0.3.11",
   "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);
   }
@@ -269,8 +276,11 @@ export type AutoplayTurnDeps = {
   runtime: PluginRuntime;
   sessionKey: string;
   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;
@@ -301,6 +311,7 @@ export async function runAutoplayTurn(deps: AutoplayTurnDeps): Promise<AutoplayT
   const { runId } = await runtime.subagent.run({
     sessionKey: deps.sessionKey,
     message: deps.message,
+    ...(deps.extraSystemPrompt ? { extraSystemPrompt: deps.extraSystemPrompt } : {}),
     deliver: false,
     idempotencyKey: deps.idempotencyKey,
   });

package/src/watcher.ts

@@ -100,36 +100,46 @@ 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. */
+export type DeliverPrompt = { system: string; user: string };
+
+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),
+    };
   }
   // 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),
+  };
 }
 
 /** The observe path for a venue, from spec.routes ({matchId}/{did} substituted),
@@ -143,7 +153,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;