@clawling/clawchat-plugin-openclaw 2026.8.20-1 → 2026.8.26-1

package/dist/src/protocol-types.js

@@ -8,6 +8,7 @@ export const EVENT = {
     MESSAGE_ERROR: "message.error",
     MESSAGE_REPLY: "message.reply",
     MESSAGE_REACTION: "message.reaction",
+    MESSAGE_RECALL: "message.recall",
     MESSAGE_CREATED: "message.created",
     MESSAGE_ADD: "message.add",
     MESSAGE_DONE: "message.done",
@@ -90,3 +91,20 @@ export class StateError extends Error {
 export function isBusinessDispatchEvent(event) {
     return event === EVENT.MESSAGE_SEND || event === EVENT.MESSAGE_REPLY;
 }
+/**
+ * Pull the id to delete out of a `message.recall` payload.
+ *
+ * Exists as a pure function, apart from the socket, for the same reason the
+ * mistake it guards is worth guarding: `payload.message_id` is right there and
+ * looks like the answer, but it is the `rcl:` slot. Deleting by it removes
+ * nothing and reads exactly like working code.
+ *
+ * Answers `null` for anything unusable, so a recall we cannot resolve deletes
+ * nothing rather than something adjacent.
+ */
+export function recallTargetMessageId(payload) {
+    if (!payload || typeof payload !== "object")
+        return null;
+    const target = payload.target_message_id;
+    return typeof target === "string" && target.length > 0 ? target : null;
+}

package/dist/src/runtime.js

@@ -1,4 +1,4 @@
-import { AckTimeoutError, AuthError, ProtocolError, StateError, TransportError, EVENT, } from "./protocol-types.js";
+import { AckTimeoutError, AuthError, ProtocolError, StateError, TransportError, EVENT, recallTargetMessageId, } from "./protocol-types.js";
 import { waitUntilAbort } from "openclaw/plugin-sdk/channel-lifecycle";
 import { hasControlCommand } from "openclaw/plugin-sdk/command-detection";
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
@@ -1534,7 +1534,6 @@ export async function startOpenclawClawlingGateway(params) {
     const protocolControlLogger = createProtocolControlHandler({
         accountId,
         log: (msg) => log?.info?.(msg),
-        send: () => { },
         context: wsLogContext,
     });
     const notifySignalObserver = createNotifySignalObserver({
@@ -2907,6 +2906,38 @@ export async function startOpenclawClawlingGateway(params) {
             await handleInboundEnvelope(env);
         })();
     });
+    // `message.recall` — the sender withdrew a message. Erase our own ledger row
+    // so the "Prior group context" block above (MENTION_CONTEXT_N rows, no time
+    // predicate, no retention) can never read it back into a turn.
+    //
+    // Ids only: the frame carries no content, and `payload.message_id` is the
+    // server's `rcl:<target>` slot — the id to delete is `target_message_id`.
+    //
+    // Synchronous and fire-and-forget on purpose: there is no ack to send (the
+    // frame is BestEffort and non-ackable).
+    //
+    // §9.8 requires a permanent tombstone consulted on every ingest path, and
+    // `store.recallMessage` writes one in the same transaction as the delete.
+    // That is what makes this handler's timing irrelevant: the inbound ledger
+    // write sits behind an await, so on a replay carrying the original and its
+    // recall back-to-back the DELETE runs first — and the tombstone then refuses
+    // the INSERT. It also closes the Kafka-redelivery resurrection this comment
+    // previously accepted as a known limitation.
+    client.on("message:recall", (env) => {
+        const target = recallTargetMessageId(env.payload);
+        if (!target) {
+            log?.info?.(`[${accountId}] clawchat-plugin-openclaw recall ignored (no target_message_id) chat_id=${String(env.chat_id ?? "")}`);
+            return;
+        }
+        const removed = store?.recallMessage?.({
+            platform: "openclaw",
+            accountId,
+            messageId: target,
+        });
+        const rowsLabel = typeof removed === "number" ? String(removed) : "unavailable";
+        const logFn = typeof removed === "number" ? log?.info : log?.error;
+        logFn?.(`[${accountId}] clawchat-plugin-openclaw recall purged chat_id=${String(env.chat_id ?? "")} msg=${target} rows=${rowsLabel}`);
+    });
     // Initial pull of per-group agent settings at startup (best-effort; errors are
     // logged). `bypassRefresh: true` (Finding 4) keeps this pre-connect pull from
     // rotating `account.token` out from under the already-constructed WS client.

package/dist/src/storage.js

@@ -171,6 +171,19 @@ CREATE TABLE IF NOT EXISTS owner_profile (
   updated_at INTEGER NOT NULL,
   PRIMARY KEY (platform, account_id)
 );
+`,
+    },
+    {
+        version: 10,
+        name: "recalled_messages",
+        sql: `
+CREATE TABLE IF NOT EXISTS recalled_messages (
+  platform TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  recalled_at INTEGER NOT NULL,
+  PRIMARY KEY (platform, account_id, message_id)
+);
 `,
     },
 ];
@@ -412,6 +425,14 @@ export class ClawChatStore {
     }
     claimMessageOnce(input) {
         return this.write(() => {
+            // Protocol v2 §9.8: consult the recall tombstone on every ingest path.
+            // Doing it inside this same write transaction is what makes the delete
+            // and the insert order-independent: whichever frame the server delivers
+            // first, a recalled message_id can never end up in the ledger. Without
+            // it, a replay carrying the original and its recall back-to-back ran the
+            // DELETE before the INSERT and the row survived.
+            if (input.messageId && this.isMessageRecalled(input))
+                return false;
             const result = this.requireDb()
                 .prepare(`INSERT OR IGNORE INTO clawchat_messages(
             platform, account_id, kind, direction, event_type, trace_id, chat_id,
@@ -443,6 +464,75 @@ export class ClawChatStore {
                 .run(input.eventType, input.traceId ?? null, input.chatId ?? null, input.text ?? null, toJson(input.raw), input.accountId, input.kind, input.direction, input.messageId);
         });
     }
+    /**
+     * Erase every ledger row for one `message_id` — the local half of a
+     * server-authorised recall (`message.recall`, docs/client-integration.md §9.8).
+     *
+     * **The only DELETE in this store, and deliberately so.** There is no prune
+     * and no retention on `clawchat_messages`: without this, a message recalled
+     * ninety seconds after it was sent stays one @-mention away from being read
+     * back aloud under "Prior group context" for as long as the group is quiet.
+     *
+     * Scoped to `(platform, account_id)` so one account's recall cannot reach
+     * another's rows, and matched on `message_id`, which seeks via the
+     * single-column `idx_clawchat_messages_message_id` before the `platform` /
+     * `account_id` filter is applied — so this is a lookup, not a table scan.
+     *
+     * Answers the number of rows removed. `0` is a normal outcome, not a failure:
+     * the row may never have been stored (a message that arrived before this
+     * account was paired, or one dropped by the inbound filter). `null` means the
+     * store is unavailable.
+     */
+    /** True when `message_id` was recalled for this (platform, account). */
+    isMessageRecalled(input) {
+        if (!input.messageId)
+            return false;
+        const row = this.requireDb()
+            .prepare(`SELECT 1 FROM recalled_messages
+          WHERE platform = ? AND account_id = ? AND message_id = ?`)
+            .get(input.platform, input.accountId, input.messageId);
+        return row !== undefined;
+    }
+    /**
+     * Record the permanent recall tombstone and purge any row already stored,
+     * atomically. Returns the number of ledger rows deleted (0 when the recall
+     * arrived before the message did — the tombstone still stands and the later
+     * ingest is refused by {@link claimMessageOnce}).
+     */
+    recallMessage(input) {
+        // An empty id would tombstone and delete rows keyed by '' — every row the
+        // store never managed to key. Refuse rather than guess.
+        if (!input.messageId)
+            return 0;
+        return this.write(() => {
+            const db = this.requireDb();
+            db.prepare(`INSERT OR IGNORE INTO recalled_messages(platform, account_id, message_id, recalled_at)
+          VALUES (?, ?, ?, ?)`).run(input.platform, input.accountId, input.messageId, input.recalledAt ?? Date.now());
+            const result = db
+                .prepare(`DELETE FROM clawchat_messages
+            WHERE platform = ? AND account_id = ? AND message_id = ?`)
+                .run(input.platform, input.accountId, input.messageId);
+            return Number(result.changes);
+        });
+    }
+    /**
+     * Low-level purge by message id. NOT the recall path: it writes no tombstone,
+     * so a recall routed through here loses to a redelivery or to an ingest that
+     * is still behind an await. Use {@link recallMessage} for `message.recall`.
+     */
+    deleteMessagesByMessageId(input) {
+        // An empty id would match every row whose message_id is '' — deleting
+        // everything the store never managed to key. Refuse rather than guess.
+        if (!input.messageId)
+            return 0;
+        return this.write(() => {
+            const result = this.requireDb()
+                .prepare(`DELETE FROM clawchat_messages
+            WHERE platform = ? AND account_id = ? AND message_id = ?`)
+                .run(input.platform, input.accountId, input.messageId);
+            return Number(result.changes);
+        });
+    }
     startConnection(input) {
         return this.write(() => {
             const now = input.connectStartedAt ?? Date.now();

package/dist/src/ws-alignment.js

@@ -171,15 +171,12 @@ export function createProtocolControlHandler(options) {
     return {
         handleInbound(env) {
             if (env.event === "ping") {
-                logControl("protocol_ping_received", "send_pong", [["trace_id", env.trace_id]]);
-                options.send(JSON.stringify({
-                    version: "2",
-                    event: "pong",
-                    trace_id: env.trace_id ?? "-",
-                    // §12: echo the sender's emitted_at verbatim (do not restamp).
-                    emitted_at: env.emitted_at ?? Date.now(),
-                    payload: {},
-                }));
+                // §12: the server never emits a JSON-level `ping`, so this is an
+                // anomaly worth seeing — but answering it would send exactly the
+                // unsolicited `pong` the spec bans, which the server drops as an
+                // unknown uplink event. Log it and drop it; this handler has no send
+                // capability, so the banned frame cannot be produced here at all.
+                logControl("protocol_ping_received", "drop", [["trace_id", env.trace_id]]);
                 return true;
             }
             if (env.event === "pong") {

package/dist/src/ws-client.js

@@ -548,8 +548,10 @@ export class ClawChatClient extends EventEmitter {
             return this.onHelloOk(env);
         if (env.event === EVENT.HELLO_FAIL)
             return this.onHelloFail(env);
-        if (env.event === EVENT.PING)
-            return this.onPing(env);
+        // §12: the server never emits a JSON-level `ping`, and an unsolicited
+        // `pong` is an unknown uplink event the server drops. We therefore do NOT
+        // answer a downlink ping. `pong` below is still handled: it is the reply
+        // to the client-initiated heartbeat probe §12 does allow.
         if (env.event === EVENT.PONG)
             return this.onPong();
         if (env.event === EVENT.MESSAGE_ACK)
@@ -558,6 +560,11 @@ export class ClawChatClient extends EventEmitter {
             return this.onMessageError(env);
         if (isBusinessDispatchEvent(env.event))
             this.emit("message", env);
+        // Deliberately NOT a business dispatch event: `message` feeds the turn
+        // pipeline, and a recall has no body to turn into a prompt. It is an
+        // instruction to delete, so it gets its own emitter and its own consumer.
+        if (env.event === EVENT.MESSAGE_RECALL)
+            this.emit("message:recall", env);
         if (env.event === EVENT.MESSAGE_CREATED)
             this.emit("message:created", env);
         if (env.event === EVENT.MESSAGE_ADD)
@@ -699,15 +706,6 @@ export class ClawChatClient extends EventEmitter {
             this.opts.transport.close(4001, "auth failed");
         }
     }
-    onPing(env) {
-        this.sendRawEnvelope({
-            version: "2",
-            event: EVENT.PONG,
-            trace_id: env.trace_id,
-            emitted_at: env.emitted_at,
-            payload: {},
-        });
-    }
     onPong() {
         if (this.pongTimer)
             clearTimeout(this.pongTimer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.8.20-1",
+  "version": "2026.8.26-1",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "author": "CLAWLING PTE. LTD.",

package/src/protocol-types.ts

@@ -8,6 +8,7 @@ export const EVENT = {
   MESSAGE_ERROR: "message.error",
   MESSAGE_REPLY: "message.reply",
   MESSAGE_REACTION: "message.reaction",
+  MESSAGE_RECALL: "message.recall",
   MESSAGE_CREATED: "message.created",
   MESSAGE_ADD: "message.add",
   MESSAGE_DONE: "message.done",
@@ -361,3 +362,39 @@ export class StateError extends Error {
 export function isBusinessDispatchEvent(event: string): boolean {
   return event === EVENT.MESSAGE_SEND || event === EVENT.MESSAGE_REPLY;
 }
+
+/**
+ * `message.recall` downlink payload (docs/client-integration.md §9.8).
+ *
+ * **Ids only, never content.** The frame relays an instruction to delete, not
+ * a copy of what is being deleted — which is what makes it compatible with the
+ * feature's "no trace anywhere" requirement.
+ */
+export interface MessageRecallPayload {
+  /**
+   * The server's deterministic slot id, `rcl:<target_message_id>`. Present so
+   * the marker can occupy one durable inbox row per recalled message. It is
+   * NOT the id to delete.
+   */
+  message_id: string;
+
+  /** The id of the message being erased. This is the one to delete by. */
+  target_message_id: string;
+}
+
+/**
+ * Pull the id to delete out of a `message.recall` payload.
+ *
+ * Exists as a pure function, apart from the socket, for the same reason the
+ * mistake it guards is worth guarding: `payload.message_id` is right there and
+ * looks like the answer, but it is the `rcl:` slot. Deleting by it removes
+ * nothing and reads exactly like working code.
+ *
+ * Answers `null` for anything unusable, so a recall we cannot resolve deletes
+ * nothing rather than something adjacent.
+ */
+export function recallTargetMessageId(payload: unknown): string | null {
+  if (!payload || typeof payload !== "object") return null;
+  const target = (payload as { target_message_id?: unknown }).target_message_id;
+  return typeof target === "string" && target.length > 0 ? target : null;
+}

package/src/runtime.ts

@@ -5,6 +5,7 @@ import {
   StateError,
   TransportError,
   EVENT,
+  recallTargetMessageId,
   type Envelope,
   type Transport,
 } from "./protocol-types.ts";
@@ -123,6 +124,7 @@ type RuntimeConnectionStore = Pick<
       | "getActivationConversation"
       | "getLastResolvedDeviceId"
       | "listRecentGroupMessages"
+      | "recallMessage"
       | "upsertOwnerProfile"
     >
   >;
@@ -1920,7 +1922,6 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
   const protocolControlLogger = createProtocolControlHandler({
     accountId,
     log: (msg) => log?.info?.(msg),
-    send: () => {},
     context: wsLogContext,
   });
   const notifySignalObserver = createNotifySignalObserver({
@@ -3447,6 +3448,43 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     })();
   });
 
+  // `message.recall` — the sender withdrew a message. Erase our own ledger row
+  // so the "Prior group context" block above (MENTION_CONTEXT_N rows, no time
+  // predicate, no retention) can never read it back into a turn.
+  //
+  // Ids only: the frame carries no content, and `payload.message_id` is the
+  // server's `rcl:<target>` slot — the id to delete is `target_message_id`.
+  //
+  // Synchronous and fire-and-forget on purpose: there is no ack to send (the
+  // frame is BestEffort and non-ackable).
+  //
+  // §9.8 requires a permanent tombstone consulted on every ingest path, and
+  // `store.recallMessage` writes one in the same transaction as the delete.
+  // That is what makes this handler's timing irrelevant: the inbound ledger
+  // write sits behind an await, so on a replay carrying the original and its
+  // recall back-to-back the DELETE runs first — and the tombstone then refuses
+  // the INSERT. It also closes the Kafka-redelivery resurrection this comment
+  // previously accepted as a known limitation.
+  client.on("message:recall", (env: Envelope) => {
+    const target = recallTargetMessageId(env.payload);
+    if (!target) {
+      log?.info?.(
+        `[${accountId}] clawchat-plugin-openclaw recall ignored (no target_message_id) chat_id=${String(env.chat_id ?? "")}`,
+      );
+      return;
+    }
+    const removed = store?.recallMessage?.({
+      platform: "openclaw",
+      accountId,
+      messageId: target,
+    });
+    const rowsLabel = typeof removed === "number" ? String(removed) : "unavailable";
+    const logFn = typeof removed === "number" ? log?.info : log?.error;
+    logFn?.(
+      `[${accountId}] clawchat-plugin-openclaw recall purged chat_id=${String(env.chat_id ?? "")} msg=${target} rows=${rowsLabel}`,
+    );
+  });
+
   // Initial pull of per-group agent settings at startup (best-effort; errors are
   // logged). `bypassRefresh: true` (Finding 4) keeps this pre-connect pull from
   // rotating `account.token` out from under the already-constructed WS client.

package/src/storage.ts

@@ -389,6 +389,19 @@ CREATE TABLE IF NOT EXISTS owner_profile (
   updated_at INTEGER NOT NULL,
   PRIMARY KEY (platform, account_id)
 );
+`,
+  },
+  {
+    version: 10,
+    name: "recalled_messages",
+    sql: `
+CREATE TABLE IF NOT EXISTS recalled_messages (
+  platform TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  recalled_at INTEGER NOT NULL,
+  PRIMARY KEY (platform, account_id, message_id)
+);
 `,
   },
 ];
@@ -722,6 +735,13 @@ export class ClawChatStore {
 
   claimMessageOnce(input: MessageInput): true | false | null {
     return this.write(() => {
+      // Protocol v2 §9.8: consult the recall tombstone on every ingest path.
+      // Doing it inside this same write transaction is what makes the delete
+      // and the insert order-independent: whichever frame the server delivers
+      // first, a recalled message_id can never end up in the ledger. Without
+      // it, a replay carrying the original and its recall back-to-back ran the
+      // DELETE before the INSERT and the row survived.
+      if (input.messageId && this.isMessageRecalled(input)) return false;
       const result = this.requireDb()
         .prepare(
           `INSERT OR IGNORE INTO clawchat_messages(
@@ -802,6 +822,92 @@ export class ClawChatStore {
     });
   }
 
+  /**
+   * Erase every ledger row for one `message_id` — the local half of a
+   * server-authorised recall (`message.recall`, docs/client-integration.md §9.8).
+   *
+   * **The only DELETE in this store, and deliberately so.** There is no prune
+   * and no retention on `clawchat_messages`: without this, a message recalled
+   * ninety seconds after it was sent stays one @-mention away from being read
+   * back aloud under "Prior group context" for as long as the group is quiet.
+   *
+   * Scoped to `(platform, account_id)` so one account's recall cannot reach
+   * another's rows, and matched on `message_id`, which seeks via the
+   * single-column `idx_clawchat_messages_message_id` before the `platform` /
+   * `account_id` filter is applied — so this is a lookup, not a table scan.
+   *
+   * Answers the number of rows removed. `0` is a normal outcome, not a failure:
+   * the row may never have been stored (a message that arrived before this
+   * account was paired, or one dropped by the inbound filter). `null` means the
+   * store is unavailable.
+   */
+  /** True when `message_id` was recalled for this (platform, account). */
+  isMessageRecalled(input: { platform: string; accountId: string; messageId?: string | null }): boolean {
+    if (!input.messageId) return false;
+    const row = this.requireDb()
+      .prepare(
+        `SELECT 1 FROM recalled_messages
+          WHERE platform = ? AND account_id = ? AND message_id = ?`,
+      )
+      .get(input.platform, input.accountId, input.messageId);
+    return row !== undefined;
+  }
+
+  /**
+   * Record the permanent recall tombstone and purge any row already stored,
+   * atomically. Returns the number of ledger rows deleted (0 when the recall
+   * arrived before the message did — the tombstone still stands and the later
+   * ingest is refused by {@link claimMessageOnce}).
+   */
+  recallMessage(input: {
+    platform: string;
+    accountId: string;
+    messageId: string;
+    recalledAt?: number;
+  }): number | null {
+    // An empty id would tombstone and delete rows keyed by '' — every row the
+    // store never managed to key. Refuse rather than guess.
+    if (!input.messageId) return 0;
+    return this.write(() => {
+      const db = this.requireDb();
+      db.prepare(
+        `INSERT OR IGNORE INTO recalled_messages(platform, account_id, message_id, recalled_at)
+          VALUES (?, ?, ?, ?)`,
+      ).run(input.platform, input.accountId, input.messageId, input.recalledAt ?? Date.now());
+      const result = db
+        .prepare(
+          `DELETE FROM clawchat_messages
+            WHERE platform = ? AND account_id = ? AND message_id = ?`,
+        )
+        .run(input.platform, input.accountId, input.messageId);
+      return Number(result.changes);
+    });
+  }
+
+  /**
+   * Low-level purge by message id. NOT the recall path: it writes no tombstone,
+   * so a recall routed through here loses to a redelivery or to an ingest that
+   * is still behind an await. Use {@link recallMessage} for `message.recall`.
+   */
+  deleteMessagesByMessageId(input: {
+    platform: string;
+    accountId: string;
+    messageId: string;
+  }): number | null {
+    // An empty id would match every row whose message_id is '' — deleting
+    // everything the store never managed to key. Refuse rather than guess.
+    if (!input.messageId) return 0;
+    return this.write(() => {
+      const result = this.requireDb()
+        .prepare(
+          `DELETE FROM clawchat_messages
+            WHERE platform = ? AND account_id = ? AND message_id = ?`,
+        )
+        .run(input.platform, input.accountId, input.messageId);
+      return Number(result.changes);
+    });
+  }
+
   startConnection(input: StartConnectionInput): number | null {
     return this.write(() => {
       const now = input.connectStartedAt ?? Date.now();

package/src/ws-alignment.ts

@@ -238,7 +238,6 @@ export interface ProtocolControlEnvelope {
 export interface CreateProtocolControlHandlerOptions {
   accountId: string;
   log: (msg: string) => void;
-  send: (wire: string) => void;
   scheduleReconnect?: (reason: string) => void;
   attempt?: number;
   reconnectCount?: number;
@@ -275,17 +274,12 @@ export function createProtocolControlHandler(options: CreateProtocolControlHandl
   return {
     handleInbound(env: ProtocolControlEnvelope): boolean {
       if (env.event === "ping") {
-        logControl("protocol_ping_received", "send_pong", [["trace_id", env.trace_id]]);
-        options.send(
-          JSON.stringify({
-            version: "2",
-            event: "pong",
-            trace_id: env.trace_id ?? "-",
-            // §12: echo the sender's emitted_at verbatim (do not restamp).
-            emitted_at: env.emitted_at ?? Date.now(),
-            payload: {},
-          }),
-        );
+        // §12: the server never emits a JSON-level `ping`, so this is an
+        // anomaly worth seeing — but answering it would send exactly the
+        // unsolicited `pong` the spec bans, which the server drops as an
+        // unknown uplink event. Log it and drop it; this handler has no send
+        // capability, so the banned frame cannot be produced here at all.
+        logControl("protocol_ping_received", "drop", [["trace_id", env.trace_id]]);
         return true;
       }
       if (env.event === "pong") {

package/src/ws-client.ts

@@ -646,11 +646,18 @@ export class ClawChatClient extends EventEmitter {
     if (env.event === EVENT.CONNECT_CHALLENGE) return this.onChallenge(env);
     if (env.event === EVENT.HELLO_OK) return this.onHelloOk(env);
     if (env.event === EVENT.HELLO_FAIL) return this.onHelloFail(env);
-    if (env.event === EVENT.PING) return this.onPing(env);
+    // §12: the server never emits a JSON-level `ping`, and an unsolicited
+    // `pong` is an unknown uplink event the server drops. We therefore do NOT
+    // answer a downlink ping. `pong` below is still handled: it is the reply
+    // to the client-initiated heartbeat probe §12 does allow.
     if (env.event === EVENT.PONG) return this.onPong();
     if (env.event === EVENT.MESSAGE_ACK) return this.onAck(env as Envelope<MessageAckPayload>);
     if (env.event === EVENT.MESSAGE_ERROR) return this.onMessageError(env as Envelope<MessageErrorPayload>);
     if (isBusinessDispatchEvent(env.event)) this.emit("message", env);
+    // Deliberately NOT a business dispatch event: `message` feeds the turn
+    // pipeline, and a recall has no body to turn into a prompt. It is an
+    // instruction to delete, so it gets its own emitter and its own consumer.
+    if (env.event === EVENT.MESSAGE_RECALL) this.emit("message:recall", env);
     if (env.event === EVENT.MESSAGE_CREATED) this.emit("message:created", env);
     if (env.event === EVENT.MESSAGE_ADD) this.emit("message:add", env);
     if (env.event === EVENT.MESSAGE_DONE) this.emit("message:done", env);
@@ -781,16 +788,6 @@ export class ClawChatClient extends EventEmitter {
     }
   }
 
-  private onPing(env: Envelope): void {
-    this.sendRawEnvelope({
-      version: "2",
-      event: EVENT.PONG,
-      trace_id: env.trace_id,
-      emitted_at: env.emitted_at,
-      payload: {} satisfies EmptyPayload,
-    });
-  }
-
   private onPong(): void {
     if (this.pongTimer) clearTimeout(this.pongTimer);
     this.pongTimer = undefined;