@openbrt/weclawbotctl 0.1.8 → 0.1.14

package/README.md

@@ -52,6 +52,12 @@ weclawbotctl thinking --id "$task_id" --ttl 45
 weclawbotctl idle --id "$task_id"
 ```
 
+`idle` must use the same id as the active `thinking` message. Newer firmware
+rejects stale or unrelated `idle` messages and keeps the visible thinking state.
+The bundled OpenClaw bridge publishes `thinking` before every curator job and
+`idle` after it finishes, so WeChat-origin official-mode work also gets a visible
+processing state without relying on the model to remember it.
+
 To put text, status, diagrams, or images on the screen, render them into a
 pre-rendered `weclawbot.screen_document.v1` first. The firmware receives pixels;
 it does not lay out text, choose fonts, or split pages for agents.
@@ -60,9 +66,24 @@ it does not lay out text, choose fonts, or split pages for agents.
 weclawbotctl screen /path/to/screen-document.json
 ```
 
+`screen` waits for the device status topic by default. It exits successfully
+only after the firmware reports `applied`; a firmware `rejected` status or a
+timeout is a failed delivery. Use `--no-wait` only for diagnostics where MQTT
+publish acknowledgement is enough.
+
+To clear the current note, use the firmware clear command:
+
+```bash
+weclawbotctl clear
+```
+
+Do not emulate clear by publishing a blank, white, or black screen document.
+That creates a new note and can leave the physical screen looking black.
+
 The package also includes an OpenClaw integration: the `weclawbot-curator`
 skill, `weclawbot_status`, `weclawbot_validate_screen_document`,
-`weclawbot_publish_screen_document`, `weclawbot_validate_activity`,
+`weclawbot_clear_screen`, `weclawbot_publish_screen_document`,
+`weclawbot_validate_activity`,
 `weclawbot_publish_activity`, and a small outbound bridge service. The bridge
 polls `weclawbot.link`; no public HTTP endpoint, port forwarding, or WeChat
 credential is required on the OpenClaw host.
@@ -243,6 +264,24 @@ three `mono1` pages, and a future UTC expiry. Agents may use PIL, Canvas, SVG
 rasterization, screenshots, or any local renderer, but the MQTT payload must be
 pixels:
 
+There is no canonical WeClawBot renderer that agents must use. The stable
+contract is the bounded pixel document plus device feedback. Keep layout,
+typography, and page-composition decisions in the agent/tool layer so skills and
+models can improve the result without requiring users to flash firmware.
+Preserve any layout preferences, visual language, page rhythm, font choices, or
+review habits that the user and agent have already developed; package upgrades
+should add capabilities without resetting that accumulated practice.
+
+The hardware facts are stable: the content viewport is 368 x 206 mono1 pixels,
+content documents may contain one to three pages, and the firmware will not split
+a single pixel page after receiving it. If `pages.length === 1`, the physical
+screen has exactly one page.
+
+Before publishing, agents should inspect or otherwise self-evaluate the rendered
+pages against the user's preferences and their own learned standards when their
+runtime supports it. Regenerate the document if the bitmap does not satisfy those
+standards.
+
 ```bash
 weclawbotctl screen /path/to/screen-document.json
 ```
