@weavetab/plugin-realtime 0.2.0 → 0.3.0

package/AGENTS.md

@@ -0,0 +1,19 @@
+# Realtime Plugin — Agent Playbook
+
+60Hz in-page reflex engine, causal DOM age/proximity tagging, Canvas2D entity tracking, and bounded click autopilot (`@weavetab/plugin-realtime`).
+
+## MCP Tools
+- `realtime_canvas`: Sample Canvas2D draw calls (`sample`, `attach`, `detach`, `frames`) to get entities and px/frame velocity.
+- `realtime_reflex`: Arm, remove, list, or clear 60Hz `requestAnimationFrame` DOM or Canvas2D reflex rules (`action`, `when`, `do`).
+- `realtime_autopilot`: Run a bounded click loop toward a short goal (`goal`, `stop_when_selector`, `stop_when_text`).
+- `realtime_status`: Inspect probe status, canvas frame count, and reflex hits (`wait_ms`).
+
+## CLI Commands (`weavetab plugin use realtime <cmd>`)
+- `weavetab plugin use realtime status [--wait_ms 2000]`: Inspect live probe and reflex rules.
+- `weavetab plugin use realtime reflex-clear`: Clear all active 60Hz reflex rules on the active tab.
+- `weavetab plugin use realtime autopilot --goal <text>`: Run bounded click autopilot via CLI.
+
+## Utilities (`/` Prompts & `@` Resources)
+- `/realtime_watch`: Snapshot live DOM/canvas state and wire a 60Hz reflex rule.
+- `@realtime://feed`: Live JSON feed of newly added DOM elements, reflexes, and canvas entities.
+- `@realtime://canvas`: Live inspection of Canvas2D draw count, rAF FPS, and moving bounding boxes.

package/dist/canvas.js

