@agentmessier/openclaw-agent-messier 0.3.5 → 0.3.7

package/index.ts

@@ -25,6 +25,14 @@ export default function register(api: OpenClawPluginApi) {
     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.
+  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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentmessier/openclaw-agent-messier",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "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/generate.ts

@@ -36,6 +36,7 @@ function did(venueId: string, cfg: PluginCfg): string {
  *  what it needs: Bearer→DID for games, x-caller-did for work, seat token for acts). */
 async function vfetch(base: string, path: string, opts: { method?: string; body?: unknown; cfg: PluginCfg; token?: string; did: string }): Promise<{ ok: boolean; status: number; data: any }> {
   const headers: Record<string, string> = { "x-caller-did": opts.did, "x-agent-runtime": "openclaw-plugin/0.2.0" };
+  if (session.lastModel) headers["x-agent-model"] = session.lastModel; // effective LLM for the pitch roster
   const key = apiKeyOf(opts.cfg); if (key) headers["Authorization"] = `Bearer ${key}`;
   if (opts.token) headers["x-agent-token"] = opts.token;
   if (opts.body !== undefined) headers["Content-Type"] = "application/json";

package/src/state.ts

@@ -19,8 +19,12 @@ export const session: {
   did: string | null
   turn: number
   lockstep: boolean
+  /** Effective LLM (provider/model) of the most recent decision, captured from
+   *  the gateway's llm_output hook — sent as x-agent-model so the pitch records
+   *  the model that's actually playing (reflects a mid-match /model switch). */
+  lastModel: string | null
   /** Installed by the service: seat into a venue room (matchId omitted = quickmatch
    *  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, joinAndWatch: null }
+} = { matchId: null, players: [], token: null, did: null, turn: 0, lockstep: false, lastModel: null, joinAndWatch: null }

package/src/generate.test.ts

@@ -1,181 +0,0 @@
-import { describe, it, expect, afterEach, vi } from "vitest";
-import { generateVenueTools, defaultVenueTools, joinVenue, seatOf, defaultRealtimeVenue, isRealtimeVenue, _resetSeats } from "./generate.js";
-import { session } from "./state.js";
-import type { GameSpec, PluginCfg } from "./tools.js";
-
-function cfg(extra: Partial<PluginCfg> = {}): PluginCfg {
-  return { serverUrl: "http://pitch.test", sessionKey: "did:wba:me", ...extra };
-}
-
-// A venue the plugin has NEVER heard of — proves tools come from the spec, not code.
-const GOLF_VENUE = { id: "agent-golf", origin: "http://golf.test", specUrl: "/spec" };
-const GOLF_SPEC: GameSpec = {
-  game: "agent-golf", specVersion: 1, rulesVersion: 1,
-  actions: { type: "string", enum: ["drive", "chip", "putt"], descriptions: { drive: "tee shot", putt: "on the green" } },
-  observe: { mode: "stream", suggestedIntervalMs: 3000 },
-  routes: { observe: "/rounds/{matchId}/agents/{did}/observe", act: "/rounds/{matchId}/players/{playerId}/swing" },
-  client: {
-    prefix: "golf", noun: "round",
-    lobby: { tool: "golf_rounds", route: "/rounds", params: {}, summary: "List rounds." },
-    join: { tool: "golf_join", route: "/quickround", seatRoute: "/rounds/{matchId}/join", params: { holes: { type: "integer" }, matchId: { type: "string" } }, seat: { id: "matchId", token: "token", controls: "playerIds" }, summary: "Join a round." },
-    autoplay: { tool: "golf_autoplay", summary: "Hands-free." },
-    leave: { tool: "golf_leave", route: "/rounds/{matchId}/leave", summary: "Leave the round (forfeit if live)." },
-    observe: { tool: "golf_observe", params: {}, summary: "See the course." },
-    act: { tool: "golf_play", params: { club: { type: "string" } }, summary: "Swing." },
-  },
-};
-
-describe("generated tool surface comes entirely from the spec", () => {
-  it("baked soccer + taskmarket specs generate their canonical named tools", () => {
-    const names = defaultVenueTools(cfg()).map(t => t.name);
-    // soccer (a game, seated): lobby + join + observe + batch play
-    expect(names).toEqual(expect.arrayContaining(["soccer_matches", "soccer_join", "soccer_observe", "soccer_play"]));
-    // taskmarket (seatless work): observe + act, NO lobby/join
-    expect(names).toEqual(expect.arrayContaining(["work_observe", "work_act"]));
-    expect(names).not.toContain("work_join");
-  });
-
-  it("golf thesis: a brand-new venue's spec yields golf_* tools with ZERO plugin code", () => {
-    _resetSeats();
-    const tools = generateVenueTools(GOLF_VENUE, GOLF_SPEC, cfg());
-    const names = tools.map(t => t.name);
-    expect(names).toEqual(["golf_rounds", "golf_join", "golf_observe", "golf_play", "golf_leave"]);
-
-    // The act tool is BATCH (golf seats players) and carries the spec's action enum.
-    const play = tools.find(t => t.name === "golf_play")!;
-    const enumList = (play.parameters as any).properties.moves.items.properties.type.enum;
-    expect(enumList).toEqual(["drive", "chip", "putt"]);
-    // Per-action descriptions from the spec flow into the tool description.
-    expect(play.description).toContain("drive: tee shot");
-  });
-
-  it("the act enum tracks the spec — a server-added action surfaces with no plugin edit", () => {
-    _resetSeats();
-    const evolved: GameSpec = { ...GOLF_SPEC, actions: { ...GOLF_SPEC.actions!, enum: [...GOLF_SPEC.actions!.enum, "flop"] } };
-    const play = generateVenueTools(GOLF_VENUE, evolved, cfg()).find(t => t.name === "golf_play")!;
-    expect((play.parameters as any).properties.moves.items.properties.type.enum).toContain("flop");
-  });
-});
-
-describe("joinVenue — the one spec-driven seating path (tool + service share it)", () => {
-  afterEach(() => { vi.unstubAllGlobals(); _resetSeats(); });
-
-  it("quickmatch (no matchId) posts to client.join.route and reads the seat block", async () => {
-    let url = "", body: any = null;
-    vi.stubGlobal("fetch", vi.fn(async (u: any, init?: any) => {
-      url = String(u); body = JSON.parse(init.body);
-      return { ok: true, json: async () => ({ matchId: "r7", token: "tok", playerIds: ["p1", "p2"], did: "did:wba:me", started: false }) } as any;
-    }));
-    const seat = await joinVenue(GOLF_VENUE, GOLF_SPEC, cfg({ sessionKey: "did:wba:me" }), { params: { holes: 9 } });
-    expect(url).toBe("http://golf.test/quickround");
-    expect(body.agentId).toBe("did:wba:me");
-    expect(body.holes).toBe(9);                       // whitelisted join param
-    expect(seat.id).toBe("r7");                        // seat.id field from spec
-    expect(seat.controls).toEqual(["p1", "p2"]);       // seat.controls field
-    expect(seat.token).toBe("tok");
-    expect(seatOf("agent-golf")?.id).toBe("r7");
-    expect(session.matchId).toBe("r7");                // mirrored for the watcher
-  });
-
-  it("rejoining a KNOWN room uses seatRoute with {matchId} substituted", async () => {
-    let url = "";
-    vi.stubGlobal("fetch", vi.fn(async (u: any) => {
-      url = String(u);
-      return { ok: true, json: async () => ({ matchId: "r7", token: "t", playerIds: ["p1"] }) } as any;
-    }));
-    await joinVenue(GOLF_VENUE, GOLF_SPEC, cfg(), { matchId: "r7" });
-    expect(url).toBe("http://golf.test/rounds/r7/join");
-  });
-
-  it("rejoin response without the seat-id field falls back to the matchId joined with", async () => {
-    _resetSeats();
-    // per-room join responses omit matchId (you already know it from the URL) —
-    // seat.id must still resolve, or the observe loop 404s and reclaim-loops.
-    vi.stubGlobal("fetch", vi.fn(async () =>
-      ({ ok: true, json: async () => ({ token: "t", playerIds: ["p1", "p2", "p3"], started: true }) }) as any));
-    const seat = await joinVenue(GOLF_VENUE, GOLF_SPEC, cfg(), { matchId: "r7" });
-    expect(seat.id).toBe("r7");
-    expect(session.matchId).toBe("r7");
-  });
-
-  it("service extras (teamSize/identity) ride along but tool calls omit them", async () => {
-    let body: any = null;
-    vi.stubGlobal("fetch", vi.fn(async (_u: any, init?: any) => {
-      body = JSON.parse(init.body);
-      return { ok: true, json: async () => ({ matchId: "r1", token: "t", playerIds: [] }) } as any;
-    }));
-    await joinVenue(GOLF_VENUE, GOLF_SPEC, cfg(), { params: { holes: 18 }, extra: { teamSize: 5, identity: { name: "Eagles" } } });
-    expect(body).toMatchObject({ holes: 18, teamSize: 5, identity: { name: "Eagles" } });
-  });
-});
-
-describe("realtime-venue detection (which venue the autoplay watcher drives)", () => {
-  it("a streamed + seated + autoplay venue is realtime; seatless/poll is not", () => {
-    expect(isRealtimeVenue(GOLF_SPEC)).toBe(true);
-    expect(isRealtimeVenue({ ...GOLF_SPEC, observe: { mode: "poll", suggestedIntervalMs: 1000 } })).toBe(false);
-    expect(isRealtimeVenue({ ...GOLF_SPEC, client: { ...GOLF_SPEC.client!, join: null } } as GameSpec)).toBe(false);
-    expect(isRealtimeVenue(null)).toBe(false);
-  });
-
-  it("the baked defaults pick soccer (realtime), never the seatless taskmarket", () => {
-    const rt = defaultRealtimeVenue();
-    expect(rt?.venue.id).toBe("agent-soccer");
-    expect(rt?.spec.client?.act.tool).toBe("soccer_play");
-  });
-});
-
-describe("join-by-id and leave (the lifecycle gap closed in VA-6)", () => {
-  afterEach(() => { vi.unstubAllGlobals(); _resetSeats(); });
-
-  async function exec(name: string, params: unknown) {
-    const t = generateVenueTools(GOLF_VENUE, GOLF_SPEC, cfg()).find(x => x.name === name)!;
-    const r = await t.execute("id", params as any) as { content: { text: string }[] };
-    return JSON.parse(r.content[0]!.text);
-  }
-
-  it("the join tool routes a matchId param through seatRoute (not the body)", async () => {
-    let url = "", body: any = null;
-    vi.stubGlobal("fetch", vi.fn(async (u: any, init?: any) => {
-      url = String(u); body = JSON.parse(init.body);
-      return { ok: true, json: async () => ({ token: "t", playerIds: ["p1"] }) } as any;
-    }));
-    const out = await exec("golf_join", { matchId: "r9", holes: 9 });
-    expect(url).toBe("http://golf.test/rounds/r9/join"); // seatRoute, not /quickround
-    expect(body.holes).toBe(9);
-    expect(body.matchId).toBeUndefined();               // matchId is routing, never a body field
-    expect(out.joined).toBe("r9");
-  });
-
-  it("omitting matchId quickmatches (find-or-create) via the join route", async () => {
-    let url = "";
-    vi.stubGlobal("fetch", vi.fn(async (u: any) => {
-      url = String(u);
-      return { ok: true, json: async () => ({ matchId: "r1", token: "t", playerIds: ["p1"] }) } as any;
-    }));
-    await exec("golf_join", { holes: 9 });
-    expect(url).toBe("http://golf.test/quickround");
-  });
-
-  it("the leave tool posts to the leave route and frees the seat locally", async () => {
-    // seat first so there's a match to leave
-    vi.stubGlobal("fetch", vi.fn(async () => ({ ok: true, json: async () => ({ matchId: "r5", token: "t", playerIds: ["p1"] }) }) as any));
-    await joinVenue(GOLF_VENUE, GOLF_SPEC, cfg(), { matchId: "r5" });
-    expect(session.matchId).toBe("r5");
-
-    let url = "", method = "";
-    vi.stubGlobal("fetch", vi.fn(async (u: any, init?: any) => {
-      url = String(u); method = init?.method;
-      return { ok: true, json: async () => ({ left: "r5", forfeit: true, winner: "away" }) } as any;
-    }));
-    const out = await exec("golf_leave", {});
-    expect(method).toBe("POST");
-    expect(url).toBe("http://golf.test/rounds/r5/leave");
-    expect(out.left).toBe("r5");
-    expect(session.matchId).toBeNull();   // freed → ready to join elsewhere
-  });
-
-  it("leaving when not in a match is a no-op error, not a crash", async () => {
-    const out = await exec("golf_leave", {});
-    expect(out.error).toMatch(/not in a match/i);
-  });
-});

package/src/spec.test.ts

@@ -1,107 +0,0 @@
-import { describe, it, expect, afterEach, vi } from "vitest";
-import { fetchSpec, playActionTypes, type GameSpec, type PluginCfg } from "./tools.js";
-import { generateVenueTools } from "./generate.js";
-
-const SOCCER_VENUE = { id: "agent-soccer", origin: "pitch", specUrl: "/spec" };
-function withClient(spec: GameSpec): GameSpec {
-  return { ...spec, routes: { act: "/matches/{matchId}/players/{playerId}/action", observe: "/matches/{matchId}/agents/{did}/observe" },
-    client: { prefix: "soccer", noun: "match",
-      join: { tool: "soccer_join", route: "/quickmatch", params: {}, seat: { id: "matchId", token: "token", controls: "playerIds" }, summary: "join" },
-      observe: { tool: "soccer_observe", params: {}, summary: "see" },
-      act: { tool: "soccer_play", params: {}, summary: "order" } } };
-}
-
-// A FIXTURE manifest with a FAKE action the static list never had. Adding it
-// here must surface it in the generated tool with zero further code change.
-const FIXTURE: GameSpec = {
-  game: "agent-soccer",
-  specVersion: 1,
-  rulesVersion: 1,
-  actions: {
-    type: "string",
-    enum: ["run", "kick", "chase", "shoot", "teleport", "stop"],
-    descriptions: { teleport: "blink to the ball (test-only fake action)" },
-  },
-};
-
-function cfg(extra: Partial<PluginCfg> = {}): PluginCfg {
-  return { serverUrl: "http://pitch.test", sessionKey: `s-${Math.random().toString(36).slice(2)}`, ...extra };
-}
-
-describe("Phase 4 — soccer tools generate from /spec (static fallback when absent)", () => {
-  afterEach(() => vi.unstubAllGlobals());
-
-  it("playActionTypes derives the easy-tier enum from the manifest (fake action included)", () => {
-    const acts = playActionTypes(FIXTURE, "easy");
-    expect(acts).toContain("teleport");   // the fake action surfaced
-    expect(acts).toContain("shoot");
-    expect(acts).not.toContain("run");    // run/kick are the advanced tier, excluded from easy
-  });
-
-  it("playActionTypes falls back to the static vocabulary when spec is null", () => {
-    const acts = playActionTypes(null, "easy");
-    expect(acts).toContain("chase");
-    expect(acts).toContain("shoot");
-    expect(acts).not.toContain("teleport"); // nothing invented offline
-  });
-
-  it("fetchSpec returns the manifest from GET /spec", async () => {
-    vi.stubGlobal("fetch", vi.fn(async (url: any) => {
-      expect(String(url)).toContain("/spec");
-      return { ok: true, json: async () => FIXTURE } as any;
-    }));
-    expect(await fetchSpec(cfg())).toEqual(FIXTURE);
-  });
-
-  it("fetchSpec returns null when /spec is unreachable (offline-safe)", async () => {
-    vi.stubGlobal("fetch", vi.fn(async () => { throw new Error("ECONNREFUSED"); }));
-    expect(await fetchSpec(cfg())).toBeNull();
-  });
-
-  it("fetchSpec returns null on a non-ok response", async () => {
-    vi.stubGlobal("fetch", vi.fn(async () => ({ ok: false, status: 404, text: async () => "nope" } as any)));
-    expect(await fetchSpec(cfg())).toBeNull();
-  });
-
-  it("the generated soccer_play (batch) carries the spec's action enum (fake action included)", () => {
-    const tools = generateVenueTools(SOCCER_VENUE, withClient(FIXTURE), cfg());
-    const play = tools.find(t => t.name === "soccer_play")!;
-    const enumList: string[] = (play.parameters as any).properties.moves.items.properties.type.enum;
-    expect(enumList).toContain("teleport"); // a server-added action surfaces with zero plugin edit
-    expect(enumList).toContain("shoot");
-  });
-});
-
-// ── per-match spec snapshot + protection ladder ──────────────────────────────
-import { fetchMatchSpec } from "./tools.js";
-
-describe("fetchMatchSpec — per-game snapshot with the /spec fallback ladder", () => {
-  afterEach(() => vi.unstubAllGlobals());
-
-  it("fetches the match's snapshot first", async () => {
-    const seen: string[] = [];
-    vi.stubGlobal("fetch", vi.fn(async (url: any) => {
-      seen.push(String(url));
-      return { ok: true, json: async () => FIXTURE } as any;
-    }));
-    expect(await fetchMatchSpec(cfg(), "m7")).toEqual(FIXTURE);
-    expect(seen[0]).toContain("/matches/m7/spec");
-  });
-
-  it("falls back to server-current /spec when the match route fails (old server)", async () => {
-    const seen: string[] = [];
-    vi.stubGlobal("fetch", vi.fn(async (url: any) => {
-      seen.push(String(url));
-      if (String(url).includes("/matches/")) return { ok: false, status: 404 } as any;
-      return { ok: true, json: async () => FIXTURE } as any;
-    }));
-    expect(await fetchMatchSpec(cfg(), "m7")).toEqual(FIXTURE);
-    expect(seen.length).toBe(2);
-    expect(seen[1]).toMatch(/\/spec$/);
-  });
-
-  it("returns null when the whole ladder fails (caller stays on static fallback and retries later)", async () => {
-    vi.stubGlobal("fetch", vi.fn(async () => { throw new Error("ECONNREFUSED"); }));
-    expect(await fetchMatchSpec(cfg(), "m7")).toBeNull();
-  });
-});

package/src/tools.test.ts

@@ -1,57 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { pitchClient, agentIdOf, apiKeyOf, type PluginCfg } from "./tools.js";
-import { session } from "./state.js";
-
-// A config whose sessionKey is unique per test so the cross-process tmp caches
-// (token/did) never collide between cases.
-function cfg(extra: Partial<PluginCfg> = {}): PluginCfg {
-  return { serverUrl: "http://pitch.test", sessionKey: `t-${Math.random().toString(36).slice(2)}`, ...extra };
-}
-
-describe("soccer extension join auth", () => {
-  beforeEach(() => {
-    session.did = null;
-    session.token = null;
-    session.matchId = null;
-  });
-  afterEach(() => vi.unstubAllGlobals());
-
-  it("apiKeyOf comes from config only — never from the environment", () => {
-    expect(apiKeyOf(cfg({ apiKey: "from-cfg" }))).toBe("from-cfg");
-    // a stray env var must NOT be picked up (config-only; avoids the env+network
-    // 'credential harvesting' scanner flag and keeps config the single channel).
-    vi.stubEnv("AGENTNET_API_KEY", "from-env");
-    expect(apiKeyOf(cfg())).toBeUndefined();
-    vi.unstubAllEnvs();
-  });
-
-  it("quickMatch sends the Bearer key and learns the returned DID", async () => {
-    const seen: { auth?: string } = {};
-    vi.stubGlobal("fetch", vi.fn(async (_url: any, init: any) => {
-      seen.auth = init?.headers?.Authorization;
-      return { ok: true, json: async () => ({ matchId: "m1", team: "home", playerIds: ["h1"], started: false, did: "did:wba:tester", token: "seat-tok" }) } as any;
-    }));
-
-    const c = cfg({ apiKey: "good-key" });
-    const data = await pitchClient(c).quickMatch(agentIdOf(c), { teamSize: 5 });
-
-    expect(seen.auth).toBe("Bearer good-key");
-    expect(data.did).toBe("did:wba:tester");
-    // DID is now this agent's identity for subsequent seat lookups + calls.
-    expect(session.did).toBe("did:wba:tester");
-    expect(agentIdOf(c)).toBe("did:wba:tester");
-    expect(session.token).toBe("seat-tok");
-  });
-
-  it("omits the Authorization header when no key is configured (dev mode)", async () => {
-    const seen: { auth?: string } = {};
-    vi.stubGlobal("fetch", vi.fn(async (_url: any, init: any) => {
-      seen.auth = init?.headers?.Authorization;
-      return { ok: true, json: async () => ({ matchId: "m1", team: "home", playerIds: ["h1"], started: false, token: "seat-tok" }) } as any;
-    }));
-
-    const c = cfg(); // no apiKey, no env
-    await pitchClient(c).quickMatch(agentIdOf(c), {});
-    expect(seen.auth).toBeUndefined();
-  });
-});

package/src/venues.test.ts

@@ -1,71 +0,0 @@
-import { describe, it, expect, afterEach, vi } from "vitest";
-import { venuesTool, type GameSpec, type PluginCfg } from "./tools.js";
-import { generateVenueTools, _resetSeats } from "./generate.js";
-
-const REGISTRY = { marketplaces: [
-  { id: "agent-soccer", name: "Agent Soccer", origin: "pitch", specUrl: "/spec", feeBps: 2000, status: "live", kind: "game" },
-  { id: "taskmarket", name: "Agent Task Market", origin: "taskmarket", specUrl: "/spec", feeBps: 1000, status: "live", kind: "work" },
-] };
-
-const WORK_VENUE = { id: "taskmarket", origin: "taskmarket", specUrl: "/spec" };
-const WORK_SPEC: GameSpec = {
-  game: "taskmarket", specVersion: 1, rulesVersion: 1,
-  actions: { type: "string", enum: ["post", "bid", "deliver"], descriptions: {} },
-  observe: { mode: "poll", suggestedIntervalMs: 30000 },
-  routes: { observe: "/agents/{did}/observe", act: "/agents/{did}/action" },
-  client: {
-    prefix: "taskmarket", noun: "task", lobby: null, join: null,
-    observe: { tool: "work_observe", params: { cursor: { type: "number" } }, summary: "See the task market." },
-    act: { tool: "work_act", params: { title: { type: "string" }, description: { type: "string" }, budget: { type: "number" } }, summary: "Act in the task market." },
-  },
-};
-
-function cfg(extra: Partial<PluginCfg> = {}): PluginCfg {
-  return { serverUrl: "http://pitch.test", sessionKey: "did:wba:me", ...extra };
-}
-function workTool(name: string) {
-  const tools = generateVenueTools(WORK_VENUE, WORK_SPEC, cfg());
-  return tools.find(t => t.name === name)!;
-}
-async function runTool(t: any, params: unknown): Promise<any> {
-  const r = await t.execute("id", params as any) as { content: { text: string }[] };
-  return JSON.parse(r.content[0]!.text);
-}
-
-describe("multi-venue tools (marketplace registry → generated work tools)", () => {
-  afterEach(() => { vi.unstubAllGlobals(); _resetSeats(); });
-
-  it("venues lists the registry with kinds", async () => {
-    vi.stubGlobal("fetch", vi.fn(async (url: any) => {
-      expect(String(url)).toContain("/platform/marketplaces");
-      return { ok: true, json: async () => REGISTRY } as any;
-    }));
-    const out = await runTool(venuesTool(cfg()), {});
-    expect(out.venues.map((v: any) => v.kind)).toEqual(["game", "work"]);
-  });
-
-  it("work_observe substitutes the DID into the venue's route template", async () => {
-    const seen: string[] = [];
-    vi.stubGlobal("fetch", vi.fn(async (url: any, init?: any) => {
-      seen.push(String(url));
-      expect(init?.headers?.["x-caller-did"]).toBe("did:wba:me");
-      return { ok: true, json: async () => ({ summary: "quiet", events: [], cursor: 0 }) } as any;
-    }));
-    const out = await runTool(workTool("work_observe"), {});
-    expect(out.view.summary).toBe("quiet");
-    expect(seen.some(u => u.includes("/agents/did%3Awba%3Ame/observe") || u.includes("/agents/did:wba:me/observe"))).toBe(true);
-  });
-
-  it("work_act validates against the venue enum and posts the uniform body", async () => {
-    let posted: any = null;
-    vi.stubGlobal("fetch", vi.fn(async (_url: any, init?: any) => {
-      posted = JSON.parse(init.body);
-      return { ok: true, json: async () => ({ id: "task-1", status: "open" }) } as any;
-    }));
-    const bad = await runTool(workTool("work_act"), { type: "fly" });
-    expect(bad.error).toContain("post");
-    const ok2 = await runTool(workTool("work_act"), { type: "post", title: "t", description: "d", budget: 5 });
-    expect(ok2.result.id).toBe("task-1");
-    expect(posted).toEqual({ type: "post", title: "t", description: "d", budget: 5 });
-  });
-});

package/src/watcher.test.ts

@@ -1,137 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, writeFileSync, rmSync, utimesSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { strategyText, _clearStrategyCache, prompt, parseSseBlock } from "./watcher.js";
-import type { TeamView } from "./format.js";
-import type { GameSpec } from "./tools.js";
-
-let dir: string;
-beforeEach(() => { dir = mkdtempSync(join(tmpdir(), "soccer-strat-")); _clearStrategyCache(); });
-afterEach(() => { rmSync(dir, { recursive: true, force: true }); });
-
-const VIEW = {
-  tick: 1, clock: 0, phase: "live", team: "home",
-  score: { home: 0, away: 0 },
-  field: { length: 105, width: 68, attackGoal: { x: 52.5, y: 0 }, ownGoal: { x: -52.5, y: 0 }, goalHalfWidth: 3.66, tickHz: 10 },
-  mine: [{ id: "home-9", number: 9, pos: { x: 0, y: 0 }, vel: { x: 0, y: 0 }, hasBall: true }],
-  ball: { pos: { x: 0, y: 0 }, vel: { x: 0, y: 0 }, owner: "home-9" },
-  teammates: [], opponents: [],
-} as unknown as TeamView;
-
-describe("Phase 5 — strategyText (mtime-cached, capped) + prompt injection", () => {
-  it("returns '' when the file is absent", () => {
-    expect(strategyText(join(dir, "nope.md"))).toBe("");
-    expect(strategyText(undefined)).toBe("");
-  });
-
-  it("reads a present file", () => {
-    const f = join(dir, "strategy.md");
-    writeFileSync(f, "Press high. Keep the ball.");
-    expect(strategyText(f)).toContain("Press high");
-  });
-
-  it("caps the injected text at ~1k chars", () => {
-    const f = join(dir, "strategy.md");
-    writeFileSync(f, "x".repeat(5000));
-    expect(strategyText(f).length).toBeLessThanOrEqual(1000);
-  });
-
-  it("refreshes when the file mtime changes", () => {
-    const f = join(dir, "strategy.md");
-    writeFileSync(f, "first plan");
-    expect(strategyText(f)).toContain("first plan");
-    writeFileSync(f, "second plan");
-    const future = new Date(Date.now() + 5000);
-    utimesSync(f, future, future);
-    const out = strategyText(f);
-    expect(out).toContain("second plan");
-    expect(out).not.toContain("first plan");
-  });
-
-  it("prompt injects the strategy block when a strategyFile is set", () => {
-    const f = join(dir, "strategy.md");
-    writeFileSync(f, "Park the bus. Counter fast.");
-    const p = prompt(VIEW, "easy", f);
-    expect(p.toLowerCase()).toContain("standing instructions");
-    expect(p).toContain("Park the bus");
-  });
-
-  it("prompt has no strategy block when the file is absent", () => {
-    const p = prompt(VIEW, "easy", join(dir, "missing.md"));
-    expect(p.toLowerCase()).not.toContain("standing instructions");
-  });
-});
-
-// ── the self-instructable envelope (generic GSP client) ─────────────────────
-const SPEC = {
-  game: "agent-soccer", specVersion: 1, rulesVersion: 2,
-  actions: { type: "string", enum: ["chase", "shoot", "lob"], descriptions: { lob: "chip it" } },
-  instructions: {
-    system: "You are a decisive tactician.",
-    play: "SERVER PLAY GUIDANCE: lob when the keeper is off his line.",
-    output: 'Reply with ONLY JSON {"moves":{...}}',
-  },
-} as unknown as GameSpec;
-
-const VIEW_WITH_SUMMARY = { ...VIEW, summary: "⚽ SERVER-RENDERED SITUATION." } as TeamView & { summary: string };
-
-describe("generic prompt — instructions + summary come from the server", () => {
-  it("uses the server's instructions and summary when a spec is cached", () => {
-    const p = prompt(VIEW_WITH_SUMMARY, "easy", undefined, SPEC, "golf_play");
-    expect(p).toContain("SERVER-RENDERED SITUATION");
-    expect(p).toContain("SERVER PLAY GUIDANCE");
-    // tool-calling host: act via the venue's act tool, named from the spec
-    expect(p).toContain("golf_play");
-    // the plugin's hardcoded soccer prose is gone on this path
-    expect(p).not.toContain("YOU ATTACK +x: opponent goal at x=+52.5");
-  });
-
-  it("keeps the strategy block on the generic path", () => {
-    const f = join(dir, "strategy.md");
-    writeFileSync(f, "Park the bus tonight.");
-    const p = prompt(VIEW_WITH_SUMMARY, "easy", f, SPEC);
-    expect(p).toContain("Park the bus tonight");
-    expect(p).toContain("SERVER PLAY GUIDANCE");
-  });
-
-  it("falls back to local rendering when there is no spec (old server)", () => {
-    const p = prompt(VIEW, "easy", undefined, null);
-    expect(p).toContain("soccer_play"); // the legacy describeTeam path
-  });
-});
-
-describe("parseSseBlock — named events for the handshake", () => {
-  it("parses a named event block", () => {
-    const b = parseSseBlock('event: spec\ndata: {"game":"agent-soccer"}');
-    expect(b.event).toBe("spec");
-    expect(JSON.parse(b.data!)).toEqual({ game: "agent-soccer" });
-  });
-
-  it("parses a plain data block (no event name)", () => {
-    const b = parseSseBlock('data: {"tick":1}');
-    expect(b.event).toBeUndefined();
-    expect(JSON.parse(b.data!)).toEqual({ tick: 1 });
-  });
-
-  it("ignores comments and empty payloads", () => {
-    expect(parseSseBlock(": connected").data).toBeUndefined();
-    expect(parseSseBlock("data: ").data).toBeUndefined();
-  });
-});
-
-import { observeUrl } from "./watcher.js";
-
-describe("observeUrl — venue-agnostic observe endpoint (VA-4)", () => {
-  it("substitutes spec.routes.observe with matchId + did", () => {
-    const spec = { routes: { observe: "/matches/{matchId}/agents/{did}/observe" } } as any;
-    expect(observeUrl(spec, "m7", "did:wba:me")).toBe("/matches/m7/agents/did%3Awba%3Ame/observe");
-  });
-  it("uses a non-soccer venue's route shape unchanged", () => {
-    const spec = { routes: { observe: "/golf/{matchId}/player/{did}/look" } } as any;
-    expect(observeUrl(spec, "g3", "alice")).toBe("/golf/g3/player/alice/look");
-  });
-  it("falls back to the soccer-literal route when no spec", () => {
-    expect(observeUrl(null, "m9", "bob")).toBe("/matches/m9/agents/bob/observe");
-  });
-});