@@ -254,6 +293,11 @@ the firmware supports forced replacement, use:
 weclawbotctl screen /path/to/screen-document.json --force
 ```
 
+The command waits for the device's `applied`/`rejected` status by default, so
+an Agent must not tell the user the content is on the screen until the command
+returns success. If the device reports `stale_screen_revision`, regenerate the
+document with the current revision or intentionally overwrite with `--force`.
+
 These commands use MQTT/TLS directly, publish QoS 1 without retain, and
 never create an offline command queue. See
 `docs/agent-direct-control-protocol.md` in the firmware repository for the

package/bin/weclawbot-openclaw-bridge.mjs

@@ -2,6 +2,7 @@
 
 import process from "node:process";
 import { spawn } from "node:child_process";
+import path from "node:path";
 
 const ACTIONS = new Set([
   "ignore",
@@ -53,6 +54,10 @@ function stop() {
 
 async function handleJob(job) {
   const started = Date.now();
+  const activityId = `openclaw-${String(job.id || cryptoRandom()).replace(/[^a-zA-Z0-9_.-]/gu, "_").slice(0, 64)}`;
+  await publishBridgeActivity("thinking", activityId, {
+    ttlSeconds: Math.min(120, Math.max(5, config.agentTimeoutSeconds + 15)),
+  });
   try {
     const decision = await curateWithOpenClaw(job);
     await gatewayJson("POST", `${config.jobsPath}/${encodeURIComponent(job.id)}/result`, {
@@ -71,6 +76,24 @@ async function handleJob(job) {
     } catch (resultError) {
       log("failure_report_failed", { job: job.id, error: errorMessage(resultError) });
     }
+  } finally {
+    await publishBridgeActivity("idle", activityId);
+  }
+}
+
+async function publishBridgeActivity(state, id, options = {}) {
+  if (!config.screenActivity) return;
+  const args = [state, "--id", id];
+  if (state === "thinking") args.push("--ttl", String(options.ttlSeconds || 45));
+  try {
+    const result = await run(config.weclawbotctlBin, args, 8000);
+    if (result.code !== 0) {
+      log("activity_failed", { state, id, error: shortText(result.stderr || result.stdout || `exit ${result.code}`) });
+    } else {
+      log("activity_sent", { state, id });
+    }
+  } catch (error) {
+    log("activity_failed", { state, id, error: errorMessage(error) });
   }
 }
 
@@ -316,8 +339,10 @@ function loadConfig(env) {
     jobsPath: String(env.WEC_GATEWAY_JOBS_PATH || "/api/agent/curator/jobs"),
     agentId: String(env.WEC_OPENCLAW_AGENT || "weclawbot"),
     openclawBin: String(env.WEC_OPENCLAW_BIN || "openclaw"),
+    weclawbotctlBin: String(env.WEC_WECLAWBOTCTL_BIN || siblingBin("weclawbotctl")),
     transport: env.WEC_OPENCLAW_TRANSPORT === "local" ? "local" : "gateway",
     thinking: String(env.WEC_OPENCLAW_THINKING || "low"),
+    screenActivity: env.WEC_SCREEN_ACTIVITY !== "0" && env.WEC_SCREEN_ACTIVITY !== "false",
     pollWaitMs: positiveInteger(env.WEC_POLL_WAIT_MS, 20000),
     retryMs: positiveInteger(env.WEC_RETRY_MS, 3000),
     agentTimeoutSeconds: positiveInteger(env.WEC_AGENT_TIMEOUT_SECONDS, 20),
@@ -326,6 +351,15 @@ function loadConfig(env) {
   };
 }
 
+function siblingBin(name) {
+  const script = process.argv[1] || "";
+  return script ? path.join(path.dirname(script), name) : name;
+}
+
+function cryptoRandom() {
+  return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
 function positiveInteger(value, fallback) {
   const parsed = Number.parseInt(String(value || ""), 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;

package/bin/weclawbotctl.mjs

@@ -9,7 +9,7 @@ import process from "node:process";
 
 import { validateActivity } from "../lib/activity.mjs";
 import { validateScreenDocument } from "../lib/direct-control.mjs";
-import { normalizeCredentials, publishControl, testConnection } from "../lib/mqtt-control.mjs";
+import { normalizeCredentials, publishControl, publishControlAndWaitStatus, testConnection } from "../lib/mqtt-control.mjs";
 
 const DEFAULT_ENDPOINT = "https://weclawbot.link/byoa";
 const DEFAULT_CREDENTIALS_PATH = path.join(os.homedir(), ".config", "weclawbot", "agent-mqtt.json");
@@ -17,7 +17,7 @@ const DEFAULT_OPENCLAW_PLUGIN_SPEC = "@openbrt/weclawbotctl";
 const MIN_OPENCLAW_VERSION = "2026.6.9";
 
 const [command, ...args] = process.argv.slice(2);
-const commands = new Set(["bind", "status", "doctor", "export", "unbind", "thinking", "idle", "screen", "openclaw"]);
+const commands = new Set(["bind", "status", "doctor", "export", "unbind", "thinking", "idle", "screen", "clear", "openclaw"]);
 if (!commands.has(command)) {
   usage();
   process.exit(64);
@@ -30,6 +30,7 @@ try {
   else if (command === "export") await commandExport(args);
   else if (command === "unbind") await commandUnbind(args);
   else if (command === "screen") await commandScreen(args);
+  else if (command === "clear") await commandClear(args);
   else if (command === "openclaw") await commandOpenClaw(args);
   else await commandActivity(command, args);
 } catch (error) {
@@ -202,10 +203,15 @@ async function commandUnbind(values) {
 }
 
 async function commandScreen(values) {
-  const options = parseOptions(values, { credentials: credentialsPath(), force: false });
+  const options = parseOptions(values, {
+    credentials: credentialsPath(),
+    force: false,
+    wait: true,
+    timeout: 12,
+  });
   const file = String(options._[0] || "").trim();
   if (!file || options._.length !== 1) {
-    throw new Error("Usage: weclawbotctl screen <document.json> [--force]");
+    throw new Error("Usage: weclawbotctl screen <document.json> [--force] [--no-wait] [--timeout seconds]");
   }
   const document = JSON.parse(await fs.readFile(file, "utf8"));
   if (options.force) {
@@ -218,13 +224,84 @@ async function commandScreen(values) {
   if (!validation.ok) {
     throw new Error(`Invalid screen document: ${validation.errors.join("; ")}`);
   }
-  await publishControl(await requireCredentials(expandPath(options.credentials)), {
+  const control = {
     schema: "weclawbot.control.v1",
     id: `screen_${crypto.randomUUID()}`,
     kind: "screen_document",
     document,
+  };
+  const credentials = await requireCredentials(expandPath(options.credentials));
+  if (options.wait) {
+    const delivery = await publishControlAndWaitStatus(credentials, control, {
+      expectedDetail: document.id,
+      timeoutMs: Math.max(1, Number(options.timeout) || 12) * 1000,
+    });
+    if (delivery.status.kind !== "applied") {
+      throw new Error(`Device rejected screen document: ${delivery.status.detail || "unknown"}`);
+    }
+    console.log(JSON.stringify({
+      ok: true,
+      published: true,
+      applied: true,
+      id: document.id,
+      pages: document.pages.length,
+      force_replace: document.force_replace === true,
+      warnings: validation.warnings,
+      layout_guidance: validation.layout_guidance,
+      status: delivery.status,
+    }));
+    return;
+  }
+  await publishControl(credentials, control);
+  console.log(JSON.stringify({
+    ok: true,
+    published: true,
+    applied: null,
+    id: document.id,
+    pages: document.pages.length,
+    force_replace: document.force_replace === true,
+    warnings: validation.warnings,
+    layout_guidance: validation.layout_guidance,
+  }));
+}
+
+async function commandClear(values) {
+  const options = parseOptions(values, {
+    credentials: credentialsPath(),
+    target: "note",
+    wait: true,
+    timeout: 12,
   });
-  console.log(JSON.stringify({ ok: true, id: document.id, pages: document.pages.length, force_replace: document.force_replace === true }));
+  if (options._.length > 1) {
+    throw new Error("Usage: weclawbotctl clear [--target note|idle_photo] [--no-wait] [--timeout seconds]");
+  }
+  const target = normalizeClearTarget(options._[0] || options.target);
+  const control = {
+    schema: "weclawbot.control.v1",
+    id: `clear_${crypto.randomUUID()}`,
+    kind: "screen_clear",
+    target,
+  };
+  const credentials = await requireCredentials(expandPath(options.credentials));
+  if (options.wait) {
+    const delivery = await publishControlAndWaitStatus(credentials, control, {
+      expectedDetail: clearStatusDetail(target),
+      timeoutMs: Math.max(1, Number(options.timeout) || 12) * 1000,
+    });
+    if (delivery.status.kind !== "applied") {
+      throw new Error(`Device rejected screen clear: ${delivery.status.detail || "unknown"}`);
+    }
+    console.log(JSON.stringify({
+      ok: true,
+      published: true,
+      applied: true,
+      target,
+      status: delivery.status,
+    }));
+    return;
+  }
+  await publishControl(credentials, control);
+  console.log(JSON.stringify({ ok: true, published: true, applied: null, target }));
 }
 
 async function commandActivity(state, values) {
@@ -350,6 +427,13 @@ function parseOptions(values, defaults = {}) {
     const [rawKey, inlineValue] = value.slice(2).split("=", 2);
     const key = rawKey.trim();
     if (!key) continue;
+    if (key.startsWith("no-")) {
+      const positive = key.slice(3);
+      if (typeof options[positive] === "boolean" && inlineValue === undefined) {
+        options[positive] = false;
+        continue;
+      }
+    }
     if (typeof options[key] === "boolean") {
       options[key] = inlineValue === undefined ? true : !/^(0|false|no|off)$/iu.test(inlineValue);
     } else {
@@ -603,6 +687,18 @@ function compactText(value) {
   return String(value || "").replace(/\s+/gu, " ").trim().slice(0, 500);
 }
 
+function normalizeClearTarget(value) {
+  const target = String(value || "note").trim();
+  if (target === "note" || target === "idle_photo" || target === "photo") {
+    return target === "photo" ? "idle_photo" : target;
+  }
+  throw new Error("clear target must be note or idle_photo");
+}
+
+function clearStatusDetail(target) {
+  return target === "idle_photo" ? "clear_idle_photo" : "clear_note";
+}
+
 function shellValue(value) {
   return `'${String(value).replaceAll("'", "'\\''")}'`;
 }
@@ -620,7 +716,8 @@ function usage() {
   weclawbotctl unbind --yes
   weclawbotctl thinking [--ttl seconds] [--id correlation-id]
   weclawbotctl idle [--id correlation-id]
-  weclawbotctl screen <document.json> [--force]
+  weclawbotctl screen <document.json> [--force] [--no-wait] [--timeout seconds]
+  weclawbotctl clear [--target note|idle_photo] [--no-wait] [--timeout seconds]
   weclawbotctl openclaw install [--spec @openbrt/weclawbotctl] [--bin /path/to/openclaw] [--force=false]
   weclawbotctl openclaw doctor [--gateway=false] [--bin /path/to/openclaw] [--json]`);
 }