@@ -69,12 +69,32 @@ const SPY = `(() => {
     });
   };
 
+  const matchSig = (pattern, s) => {
+    if (!pattern) return false;
+    if (pattern === '*' || pattern === true) return true;
+    if (Array.isArray(pattern)) return pattern.some((p) => matchSig(p, s));
+    if (typeof pattern !== 'string') return false;
+    if (pattern.indexOf('*') < 0) return s === pattern;
+    const parts = pattern.split('*');
+    if (!s.startsWith(parts[0])) return false;
+    if (!s.endsWith(parts[parts.length - 1])) return false;
+    let idx = 0;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (!part) continue;
+      const found = s.indexOf(part, idx);
+      if (found < 0) return false;
+      idx = found + part.length;
+    }
+    return true;
+  };
+
   cv.track = (sig, depth) => {
     const fr = cv.frames;
     if (!fr.length) return [];
-    const last = fr[fr.length - 1].d.filter((d) => d.sig === sig);
+    const last = fr[fr.length - 1].d.filter((d) => matchSig(sig, d.sig));
     if (last.length > 200) return last.map((d) => Object.assign({ vx: 0, vy: 0 }, d));
-    const prevs = fr.slice(Math.max(0, fr.length - 1 - depth), -1).reverse().map((f) => f.d.filter((d) => d.sig === sig));
+    const prevs = fr.slice(Math.max(0, fr.length - 1 - (depth || 2)), -1).reverse().map((f) => f.d.filter((d) => matchSig(sig, d.sig)));
     return last.map((d) => {
       let cur = d, steps = 0;
       for (const p of prevs) {

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-declare const plugin: import("@weavetab/sdk").WeavetabPluginDefinition;
-export default plugin;
-export { plugin };
+export declare const realtimePlugin: import("@weavetab/sdk").WeavetabPluginDefinition;
+export default realtimePlugin;
+export declare const plugin: import("@weavetab/sdk").WeavetabPluginDefinition;

package/dist/index.js

@@ -1,61 +1,133 @@
-import { definePlugin, defineTool, definePrompt, defineResource, z } from "@weavetab/sdk";
-import { arm, sessOf } from "./page.js";
+import { definePlugin, defineTool, defineCommand, definePrompt, defineResource, z, } from "@weavetab/sdk";
+import { sessOf, arm } from "./page.js";
 import { tagMap } from "./causal.js";
 import { canvasTool } from "./canvas.js";
 import { reflexTool, statusTool } from "./reflex.js";
 import { autopilotTool } from "./autopilot.js";
 import { readFeed } from "./surface.js";
-let winMs = 4000;
-const asText = (v) => ({ content: [{ type: "text", text: JSON.stringify(v, null, 2) }] });
-const plugin = definePlugin({
-    name: "@weavetab/plugin-realtime",
-    version: "0.2.0",
-    description: "Causal tags for browser_map, in-page reflex rules, canvas entity sampling, bounded click loop.",
-    defaultConfig: { causalWindowMs: 4000 },
-    permissions: {
-        cdp: { evaluate: true, input: true, reason: "Page probe, canvas spy, 60Hz reflex loop, and trusted CDP mouse clicks." },
-        tools: { add: true, reason: "Registers realtime_canvas, realtime_reflex, realtime_autopilot and realtime_status." },
-        prompts: { add: true, reason: "Registers /realtime_watch to guide setting up 60Hz DOM or canvas reflexes." },
-        resources: { add: true, reason: "Registers @realtime_feed (realtime://feed) for live reflex, DOM, and canvas telemetry." },
-        hooks: { onBeforeAction: true, onAfterAction: true, reason: "Arms page probe and appends {new ...} causal tags to browser_map." },
-        network: { hosts: ["127.0.0.1", "localhost"], reason: "Optional local model_url in realtime_autopilot." },
+const statusCommand = defineCommand({
+    name: "status",
+    description: "Read the in-page realtime probe state, canvas frame counter, and active 60Hz reflex rules.",
+    usage: "weavetab plugin use realtime status [--wait_ms <ms>]",
+    requiresSession: true,
+    schema: {
+        wait_ms: z.number().optional().describe("Block up to wait_ms until active reflexes finish"),
     },
-    async onBeforeAction(_tool, _args, sess) {
-        if (sess?.Runtime)
-            await arm(sess).catch(() => { }); // page may be mid-navigation, next call retries
+    handler: async (args, ctx) => {
+        const sess = sessOf(ctx);
+        return await statusTool(sess, Number(args.wait_ms || 0));
     },
-    async onAfterAction(tool, res, sess) {
-        if (tool !== "browser_map" || !sess?.Runtime)
-            return;
-        return tagMap(sess, res, winMs).catch(() => undefined);
+});
+const reflexClearCommand = defineCommand({
+    name: "reflex-clear",
+    description: "Clear all active 60Hz reflex rules on the active browser tab via CLI.",
+    usage: "weavetab plugin use realtime reflex-clear",
+    requiresSession: true,
+    handler: async (_args, ctx) => {
+        const sess = sessOf(ctx);
+        return await reflexTool(sess, { action: "clear" });
+    },
+});
+const autopilotCommand = defineCommand({
+    name: "autopilot",
+    description: "Run bounded in-page autopilot toward a goal directly via CLI.",
+    usage: "weavetab plugin use realtime autopilot --goal <text> [--max_steps <n>]",
+    requiresSession: true,
+    schema: {
+        goal: z.string().describe("Natural language click goal"),
+        max_steps: z.number().optional().describe("Maximum click steps (default 5)"),
+        stop_when_text: z.string().optional().describe("Stop when this text appears"),
+    },
+    handler: async (args, ctx) => {
+        const sess = sessOf(ctx);
+        return await autopilotTool(sess, {
+            goal: args.goal,
+            max_steps: args.max_steps ?? 5,
+            stop_when_text: args.stop_when_text,
+        });
     },
+});
+export const realtimePlugin = definePlugin({
+    name: "@weavetab/plugin-realtime",
+    version: "0.3.0",
+    description: "Causal age/proximity tags for browser_map, 60Hz in-page reflex rules, canvas entity sampling and a bounded click loop.",
+    agentsMd: "AGENTS.md",
+    defaultConfig: {
+        causalWindowMs: 4000,
+    },
+    permissions: {
+        cdp: {
+            evaluate: true,
+            input: true,
+            reason: "Installs the in-page MutationObserver, hooks Canvas2D/rAF, and dispatches click/key events.",
+        },
+        tools: {
+            add: true,
+            reason: "Registers realtime_canvas, realtime_reflex, realtime_autopilot, and realtime_status.",
+        },
+        commands: {
+            add: true,
+            reason: "Registers status and reflex-clear CLI commands.",
+        },
+        prompts: {
+            add: true,
+            reason: "Registers the /realtime_watch prompt utility.",
+        },
+        resources: {
+            add: true,
+            reason: "Registers the @realtime_feed resource utility.",
+        },
+        hooks: {
+            onBeforeAction: true,
+            onAfterAction: true,
+            reason: "Arms the in-page mutation probe before actions and tags newly added nodes in browser_map output.",
+        },
+        network: {
+            domains: ["127.0.0.1", "localhost"],
+            reason: "Allows realtime_autopilot to query an optional local OpenAI-compatible model endpoint.",
+        },
+    },
+    commands: [statusCommand, reflexClearCommand, autopilotCommand],
     async onLoad(ctx) {
-        winMs = Number(ctx.config?.causalWindowMs) || 4000;
-        const reg = ctx.mcp.registerTool;
-        reg(defineTool({
+        const winMs = typeof ctx.config?.causalWindowMs === "number" ? ctx.config.causalWindowMs : 4000;
+        ctx.cli?.registerCommand?.(statusCommand);
+        ctx.cli?.registerCommand?.(reflexClearCommand);
+        ctx.cli?.registerCommand?.(autopilotCommand);
+        ctx.mcp.registerTool(defineTool({
             name: "realtime_canvas",
-            description: "Sample what a 2D <canvas> game draws. 'sample' watches a few frames and returns entities (signature, bbox, px/frame velocity) in canvas pixels, plus canvas position/scale to convert to viewport coords. Only sees Canvas2D draw calls made inside requestAnimationFrame; WebGL is invisible to it. 'attach' starts recording early, 'detach' restores the page.",
+            description: "Records Canvas2D draw calls across requestAnimationFrame ticks and returns moving/static entities with bounding boxes and px/frame velocity.",
             requiresSession: true,
             schema: {
-                action: z.enum(["sample", "attach", "detach"]).default("sample"),
-                frames: z.number().int().min(2).max(15).optional().describe("frames to watch, default 6"),
+                action: z.enum(["sample", "attach", "detach"]).optional().describe("sample (default), attach, or detach"),
+                frames: z.number().optional().describe("Frames to sample (2-15, default 6)"),
+            },
+            handler: async (args, rawCtx) => {
+                const out = await canvasTool(sessOf(rawCtx), {
+                    action: args.action || "sample",
+                    frames: args.frames,
+                });
+                return { content: [{ type: "text", text: JSON.stringify(out, null, 2) }] };
             },
-            handler: async (a, ctx) => asText(await canvasTool(sessOf(ctx), a)),
         }));
-        reg(defineTool({
+        ctx.mcp.registerTool(defineTool({
             name: "realtime_reflex",
-            description: "Register a rule that runs inside the page every animation frame, no LLM round-trip. Trigger is either a DOM selector (optionally text / only_new) or a canvas expression over named entity signatures from realtime_canvas: names {player:'rect|20x20|#f00'}, js \"gap(E.player[0], E.cactus[0]) < 50\" (E.name = array of {x,y,w,h,vx,vy}; dist() and gap() return Infinity when an entity is missing). Action: click, click_xy, key, or js. Events are synthetic, sites that check isTrusted ignore them. Needs a visible tab.",
+            description: "Registers, removes, lists, or clears in-page 60Hz requestAnimationFrame rules that click or press keys on DOM or Canvas2D triggers without an LLM round-trip.",
             requiresSession: true,
             schema: {
-                action: z.enum(["add", "remove", "list", "clear"]).default("add"),
-                id: z.string().optional(),
+                action: z.enum(["add", "remove", "list", "clear"]).describe("Operation to perform"),
+                id: z.string().optional().describe("Rule identifier"),
                 when: z
                     .object({
                     selector: z.string().optional(),
-                    text: z.string().optional().describe("case-insensitive substring of label/text"),
-                    only_new: z.boolean().optional().describe("only elements added after this rule was created"),
-                    enabled: z.boolean().optional().describe("skip disabled elements, default true"),
-                    canvas: z.object({ names: z.record(z.string()), js: z.string() }).optional(),
+                    text: z.string().optional(),
+                    only_new: z.boolean().optional(),
+                    enabled: z.boolean().optional(),
+                    canvas: z
+                        .object({
+                        names: z.record(z.string(), z.union([z.string(), z.array(z.string())])),
+                        js: z.string(),
+                    })
+                        .optional(),
                 })
                     .optional(),
                 do: z
@@ -64,72 +136,107 @@ const plugin = definePlugin({
                     x: z.number().optional(),
                     y: z.number().optional(),
                     key: z.string().optional(),
-                    hold_ms: z.number().optional().describe("key hold time, default 40"),
+                    hold_ms: z.number().optional(),
                     code: z.string().optional(),
                 })
                     .optional(),
-                cooldown_ms: z.number().optional().describe("default 100"),
-                max_hits: z.number().optional().describe("default 50"),
-                ttl_ms: z.number().optional().describe("default 30000, max 600000"),
+                cooldown_ms: z.number().optional(),
+                max_hits: z.number().optional(),
+                ttl_ms: z.number().optional(),
                 stop_selector: z.string().optional(),
             },
-            handler: async (a, ctx) => asText(await reflexTool(sessOf(ctx), a)),
+            handler: async (args, rawCtx) => {
+                const out = await reflexTool(sessOf(rawCtx), args);
+                return { content: [{ type: "text", text: JSON.stringify(out, null, 2) }] };
+            },
         }));
-        reg(defineTool({
+        ctx.mcp.registerTool(defineTool({
             name: "realtime_autopilot",
-            description: "Bounded click loop for short UI sub-goals ('accept cookies', 'click next until Order summary shows'). Ranks visible, unoccluded clickable elements by word overlap with the goal, boosts ones that just appeared and ones inside an open dialog, and never re-clicks a button whose last click changed nothing. Trusted CDP mouse clicks. Skips delete/pay/sign-out style labels unless the goal says so. Not a planner: stops with no_match when no label overlaps the goal. Optional model_url = OpenAI-compatible chat endpoint to pick instead; falls back to the ranker on any failure.",
+            description: "Runs a bounded in-page click loop toward a short goal ('accept cookies', 'continue') with causal age/dialog scoring and optional local model pick.",
             requiresSession: true,
             schema: {
-                goal: z.string().min(3),
-                max_steps: z.number().int().min(1).max(25).optional().describe("default 8"),
+                goal: z.string().describe("Short natural-language click goal"),
+                max_steps: z.number().optional(),
                 stop_when_selector: z.string().optional(),
                 stop_when_text: z.string().optional(),
-                stop_when_url: z.string().optional().describe("regex tested against location.href"),
-                avoid_labels: z.string().optional().describe("regex of extra labels never to click"),
-                model_url: z.string().url().optional(),
+                stop_when_url: z.string().optional(),
+                avoid_labels: z.string().optional(),
+                model_url: z.string().optional(),
                 model: z.string().optional(),
-                model_timeout_ms: z.number().optional().describe("default 1500"),
+                model_timeout_ms: z.number().optional(),
+            },
+            handler: async (args, rawCtx) => {
+                const out = await autopilotTool(sessOf(rawCtx), args);
+                return { content: [{ type: "text", text: JSON.stringify(out, null, 2) }] };
             },
-            handler: async (a, ctx) => asText(await autopilotTool(sessOf(ctx), a)),
         }));
-        reg(defineTool({
+        ctx.mcp.registerTool(defineTool({
             name: "realtime_status",
-            description: "Probe/canvas/reflex state for the current page. wait_ms (max 30000) blocks until every active reflex has finished, so the agent can sleep through a game or a drop-watch.",
+            description: "Returns the live state of the in-page probe, Canvas2D spy, and active 60Hz reflex rules. Optionally waits until reflexes complete.",
             requiresSession: true,
-            schema: { wait_ms: z.number().optional() },
-            handler: async (a, ctx) => asText(await statusTool(sessOf(ctx), a.wait_ms)),
+            schema: {
+                wait_ms: z.number().optional().describe("Wait up to wait_ms (max 30000) for active reflexes to finish"),
+            },
+            handler: async (args, rawCtx) => {
+                const out = await statusTool(sessOf(rawCtx), args.wait_ms ?? 0);
+                return { content: [{ type: "text", text: JSON.stringify(out, null, 2) }] };
+            },
         }));
-        ctx.mcp.registerPrompt?.(definePrompt({
+        ctx.mcp.registerPrompt(definePrompt({
             name: "realtime_watch",
-            title: "Watch & React (60Hz Reflex)",
-            description: "Set up an in-page 60Hz reflex rule or canvas game loop and wait until it finishes.",
+            description: "Snapshot live DOM mutations, active reflexes, and Canvas2D entities, then guide the agent to wire a 60Hz reflex rule.",
             arguments: {
-                goal: z.string().describe("What to watch for and trigger (e.g. 'click Claim as soon as it appears' or 'jump over green obstacles in the canvas game')"),
-                mode: z.string().optional().describe("'dom', 'canvas', or 'auto' (default 'auto')"),
+                goal: z.string().describe("What the reflex should watch for and do"),
+                mode: z.enum(["auto", "dom", "canvas"]).optional().describe("Trigger mode (default: auto)"),
             },
-            handler: async ({ goal, mode }, sctx) => {
-                const feed = await readFeed(sessOf(sctx), winMs).catch(() => ({ active_tab: false }));
-                const m = (mode || "auto").toLowerCase();
+            handler: async (args, rawCtx) => {
+                const feed = await readFeed(sessOf(rawCtx), winMs);
                 return [
-                    `Goal: ${goal}`,
-                    `Mode: ${m}`,
-                    `Live state: ${JSON.stringify(feed)}`,
-                    m === "canvas"
-                        ? "1. Call realtime_canvas with action='sample' to inspect moving entity signatures and velocities.\n2. Arm realtime_reflex with when.canvas ({ names, js }) using gap(E.a[0], E.b[0]) or dist(E.a[0], E.b[0]).\n3. Call realtime_status with wait_ms to block until the reflex completes."
-                        : "1. If targeting a 2D <canvas>, run realtime_canvas (action='sample') first to grab entity signatures; if targeting DOM changes, pick a selector/text filter (set only_new=true to ignore elements already on screen).\n2. Arm the rule with realtime_reflex (action='add').\n3. Call realtime_status with wait_ms (up to 30000) to sleep until the reflex hits max_hits or stop_selector.",
-                ].join("\n\n");
+                    `Goal: ${args.goal}`,
+                    `Mode: ${args.mode || "auto"}`,
+                    `Live feed: ${JSON.stringify(feed)}`,
+                    `Use realtime_canvas, realtime_reflex, and realtime_status to arm and verify the rule.`,
+                ].join("\n");
             },
         }));
-        ctx.mcp.registerResource?.(defineResource({
+        ctx.mcp.registerResource(defineResource({
+            name: "realtime_canvas_feed",
+            uri: "realtime://canvas",
+            description: "Live snapshot of Canvas2D draw counts, rAF frame rate, and active moving entity bounding boxes.",
+            mimeType: "application/json",
+            read: async (_uri, _vars, rawCtx) => {
+                const sess = sessOf(rawCtx);
+                const canvasData = await canvasTool(sess, { action: "sample", frames: 3 });
+                return JSON.stringify(canvasData, null, 2);
+            },
+        }));
+        ctx.mcp.registerResource(defineResource({
             name: "realtime_feed",
-            title: "Realtime Page Feed",
             uri: "realtime://feed",
+            description: "Live snapshot of newly mutated DOM elements (with click distance), active 60Hz reflex rules, and tracked Canvas2D entities.",
             mimeType: "application/json",
-            description: "Live snapshot of active 60Hz reflex rules, recently mutated DOM elements with click distance, and tracked Canvas2D entities.",
-            read: async (_uri, _vars, sctx) => JSON.stringify(await readFeed(sessOf(sctx), winMs), null, 2),
+            read: async (_uri, _vars, rawCtx) => {
+                const feed = await readFeed(sessOf(rawCtx), winMs);
+                return JSON.stringify(feed, null, 2);
+            },
         }));
-        ctx.logger?.info("realtime up");
+        ctx.logger?.info("@weavetab/plugin-realtime loaded");
+    },
+    async onBeforeAction(_action, _args, rawCtx) {
+        const sess = sessOf(rawCtx);
+        if (sess?.Runtime) {
+            await arm(sess).catch(() => { });
+        }
+    },
+    async onAfterAction(action, result, rawCtx) {
+        if (action !== "browser_map")
+            return;
+        const sess = sessOf(rawCtx);
+        if (!sess?.Runtime)
+            return;
+        const winMs = typeof rawCtx?.config?.causalWindowMs === "number" ? rawCtx.config.causalWindowMs : 4000;
+        return await tagMap(sess, result, winMs).catch(() => undefined);
     },
 });
-export default plugin;
-export { plugin };
+export default realtimePlugin;
+export const plugin = realtimePlugin;

package/dist/reflex.d.ts

@@ -7,7 +7,7 @@ type Rule = {
         only_new?: boolean;
         enabled?: boolean;
         canvas?: {
-            names: Record<string, string>;
+            names: Record<string, string | string[]>;
             js: string;
         };
     };

package/dist/reflex.js

@@ -16,7 +16,11 @@ const RUNTIME = `(() => {
     const o = { key: k, code: c[0], keyCode: c[1], which: c[1], bubbles: true, cancelable: true };
     const tgt = document.activeElement || document.body;
     tgt.dispatchEvent(new KeyboardEvent('keydown', o));
-    setTimeout(() => tgt.dispatchEvent(new KeyboardEvent('keyup', o)), hold);
+    if (tgt !== document) document.dispatchEvent(new KeyboardEvent('keydown', o));
+    setTimeout(() => {
+      tgt.dispatchEvent(new KeyboardEvent('keyup', o));
+      if (tgt !== document) document.dispatchEvent(new KeyboardEvent('keyup', o));
+    }, hold);
   };
   const click = (el, x, y) => {
     if (x == null) { const b = el.getBoundingClientRect(); x = b.left + b.width / 2; y = b.top + b.height / 2; }
@@ -48,8 +52,12 @@ const RUNTIME = `(() => {
   const dist = (a, b) => (a && b) ? Math.hypot(a.x + a.w / 2 - b.x - b.w / 2, a.y + a.h / 2 - b.y - b.h / 2) : Infinity;
   const gap = (a, b) => (a && b) ? b.x - (a.x + a.w) : Infinity;
   const E = new Proxy({}, { get: (_, k) => {
-    const cv = window.__wt_cv, sig = rf.names && rf.names[k];
-    return cv && sig ? cv.track(sig, 2) : [];
+    const cv = window.__wt_cv;
+    if (!cv) return [];
+    if (k === 'all') return cv.track('*', 2);
+    if (k === 'moving') return cv.track('*', 2).filter((e) => Math.abs(e.vx) > 0.1 || Math.abs(e.vy) > 0.1);
+    const sig = rf.names && rf.names[k];
+    return sig ? cv.track(sig, 2) : [];
   } });
 
   const tick = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weavetab/plugin-realtime",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Causal age/proximity tags for browser_map, 60Hz in-page reflex rules, canvas entity sampling and a bounded click loop for Weavetab.",
   "type": "module",
   "main": "dist/index.js",
@@ -15,6 +15,7 @@
     "dist",
     "weavetab.json",
     "README.md",
+    "AGENTS.md",
     "LICENSE"
   ],
   "scripts": {
@@ -25,7 +26,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@weavetab/sdk": "^2.6.1"
+    "@weavetab/sdk": "^2.6.2"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",

package/weavetab.json

@@ -2,157 +2,269 @@
   "$schema": "https://weavetab.dev/schema/plugin.json",
   "name": "@weavetab/plugin-realtime",
   "displayName": "Realtime",
-  "version": "0.2.0",
-  "description": "Causal tags for browser_map, in-page reflex rules, canvas entity sampling and a bounded click loop for Weavetab.",
+  "version": "0.3.0",
+  "description": "Causal age/proximity tags for browser_map, 60Hz in-page reflex rules, canvas entity sampling and a bounded click loop.",
   "entry": "dist/index.js",
+  "agentsMd": "AGENTS.md",
+  "author": {
+    "name": "fy2ne",
+    "url": "https://fy2ne.me"
+  },
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/Weavetab/Realtime#readme",
+  "repository": "https://github.com/Weavetab/Realtime",
   "engines": {
-    "weavetab": ">=2.6.1",
+    "weavetab": "^2.6.2",
     "node": ">=18.0.0"
   },
-  "environments": ["mcp"],
-  "authors": [{ "name": "fy2ne", "role": "Author", "url": "https://fy2ne.me" }],
-  "license": "Apache-2.0",
-  "tags": ["Canvas", "Games", "CDP", "Automation", "Community"],
-  "defaultConfig": { "causalWindowMs": 4000 },
-  "links": { "github": "https://github.com/Weavetab/Realtime", "npm": "https://www.npmjs.com/package/@weavetab/plugin-realtime" },
+  "environments": [
+    "mcp",
+    "cli",
+    "browser"
+  ],
+  "keywords": [
+    "weavetab",
+    "weavetab-plugin",
+    "cdp",
+    "canvas",
+    "browser-automation"
+  ],
+  "defaultConfig": {
+    "causalWindowMs": 4000
+  },
   "permissions": {
     "cdp": {
       "evaluate": true,
       "input": true,
-      "reason": "Injects a MutationObserver, canvas draw recorder and reflex loop into the page, and sends real mouse clicks for realtime_autopilot."
+      "reason": "Installs the in-page MutationObserver, hooks Canvas2D/rAF, and dispatches click/key events."
     },
     "tools": {
       "add": true,
-      "reason": "Registers realtime_canvas, realtime_reflex, realtime_autopilot and realtime_status."
+      "reason": "Registers realtime_canvas, realtime_reflex, realtime_autopilot, and realtime_status."
+    },
+    "commands": {
+      "add": true,
+      "reason": "Registers status and reflex-clear CLI commands."
     },
     "prompts": {
       "add": true,
-      "reason": "Registers /realtime_watch to guide setting up 60Hz DOM or canvas reflexes with live page state."
+      "reason": "Registers the /realtime_watch prompt utility."
     },
     "resources": {
       "add": true,
-      "reason": "Registers @realtime_feed (realtime://feed) for live reflex, causal DOM, and canvas entity telemetry."
+      "reason": "Registers the @realtime_feed resource utility."
     },
     "hooks": {
       "onBeforeAction": true,
       "onAfterAction": true,
-      "reason": "Installs the page probe before any tool runs and appends {new ...} tags to browser_map output."
+      "reason": "Arms the in-page mutation probe before actions and tags newly added nodes in browser_map output."
     },
     "network": {
-      "hosts": ["127.0.0.1", "localhost"],
-      "reason": "realtime_autopilot can POST candidates to a model_url the caller supplies (meant for a local OpenAI-compatible server)."
+      "domains": [
+        "127.0.0.1",
+        "localhost"
+      ],
+      "reason": "Allows realtime_autopilot to query an optional local OpenAI-compatible model endpoint."
     }
   },
+  "commands": [
+    {
+      "name": "status",
+      "description": "Read the in-page realtime probe state, canvas frame counter, and active 60Hz reflex rules.",
+      "usage": "weavetab plugin use realtime status [--wait_ms <ms>]",
+      "requiresSession": true,
+      "options": [
+        {
+          "name": "wait_ms",
+          "type": "number",
+          "description": "Block up to wait_ms until active reflexes finish",
+          "required": false
+        }
+      ]
+    },
+    {
+      "name": "reflex-clear",
+      "description": "Clear all active 60Hz reflex rules on the active browser tab via CLI.",
+      "usage": "weavetab plugin use realtime reflex-clear",
+      "requiresSession": true,
+      "options": []
+    },
+    {
+      "name": "autopilot",
+      "description": "Run bounded in-page autopilot toward a goal directly via CLI.",
+      "usage": "weavetab plugin use realtime autopilot --goal <text> [--max_steps <n>]",
+      "requiresSession": true,
+      "options": [
+        {
+          "name": "goal",
+          "type": "string",
+          "description": "Natural language click goal",
+          "required": true
+        },
+        {
+          "name": "max_steps",
+          "type": "number",
+          "description": "Maximum click steps (default 5)",
+          "required": false
+        },
+        {
+          "name": "stop_when_text",
+          "type": "string",
+          "description": "Stop when this text appears",
+          "required": false
+        }
+      ]
+    }
+  ],
+  "prompts": [
+    {
+      "name": "realtime_watch",
+      "description": "Snapshot live DOM mutations, active reflexes, and Canvas2D entities, then guide the agent to wire a 60Hz reflex rule.",
+      "arguments": [
+        {
+          "name": "goal",
+          "description": "What the reflex should watch for and do",
+          "required": true
+        },
+        {
+          "name": "mode",
+          "description": "Trigger mode (auto, dom, canvas)",
+          "required": false
+        }
+      ]
+    }
+  ],
+  "resources": [
+    {
+      "name": "realtime_canvas_feed",
+      "uri": "realtime://canvas",
+      "description": "Live snapshot of Canvas2D draw counts, rAF frame rate, and active moving entity bounding boxes.",
+      "mimeType": "application/json"
+    },
+    {
+      "name": "realtime_feed",
+      "uri": "realtime://feed",
+      "description": "Live snapshot of newly mutated DOM elements (with click distance), active 60Hz reflex rules, and tracked Canvas2D entities.",
+      "mimeType": "application/json"
+    }
+  ],
   "tools": [
     {
       "name": "realtime_canvas",
-      "description": "Sample what a 2D canvas game draws: entities with signature, bbox and px/frame velocity.",
+      "description": "Records Canvas2D draw calls across requestAnimationFrame ticks and returns moving/static entities with bounding boxes and px/frame velocity.",
       "inputSchema": {
         "type": "object",
         "properties": {
-          "action": { "type": "string", "enum": ["sample", "attach", "detach"], "default": "sample" },
-          "frames": { "type": "integer", "minimum": 2, "maximum": 15, "description": "frames to watch, default 6" }
+          "action": {
+            "type": "string",
+            "enum": [
+              "sample",
+              "attach",
+              "detach"
+            ],
+            "description": "sample (default), attach, or detach"
+          },
+          "frames": {
+            "type": "number",
+            "description": "Frames to sample (2-15, default 6)"
+          }
         }
       }
     },
     {
       "name": "realtime_reflex",
-      "description": "Register, list or remove rules that run inside the page every animation frame.",
+      "description": "Registers, removes, lists, or clears in-page 60Hz requestAnimationFrame rules that click or press keys on DOM or Canvas2D triggers without an LLM round-trip.",
       "inputSchema": {
         "type": "object",
         "properties": {
-          "action": { "type": "string", "enum": ["add", "remove", "list", "clear"], "default": "add" },
-          "id": { "type": "string" },
+          "action": {
+            "type": "string",
+            "enum": [
+              "add",
+              "remove",
+              "list",
+              "clear"
+            ],
+            "description": "Operation to perform"
+          },
+          "id": {
+            "type": "string",
+            "description": "Rule identifier"
+          },
           "when": {
             "type": "object",
-            "properties": {
-              "selector": { "type": "string" },
-              "text": { "type": "string" },
-              "only_new": { "type": "boolean" },
-              "enabled": { "type": "boolean" },
-              "canvas": {
-                "type": "object",
-                "properties": {
-                  "names": { "type": "object", "additionalProperties": { "type": "string" } },
-                  "js": { "type": "string" }
-                },
-                "required": ["names", "js"]
-              }
-            }
+            "description": "DOM selector or Canvas2D expression trigger"
           },
           "do": {
             "type": "object",
-            "properties": {
-              "type": { "type": "string", "enum": ["click", "click_xy", "key", "js"] },
-              "x": { "type": "number" },
-              "y": { "type": "number" },
-              "key": { "type": "string" },
-              "hold_ms": { "type": "number" },
-              "code": { "type": "string" }
-            },
-            "required": ["type"]
+            "description": "Response action (click, click_xy, key, js)"
           },
-          "cooldown_ms": { "type": "number" },
-          "max_hits": { "type": "number" },
-          "ttl_ms": { "type": "number" },
-          "stop_selector": { "type": "string" }
-        }
+          "cooldown_ms": {
+            "type": "number",
+            "description": "Minimum ms between firings (default 100)"
+          },
+          "max_hits": {
+            "type": "number",
+            "description": "Auto-stop after N hits (default 50)"
+          },
+          "ttl_ms": {
+            "type": "number",
+            "description": "Rule lifetime in ms (default 30000)"
+          },
+          "stop_selector": {
+            "type": "string",
+            "description": "Selector that halts the rule when present"
+          }
+        },
+        "required": [
+          "action"
+        ]
       }
     },
     {
       "name": "realtime_autopilot",
-      "description": "Bounded click loop for short UI sub-goals, ranked by label/goal word overlap and element recency.",
+      "description": "Runs a bounded in-page click loop toward a short goal ('accept cookies', 'continue') with causal age/dialog scoring and optional local model pick.",
       "inputSchema": {
         "type": "object",
         "properties": {
-          "goal": { "type": "string", "minLength": 3 },
-          "max_steps": { "type": "integer", "minimum": 1, "maximum": 25 },
-          "stop_when_selector": { "type": "string" },
-          "stop_when_text": { "type": "string" },
-          "stop_when_url": { "type": "string" },
-          "avoid_labels": { "type": "string" },
-          "model_url": { "type": "string", "format": "uri" },
-          "model": { "type": "string" },
-          "model_timeout_ms": { "type": "number" }
+          "goal": {
+            "type": "string",
+            "description": "Short natural-language click goal"
+          },
+          "max_steps": {
+            "type": "number",
+            "description": "Maximum clicks (default 8, max 25)"
+          },
+          "stop_when_selector": {
+            "type": "string",
+            "description": "Stop when selector becomes visible"
+          },
+          "stop_when_text": {
+            "type": "string",
+            "description": "Stop when body text contains string"
+          },
+          "stop_when_url": {
+            "type": "string",
+            "description": "Stop when URL matches regex"
+          }
         },
-        "required": ["goal"]
+        "required": [
+          "goal"
+        ]
       }
     },
     {
       "name": "realtime_status",
-      "description": "Probe, canvas recorder and reflex state for the current page; wait_ms blocks until active reflexes finish.",
+      "description": "Returns the live state of the in-page probe, Canvas2D spy, and active 60Hz reflex rules. Optionally waits until reflexes complete.",
       "inputSchema": {
         "type": "object",
-        "properties": { "wait_ms": { "type": "number" } }
-      }
-    }
-  ],
-  "prompts": [
-    {
-      "name": "realtime_watch",
-      "title": "Watch & React (60Hz Reflex)",
-      "description": "Set up an in-page 60Hz reflex rule or canvas game loop and wait until it finishes.",
-      "arguments": [
-        {
-          "name": "goal",
-          "description": "What to watch for and trigger (e.g. 'click Claim as soon as it appears' or 'jump over green obstacles in the canvas game')",
-          "required": true
-        },
-        {
-          "name": "mode",
-          "description": "'dom', 'canvas', or 'auto' (default 'auto')",
-          "required": false
+        "properties": {
+          "wait_ms": {
+            "type": "number",
+            "description": "Wait up to wait_ms (max 30000) for active reflexes to finish"
+          }
         }
-      ]
-    }
-  ],
-  "resources": [
-    {
-      "name": "realtime_feed",
-      "title": "Realtime Page Feed",
-      "uri": "realtime://feed",
-      "mimeType": "application/json",
-      "description": "Live snapshot of active 60Hz reflex rules, recently mutated DOM elements with click distance, and tracked Canvas2D entities."
+      }
     }
   ]
 }