package/index.mjs

@@ -8,7 +8,7 @@ import { defineToolPlugin } from "openclaw/plugin-sdk/tool-plugin";
 
 import { validateActivity } from "./lib/activity.mjs";
 import { validateScreenDocument } from "./lib/direct-control.mjs";
-import { normalizeCredentials, publishControl, testConnection } from "./lib/mqtt-control.mjs";
+import { normalizeCredentials, publishControl, publishControlAndWaitStatus, testConnection } from "./lib/mqtt-control.mjs";
 
 const DEFAULT_CREDENTIALS_PATH = path.join(os.homedir(), ".config", "weclawbot", "agent-mqtt.json");
 
@@ -59,6 +59,43 @@ export default defineToolPlugin({
       }, { additionalProperties: false }),
       execute: ({ document, device_context }) => validateScreenDocument(document, device_context),
     }),
+    tool({
+      name: "weclawbot_clear_screen",
+      label: "Clear WeClawBot screen",
+      description: "Clear the paired WeClawBot note or idle-photo state with the firmware screen_clear control. Do not emulate clearing by publishing a blank or black bitmap.",
+      parameters: Type.Object({
+        target: Type.Optional(Type.String()),
+        credentials_path: Type.Optional(Type.String()),
+        wait_status: Type.Optional(Type.Boolean()),
+        timeout_seconds: Type.Optional(Type.Number()),
+      }, { additionalProperties: false }),
+      execute: async ({ target, credentials_path, wait_status, timeout_seconds }) => {
+        const clearTarget = normalizeClearTarget(target);
+        const control = {
+          schema: "weclawbot.control.v1",
+          id: `clear_${crypto.randomUUID()}`,
+          kind: "screen_clear",
+          target: clearTarget,
+        };
+        const credentials = await requireCredentials(credentials_path);
+        if (wait_status !== false) {
+          const delivery = await publishControlAndWaitStatus(credentials, control, {
+            expectedDetail: clearStatusDetail(clearTarget),
+            timeoutMs: Math.max(1, Number(timeout_seconds) || 12) * 1000,
+          });
+          return {
+            ok: delivery.status.kind === "applied",
+            published: true,
+            applied: delivery.status.kind === "applied",
+            rejected: delivery.status.kind === "rejected",
+            target: clearTarget,
+            status: delivery.status,
+          };
+        }
+        await publishControl(credentials, control);
+        return { ok: true, published: true, applied: null, target: clearTarget };
+      },
+    }),
     tool({
       name: "weclawbot_publish_screen_document",
       label: "Publish WeClawBot screen document",
@@ -68,8 +105,10 @@ export default defineToolPlugin({
         device_context: Type.Optional(Type.Any()),
         credentials_path: Type.Optional(Type.String()),
         force_replace: Type.Optional(Type.Boolean()),
+        wait_status: Type.Optional(Type.Boolean()),
+        timeout_seconds: Type.Optional(Type.Number()),
       }, { additionalProperties: false }),
-      execute: async ({ document, device_context, credentials_path, force_replace }) => {
+      execute: async ({ document, device_context, credentials_path, force_replace, wait_status, timeout_seconds }) => {
         const outbound = cloneObject(document);
         if (force_replace) {
           outbound.force_replace = true;
@@ -81,18 +120,41 @@ export default defineToolPlugin({
         if (!validation.ok) {
           return { ok: false, published: false, errors: validation.errors, validation };
         }
-        await publishControl(await requireCredentials(credentials_path), {
+        const control = {
           schema: "weclawbot.control.v1",
           id: `screen_${crypto.randomUUID()}`,
           kind: "screen_document",
           document: outbound,
-        });
+        };
+        const credentials = await requireCredentials(credentials_path);
+        if (wait_status !== false) {
+          const delivery = await publishControlAndWaitStatus(credentials, control, {
+            expectedDetail: outbound.id,
+            timeoutMs: Math.max(1, Number(timeout_seconds) || 12) * 1000,
+          });
+          return {
+            ok: delivery.status.kind === "applied",
+            published: true,
+            applied: delivery.status.kind === "applied",
+            rejected: delivery.status.kind === "rejected",
+            id: outbound.id,
+            pages: outbound.pages.length,
+            force_replace: outbound.force_replace === true,
+            warnings: validation.warnings,
+            layout_guidance: validation.layout_guidance,
+            status: delivery.status,
+          };
+        }
+        await publishControl(credentials, control);
         return {
           ok: true,
           published: true,
+          applied: null,
           id: outbound.id,
           pages: outbound.pages.length,
           force_replace: outbound.force_replace === true,
+          warnings: validation.warnings,
+          layout_guidance: validation.layout_guidance,
         };
       },
     }),
@@ -165,6 +227,18 @@ function cloneObject(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
+function normalizeClearTarget(value) {
+  const target = String(value || "note").trim();
+  if (target === "note" || target === "idle_photo" || target === "photo") {
+    return target === "photo" ? "idle_photo" : target;
+  }
+  throw new Error("clear target must be note or idle_photo");
+}
+
+function clearStatusDetail(target) {
+  return target === "idle_photo" ? "clear_idle_photo" : "clear_note";
+}
+
 function maskedMqtt(config, topics) {
   return {
     url: config.url,

package/lib/direct-control.mjs

@@ -29,6 +29,7 @@ export function resolveDeviceContext(value) {
 export function validateScreenDocument(value, suppliedContext) {
   const context = resolveDeviceContext(suppliedContext);
   const errors = [];
+  const pageStats = [];
   const document = value && typeof value === "object" ? value : null;
   const viewport = context.content_viewport;
   if (!document) return result(context, errors.concat("document must be an object"));
@@ -48,12 +49,15 @@ export function validateScreenDocument(value, suppliedContext) {
   if (!Array.isArray(document.pages) || document.pages.length < 1 || document.pages.length > viewport.max_pages) {
     errors.push(`pages must contain 1..${viewport.max_pages} items`);
   } else {
-    document.pages.forEach((page, index) => validatePage(page, index, viewport, errors));
+    document.pages.forEach((page, index) => validatePage(page, index, viewport, errors, pageStats));
+    if (pageStats.length > 0 && pageStats.every((stat) => stat.uniform)) {
+      errors.push("uniform_screen_document: content pages cannot all be a single color; use screen_clear for clearing");
+    }
   }
-  return result(context, errors);
+  return result(context, errors, document);
 }
 
-function validatePage(page, index, viewport, errors) {
+function validatePage(page, index, viewport, errors, pageStats) {
   if (!page || typeof page !== "object") {
     errors.push(`pages[${index}] must be an object`);
     return;
@@ -77,14 +81,35 @@ function validatePage(page, index, viewport, errors) {
     errors.push(`pages[${index}].data_b64 is not valid base64`);
   } else if (Number.isInteger(stride) && Number.isInteger(height) && bytes.length !== stride * height) {
     errors.push(`pages[${index}].data_b64 byte length does not match stride * height`);
+  } else if (bytes.length > 0) {
+    pageStats.push({ index, uniform: bytes.every((byte) => byte === bytes[0]) });
   }
 }
 
-function result(context, errors) {
+function result(context, errors, document = null) {
+  const pageCount = Array.isArray(document?.pages) ? document.pages.length : 0;
+  const warnings = [];
+  if (pageCount === 1) {
+    warnings.push("single_page_document: firmware will not split pixels; verify the page remains readable before publishing");
+  } else if (pageCount > 1) {
+    warnings.push("multi_page_document: firmware will auto-flip pages and manual left/right buttons can change pages");
+  }
   return {
     ok: errors.length === 0,
     errors,
+    warnings,
     viewport: context.content_viewport,
+    layout_guidance: {
+      hardware_contract: "agent supplies pre-rendered mono1 pixels; firmware validates geometry and does not lay out text or split pages",
+      page_contract: "pages.length is the physical page count; content documents support 1-3 pages",
+      preference_policy: "preserve user-agent learned layout preferences unless they violate hardware bounds or the user asks to change them",
+      review_policy: "agent should inspect rendered bitmap pages against user preferences and learned standards before publishing when possible",
+      max_pages: context.content_viewport?.max_pages,
+      content_viewport_px: {
+        width: context.content_viewport?.width,
+        height: context.content_viewport?.height,
+      },
+    },
     agent_transport: context.agent_transport || null,
     direct_delivery_ready: context.agent_transport?.screen_document_available === true
       || context.agent_transport?.available === true,

package/lib/mqtt-control.mjs

@@ -2,27 +2,33 @@ import mqtt from "mqtt";
 
 export async function publishControl(credentials, control) {
   const config = normalizeCredentials(credentials);
-  if (!control || typeof control !== "object" || control.schema !== "weclawbot.control.v1") {
-    throw new Error("invalid_control_message");
+  validateControl(control);
+  const client = connectMqtt(config);
+  try {
+    await onceConnected(client);
+    await publishJson(client, config.controlTopic, control);
+  } finally {
+    client.end(true);
   }
-  const client = mqtt.connect(config.url, {
-    clientId: config.clientId,
-    username: config.username,
-    password: config.password,
-    clean: true,
-    reconnectPeriod: 0,
-    connectTimeout: 12_000,
-    protocolVersion: 5,
-    properties: { sessionExpiryInterval: 0 },
-  });
+}
+
+export async function publishControlAndWaitStatus(credentials, control, options = {}) {
+  const config = normalizeCredentials(credentials);
+  validateControl(control);
+  if (!config.statusTopic) throw new Error("agent_status_topic_missing");
+  const timeoutMs = Math.max(1000, Number(options.timeoutMs || 12_000));
+  const expectedDetail = string(options.expectedDetail);
+  const client = connectMqtt(config);
   try {
     await onceConnected(client);
-    await new Promise((resolve, reject) => {
-      client.publish(config.controlTopic, JSON.stringify(control), { qos: 1, retain: false }, (error) => {
-        if (error) reject(error);
-        else resolve();
-      });
+    await subscribe(client, config.statusTopic);
+    const statusPromise = waitForStatus(client, {
+      timeoutMs,
+      expectedDetail,
     });
+    await publishJson(client, config.controlTopic, control);
+    const status = await statusPromise;
+    return { ok: status.kind === "applied", status };
   } finally {
     client.end(true);
   }
@@ -30,16 +36,7 @@ export async function publishControl(credentials, control) {
 
 export async function testConnection(credentials) {
   const config = normalizeCredentials(credentials);
-  const client = mqtt.connect(config.url, {
-    clientId: config.clientId,
-    username: config.username,
-    password: config.password,
-    clean: true,
-    reconnectPeriod: 0,
-    connectTimeout: 12_000,
-    protocolVersion: 5,
-    properties: { sessionExpiryInterval: 0 },
-  });
+  const client = connectMqtt(config);
   try {
     await onceConnected(client);
   } finally {
@@ -62,11 +59,91 @@ export function normalizeCredentials(value) {
   const password = string(mqttConfig?.password);
   const clientId = string(mqttConfig?.client_id);
   const controlTopic = string(topics?.control);
+  const statusTopic = string(topics?.status);
   if (!url || !username || !password || !clientId || !controlTopic) {
     throw new Error("agent_credentials_incomplete");
   }
   if (!/^wss:\/\//u.test(url)) throw new Error("agent_mqtt_requires_wss");
-  return { url, username, password, clientId, controlTopic };
+  return { url, username, password, clientId, controlTopic, statusTopic };
+}
+
+function connectMqtt(config) {
+  return mqtt.connect(config.url, {
+    clientId: config.clientId,
+    username: config.username,
+    password: config.password,
+    clean: true,
+    reconnectPeriod: 0,
+    connectTimeout: 12_000,
+    protocolVersion: 5,
+    properties: { sessionExpiryInterval: 0 },
+  });
+}
+
+function validateControl(control) {
+  if (!control || typeof control !== "object" || control.schema !== "weclawbot.control.v1") {
+    throw new Error("invalid_control_message");
+  }
+}
+
+function publishJson(client, topic, value) {
+  return new Promise((resolve, reject) => {
+    client.publish(topic, JSON.stringify(value), { qos: 1, retain: false }, (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+
+function subscribe(client, topic) {
+  return new Promise((resolve, reject) => {
+    client.subscribe(topic, { qos: 1 }, (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+
+function waitForStatus(client, { timeoutMs, expectedDetail }) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => finish(new Error("device_status_timeout")), timeoutMs);
+    const finish = (error, status) => {
+      clearTimeout(timeout);
+      client.removeListener("message", onMessage);
+      client.removeListener("error", onError);
+      if (error) reject(error);
+      else resolve(status);
+    };
+    const onError = (error) => finish(error);
+    const onMessage = (_topic, payload) => {
+      const status = parseStatus(payload);
+      if (!status) return;
+      if (status.kind === "applied") {
+        if (expectedDetail && status.detail !== expectedDetail) return;
+        finish(null, status);
+      } else if (status.kind === "rejected") {
+        finish(null, status);
+      }
+    };
+    client.on("message", onMessage);
+    client.once("error", onError);
+  });
+}
+
+function parseStatus(payload) {
+  try {
+    const status = JSON.parse(payload.toString("utf8"));
+    if (status?.schema !== "weclawbot.device_status.v1") return null;
+    if (status.kind !== "applied" && status.kind !== "rejected") return null;
+    return {
+      schema: status.schema,
+      kind: status.kind,
+      device_id: string(status.device_id),
+      detail: string(status.detail),
+    };
+  } catch {
+    return null;
+  }
 }
 
 function onceConnected(client) {

package/openclaw.plugin.json

@@ -6,6 +6,7 @@
     "tools": [
       "weclawbot_status",
       "weclawbot_validate_screen_document",
+      "weclawbot_clear_screen",
       "weclawbot_publish_screen_document",
       "weclawbot_validate_activity",
       "weclawbot_publish_activity"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openbrt/weclawbotctl",
-  "version": "0.1.8",
+  "version": "0.1.14",
   "description": "WeClawBot pairing and screen-control CLI for local AI agents.",
   "type": "module",
   "license": "MIT",

package/skills/weclawbot-curator/SKILL.md

@@ -59,6 +59,40 @@ OpenClaw Canvas for requests that mention WeClawBot, the physical screen, or
 not send raw text to firmware. The agent owns text layout, font choice, image
 rasterization, and page splitting; the device consumes pixels.
 
+For clear requests such as “清屏”, “清理屏幕”, “clear screen”, or removing the
+current note, call `weclawbot_clear_screen` or run `weclawbotctl clear`. Never
+simulate clearing by publishing a blank, white, or black `screen_document`; that
+creates a new note instead of clearing firmware state.
+
+## Layout, preferences, and page splitting
+
+Treat this skill as a hardware contract and starting point, not as a fixed house
+style. If the user and agent have already developed layout preferences, visual
+language, page rhythm, font choices, or review habits, preserve those choices
+unless the user asks to change them or they violate the device bounds below.
+Skill upgrades must be additive and compatible with accumulated user-agent
+practice; do not reset or overwrite local style memory just because this package
+changed.
+
+Hardware facts: the content viewport is 368 x 206 mono1 pixels, and a document
+may contain one to three content pages. The firmware will not split a single
+pixel page after receiving it; if the document has `pages.length === 1`, the
+physical screen has exactly one page. Multi-page documents can be auto-flipped by
+firmware and changed with the physical left/right buttons.
+
+Before publishing, review the actual rendered bitmap pages when your runtime can
+inspect images. Judge the preview against the user's preferences and the agent's
+own learned standards: legibility, margins, crowding, page count, and continuity
+across pages. If the preview does not satisfy those standards, regenerate the
+pages before publishing. This review loop belongs in the agent/tool layer; do not
+expect firmware to fix typography or split pages after the pixels arrive.
+
+`weclawbotctl screen` and `weclawbot_publish_screen_document` wait for the
+device status topic by default. Treat only `applied` as success. If the device
+returns `rejected`, tell the user the real rejection reason. Use
+`force_replace` or `weclawbotctl screen --force` only when the user explicitly
+intends to overwrite the currently shown BYOA screen.
+
 Only return the normal WeChat decision shape below when processing an explicit
 `WECLAWBOT_CURATOR_EVENT` envelope.
 
@@ -86,9 +120,11 @@ For a paired device, publish `weclawbot.activity.v1` with `state: "thinking"`
 immediately before an LLM call, long retrieval, or multi-step operation, then
 always publish `state: "idle"` in a `finally` path after success or failure.
 The thinking message requires a 5-120 second `ttl_seconds` and a stable
-`correlation_id`; use `weclawbot_validate_activity` first. It is a temporary
-overlay that restores the exact prior page, not a screen document and not a
-status to leave on indefinitely. Do not publish it when
+`correlation_id`; the matching idle message must reuse the same id. Newer
+firmware rejects stale or unrelated idle messages and keeps the active thinking
+state. Use `weclawbot_validate_activity` first. It is a temporary overlay that
+restores the exact prior page, not a screen document and not a status to leave on
+indefinitely. Do not publish it when
 `agent_transport.available` is false.
 
 Return this shape:

package/systemd/weclawbot-openclaw-curator.service

@@ -7,6 +7,7 @@ Wants=network-online.target
 Type=simple
 EnvironmentFile=%h/.config/weclawbot/openclaw-curator.env
 Environment=NODE_EXTRA_CA_CERTS=%h/.openclaw/gateway/tls/gateway-cert.pem
+Environment=WEC_WECLAWBOTCTL_BIN=%h/.npm-global/bin/weclawbotctl
 ExecStart=%h/.npm-global/bin/weclawbot-openclaw-bridge
 Restart=always
 RestartSec=3

package/test/direct-control.test.mjs

@@ -5,6 +5,7 @@ import { resolveDeviceContext, validateScreenDocument } from "../lib/direct-cont
 const context = resolveDeviceContext();
 const viewport = context.content_viewport;
 const bytes = Buffer.alloc(Math.ceil(viewport.width / 8) * viewport.height, 0xff);
+bytes[0] = 0x00;
 const valid = validateScreenDocument({
   schema: "weclawbot.screen_document.v1",
   id: "test-card",
@@ -33,4 +34,22 @@ const invalid = validateScreenDocument({
 assert.equal(invalid.ok, false);
 assert.ok(invalid.errors.some((error) => error.includes("width")));
 
+const uniform = validateScreenDocument({
+  schema: "weclawbot.screen_document.v1",
+  id: "bad-clear",
+  base_revision: "",
+  expires_at: new Date(Date.now() + 60_000).toISOString(),
+  target: "content",
+  kind: "replace",
+  pages: [{
+    format: "mono1",
+    width: viewport.width,
+    height: viewport.height,
+    stride: Math.ceil(viewport.width / 8),
+    data_b64: Buffer.alloc(Math.ceil(viewport.width / 8) * viewport.height, 0x00).toString("base64"),
+  }],
+}, context);
+assert.equal(uniform.ok, false);
+assert.ok(uniform.errors.some((error) => error.includes("uniform_screen_document")));
+
 console.log("direct-control validator: ok");

package/workspace/AGENTS.md

@@ -37,6 +37,17 @@ content viewport, then publish it:
 weclawbotctl screen /path/to/screen-document.json
 ```
 
+This command waits for firmware `applied`/`rejected` status by default. Report
+success only after it exits with success. If the user explicitly asks to
+replace whatever is currently shown, use `--force`; otherwise use the current
+screen revision in `base_revision`.
+
 The firmware receives pixels. Do not send raw text to firmware, and do not
 answer that direct delivery is unavailable before checking the local
 `weclawbotctl` profile.
+
+The content viewport is 368 x 206 mono1 pixels, with one to three content pages.
+The firmware will not split a single pixel page after receiving it; `pages.length`
+is the page count on the physical screen. Preserve user-agent layout preferences,
+visual language, and review habits across plugin upgrades unless they violate
+the hardware limits or the user asks to change them.