@agent-wechat/agent-wechat 1.0.0-beta.8 → 1.0.0-beta.9

package/dist/index.js

@@ -110,7 +110,7 @@ import { constants } from "node:fs";
 import { access, lstat, readFile, realpath } from "node:fs/promises";
 import { spawn, execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { delimiter, dirname, isAbsolute, join } from "node:path";
+import { delimiter, dirname, isAbsolute, join, toNamespacedPath } from "node:path";
 import { createConnection } from "node:net";
 
 // ../shared/dist/native.generated.js
@@ -146,13 +146,13 @@ var NativeApiError = class extends Error {
   }
 };
 function validateNativeBaseUrl(input) {
-  const url = new URL(input);
-  const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname.toLowerCase());
-  if (url.username || url.password || url.search || url.hash || !["http:", "https:"].includes(url.protocol) || url.protocol === "http:" && !loopback)
+  const url2 = new URL(input);
+  const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url2.hostname.toLowerCase());
+  if (url2.username || url2.password || url2.search || url2.hash || !["http:", "https:"].includes(url2.protocol) || url2.protocol === "http:" && !loopback)
     throw new Error("Native API requires verified HTTPS or a loopback HTTP endpoint, without embedded credentials");
-  if (!url.pathname.endsWith("/"))
-    url.pathname += "/";
-  return url;
+  if (!url2.pathname.endsWith("/"))
+    url2.pathname += "/";
+  return url2;
 }
 var id = (value) => {
   if (typeof value !== "string" || !value || value === "." || value === ".." || value.length > 4096 || /[\u0000-\u001f\u007f]/.test(value))
@@ -283,8 +283,24 @@ var NativeWeChatClient = class {
       throw new Error("Invalid login idempotency key");
     return this.request(`v1/accounts/${id(accountId)}/auth/login`, { method: "POST", headers: key ? { "Idempotency-Key": key } : void 0, body: JSON.stringify(options) });
   }
-  operation(accountId, operationId) {
-    return this.request(`v1/accounts/${id(accountId)}/operations/${id(operationId)}`);
+  operation(accountId, operationId, signal) {
+    return this.request(`v1/accounts/${id(accountId)}/operations/${id(operationId)}`, { signal });
+  }
+  /** Submit once with a stable key; inspect the returned operation after uncertainty. */
+  async recallMessage(accountId, messageId, serverId, idempotencyKey, signal) {
+    if (typeof serverId !== "string" || !/^[1-9]\d{0,19}$/.test(serverId) || BigInt(serverId) > 18446744073709551615n)
+      throw new Error("Invalid exact recall server ID");
+    if (typeof idempotencyKey !== "string" || !idempotencyKey || idempotencyKey.length > 200 || /[\r\n]/.test(idempotencyKey))
+      throw new Error("Invalid recall idempotency key");
+    const operation = await this.request(`v1/accounts/${id(accountId)}/messages/${id(messageId)}/recall`, {
+      method: "POST",
+      headers: { "Idempotency-Key": idempotencyKey },
+      body: JSON.stringify({ serverId }),
+      signal
+    });
+    if (!operation || operation.accountId !== accountId || operation.kind !== "message_recall" || typeof operation.id !== "string" || !operation.id || typeof operation.state !== "string")
+      throw new Error("Native recall operation identity is invalid");
+    return operation;
   }
   cancelOperation(accountId, operationId) {
     return this.request(`v1/accounts/${id(accountId)}/operations/${id(operationId)}`, { method: "DELETE" });
@@ -395,14 +411,19 @@ var NativeWeChatClient = class {
     }
     return result;
   }
-  sendText(accountId, threadId2, text, idempotencyKey) {
+  sendText(accountId, threadId2, text3, idempotencyKey) {
     if (!idempotencyKey || /[\r\n]/.test(idempotencyKey))
       throw new Error("An idempotency key is required");
-    return this.request(`v1/accounts/${id(accountId)}/sends`, { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify({ threadId: threadId2, text }) });
+    return this.request(`v1/accounts/${id(accountId)}/sends`, { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify({ threadId: threadId2, text: text3 }) });
   }
   send(accountId, sendId, signal) {
     return this.request(`v1/accounts/${id(accountId)}/sends/${id(sendId)}`, { signal });
   }
+  sendShare(accountId, input, key, signal) {
+    if (!key || key.length > 200 || /[\u0000-\u001f\u007f]/.test(key))
+      throw new Error("An idempotency key is required");
+    return this.request(`v1/accounts/${id(accountId)}/sends`, { method: "POST", headers: { "Idempotency-Key": key }, body: JSON.stringify(input), signal });
+  }
   sendByKey(accountId, key) {
     if (!key || key.length > 200)
       throw new Error("Invalid idempotency key");
@@ -411,11 +432,11 @@ var NativeWeChatClient = class {
   cancelSend(accountId, sendId) {
     return this.request(`v1/accounts/${id(accountId)}/sends/${id(sendId)}/cancel`, { method: "POST", body: "{}" });
   }
-  async upload(accountId, bytes, name, contentType = "application/octet-stream", signal) {
-    if (!bytes.length || bytes.length > NATIVE_MAX_SOURCE_BYTES || !name || name.length > 255 || /[\r\n/\\]/.test(name))
+  async upload(accountId, bytes, name2, contentType = "application/octet-stream", signal) {
+    if (!bytes.length || bytes.length > NATIVE_MAX_SOURCE_BYTES || !name2 || name2.length > 255 || /[\r\n/\\]/.test(name2))
       throw new Error("Invalid bounded media upload");
     const form = new FormData();
-    form.set("file", new Blob([new Uint8Array(bytes).buffer], { type: contentType }), name);
+    form.set("file", new Blob([new Uint8Array(bytes).buffer], { type: contentType }), name2);
     return this.request(`v1/accounts/${id(accountId)}/uploads`, { method: "POST", body: form, signal });
   }
   sendMedia(accountId, input, key) {
@@ -577,11 +598,22 @@ function requireNativeIdentity(value) {
   }
 }
 function nativeChildEnvironment(token, environment = process.env) {
-  return Object.fromEntries(["PATH", "HOME", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "TMPDIR", "TMP", "TEMP", "LANG", "LC_ALL", "TZ", "SSL_CERT_FILE", "SSL_CERT_DIR"].filter((name) => environment[name] !== void 0 && environment[name] !== token).map((name) => [name, environment[name]]));
+  return Object.fromEntries(["PATH", "HOME", "USERPROFILE", "APPDATA", "LOCALAPPDATA", "SystemRoot", "WINDIR", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "TMPDIR", "TMP", "TEMP", "LANG", "LC_ALL", "TZ", "SSL_CERT_FILE", "SSL_CERT_DIR"].filter((name2) => environment[name2] !== void 0 && environment[name2] !== token).map((name2) => [name2, environment[name2]]));
 }
 function nativeHostTarget(platform = process.platform, arch = process.arch) {
-  if (platform !== "linux" || !["x64", "arm64"].includes(arch)) throw new Error("native_binary_incompatible: managed hosting requires Linux x64 or ARM64; use external mode for remote daemons");
-  return { arch, rustTarget: arch === "arm64" ? "aarch64-unknown-linux-gnu" : "x86_64-unknown-linux-gnu" };
+  const cpu = arch === "arm64" ? "aarch64" : "x86_64";
+  const suffix = { linux: "unknown-linux-gnu", darwin: "apple-darwin", win32: "pc-windows-msvc" }[platform];
+  if (!suffix || !["x64", "arm64"].includes(arch) || platform === "darwin" && arch !== "arm64") throw new Error("native_binary_incompatible: unsupported host platform; use external mode for remote daemons");
+  return { platform, arch, rustTarget: `${cpu}-${suffix}`, key: `${platform}-${arch}${platform === "linux" ? "-gnu" : ""}`, executable: platform === "win32" ? "wx.exe" : "wx" };
+}
+function nativeExecutableFormat(bytes, platform = process.platform) {
+  if (platform === "linux") return bytes.subarray(0, 4).equals(Buffer.from([127, 69, 76, 70]));
+  if (platform === "darwin") return bytes.subarray(0, 4).equals(Buffer.from([207, 250, 237, 254]));
+  if (platform === "win32" && bytes.length >= 64 && bytes[0] === 77 && bytes[1] === 90) {
+    const offset = bytes.readUInt32LE(60);
+    return offset >= 64 && offset <= bytes.length - 4 && bytes.subarray(offset, offset + 4).equals(Buffer.from([80, 69, 0, 0]));
+  }
+  return false;
 }
 async function resolveNativeExecutable(explicit, path = process.env.PATH ?? "", environment = nativeChildEnvironment("")) {
   const target = nativeHostTarget();
@@ -590,40 +622,48 @@ async function resolveNativeExecutable(explicit, path = process.env.PATH ?? "",
   if (!candidate) {
     for (const directory of path.split(delimiter).filter(isAbsolute)) {
       try {
-        await access(join(directory, "wx"), constants.X_OK);
-        candidate = join(directory, "wx");
+        await access(join(directory, target.executable), constants.X_OK);
+        candidate = join(directory, target.executable);
         break;
       } catch {
       }
+      if (process.platform === "win32") {
+        const payload = join(directory, "node_modules", "@agent-wechat", "cli", "scripts", "native-launcher.mjs");
+        try {
+          await access(payload);
+          candidate = payload;
+          break;
+        } catch {
+        }
+      }
     }
   }
   if (!candidate) throw new Error("native_binary_missing: install native wx separately or configure its absolute path");
   candidate = await realpath(candidate);
-  if (candidate.endsWith("/scripts/native-launcher.mjs")) {
+  if (candidate.replaceAll("\\", "/").endsWith("/scripts/native-launcher.mjs")) {
     const root = dirname(dirname(candidate));
     const pkg = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
     if (pkg.name !== "@agent-wechat/cli" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(pkg.version)) throw new Error("Unsupported native CLI launcher");
     const manifest = JSON.parse(await readFile(join(root, "native-release.json"), "utf8"));
-    const asset = manifest.assets?.find((value) => value.rustTarget === target.rustTarget && value.platform === "linux" && value.arch === target.arch && value.libc === "gnu");
+    const asset = manifest.assets?.find((value) => value.rustTarget === target.rustTarget && value.platform === target.platform && value.arch === target.arch && (target.platform !== "linux" || value.libc === "gnu"));
     if (manifest.version !== pkg.version || !asset || !/^[a-f0-9]{64}$/.test(asset.sha256)) throw new Error("Native CLI manifest is incompatible");
-    candidate = await realpath(join(root, "native", pkg.version, `linux-${target.arch}-gnu`, "wx"));
+    candidate = await realpath(join(root, "native", pkg.version, target.key, target.executable));
     const bytes = await readFile(candidate);
     if (bytes.length !== asset.bytes || createHash2("sha256").update(bytes).digest("hex") !== asset.sha256) throw new Error("Installed native executable checksum mismatch");
   }
   const stat = await lstat(candidate);
   if (!stat.isFile() || stat.isSymbolicLink()) throw new Error("Native executable must be a regular file");
   await access(candidate, constants.X_OK);
-  const magic = (await readFile(candidate)).subarray(0, 4);
-  if (!magic.equals(Buffer.from([127, 69, 76, 70]))) throw new Error("native_binary_required: configure the actual native ELF executable, not an unverified process wrapper");
+  if (!nativeExecutableFormat(await readFile(candidate))) throw new Error("native_binary_required: configure the actual native executable for this OS");
   const { stdout } = await exec(candidate, ["--json", "version"], { env: environment, timeout: 5e3, maxBuffer: 65536 });
   const version = JSON.parse(stdout);
   requireNativeIdentity(version);
   if (version.target !== target.rustTarget) throw new Error("native_binary_incompatible: executable architecture differs from this host");
   return candidate;
 }
-async function portOccupied(url) {
+async function portOccupied(url2) {
   return new Promise((resolve, reject) => {
-    const socket = createConnection({ host: url.hostname.replace(/^\[|\]$/g, ""), port: Number(url.port || (url.protocol === "https:" ? 443 : 80)) });
+    const socket = createConnection({ host: url2.hostname.replace(/^\[|\]$/g, ""), port: Number(url2.port || (url2.protocol === "https:" ? 443 : 80)) });
     socket.setTimeout(1e3);
     socket.once("connect", () => {
       socket.destroy();
@@ -640,7 +680,7 @@ async function portOccupied(url) {
     });
   });
 }
-async function stopOwnedChild(child) {
+async function stopOwnedChild(child, graceful) {
   if (!child.pid || child.exitCode !== null || child.signalCode !== null) return;
   await new Promise((resolve) => {
     const kill = setTimeout(() => {
@@ -650,7 +690,10 @@ async function stopOwnedChild(child) {
       clearTimeout(kill);
       resolve();
     });
-    child.kill("SIGTERM");
+    if (graceful) void graceful().catch(() => {
+      if (child.exitCode === null && child.signalCode === null) child.kill("SIGTERM");
+    });
+    else child.kill("SIGTERM");
   });
 }
 async function startNativeHost(config) {
@@ -665,11 +708,11 @@ async function startNativeHost(config) {
     });
   }
   if (config.mode !== "managed" || config.endpoint || !config.dataDir || !isAbsolute(config.dataDir) || config.serverConfig && !isAbsolute(config.serverConfig)) throw new Error("Managed native mode requires absolute dataDir/config paths and no remote endpoint");
-  const url = validateNativeBaseUrl(`http://${config.listen ?? "127.0.0.1:6174"}`);
-  if (await portOccupied(url)) throw new Error("native_owner_conflict: configured port is already owned; use external mode for an independently operated daemon");
+  const url2 = validateNativeBaseUrl(`http://${config.listen ?? "127.0.0.1:6174"}`);
+  if (await portOccupied(url2)) throw new Error("native_owner_conflict: configured port is already owned; use external mode for an independently operated daemon");
   const executable = await resolveNativeExecutable(config.executable, void 0, nativeChildEnvironment(token));
-  const client = new NativeWeChatClient({ baseUrl: url.href, token, timeoutMs: 1e3 });
-  const args = ["serve", "--data-dir", config.dataDir, "--token-stdin", "--listen", url.host];
+  const client = new NativeWeChatClient({ baseUrl: url2.href, token, timeoutMs: 1e3 });
+  const args = ["serve", "--data-dir", config.dataDir, "--token-stdin", "--listen", url2.host];
   if (config.serverConfig) args.push("--server-config", config.serverConfig);
   const child = spawn(executable, args, { env: nativeChildEnvironment(token), stdio: ["pipe", "ignore", "pipe"], shell: false });
   child.stderr?.on("data", () => {
@@ -692,10 +735,21 @@ async function startNativeHost(config) {
       if (exited) throw new Error("Native owned child exited before readiness");
       try {
         const status = await client.status();
-        const dataDir = await realpath(config.dataDir);
+        const canonical = await realpath(config.dataDir);
+        const dataDir = process.platform === "win32" ? toNamespacedPath(canonical) : canonical;
         if (exited || status.version.backend !== "native" || status.version.apiVersion !== 1 || status.pid !== child.pid || status.dataDir !== dataDir || typeof status.serverId !== "string" || typeof status.ownershipGeneration !== "string") throw new Error("native_owner_conflict: readiness identity does not match the owned process/store");
         requireNativeIdentity(status.version);
-        return host(new NativeWeChatClient({ baseUrl: url.href, token }), token, () => stopOwnedChild(child));
+        return host(new NativeWeChatClient({ baseUrl: url2.href, token }), token, () => stopOwnedChild(child, async () => {
+          const response = await fetch(new URL("v1/daemon/shutdown", url2), {
+            method: "POST",
+            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+            body: JSON.stringify({ pid: status.pid, serverId: status.serverId, ownershipGeneration: status.ownershipGeneration }),
+            redirect: "error",
+            signal: AbortSignal.timeout(3e3)
+          });
+          if (!response.ok) throw new Error("Owned daemon refused graceful shutdown");
+          await response.body?.cancel();
+        }));
       } catch (error) {
         if (String(error).includes("native_owner_conflict")) throw error;
         await new Promise((resolve) => setTimeout(resolve, 100));
@@ -1024,25 +1078,25 @@ function appendReference(body, reference) {
   return body ? `${body}
 ${reference}` : reference;
 }
-function safeDisplayName(name) {
-  return name.replace(/[\r\n\0]/g, " ").trim() || "attachment";
+function safeDisplayName(name2) {
+  return name2.replace(/[\r\n\0]/g, " ").trim() || "attachment";
 }
 function renderAttachmentBody(originalBody, attachment, exposeNonVisualPath = true) {
   if (!attachment) return originalBody;
-  const name = safeDisplayName(attachment.filename);
+  const name2 = safeDisplayName(attachment.filename);
   if (attachment.status !== "ready" || !attachment.path) {
     const label = attachment.kind === "file" ? "File" : attachment.kind === "image" ? "Image" : attachment.kind === "audio" ? "Voice message" : "Video";
     if (attachment.status === "pending") {
-      return appendReference(originalBody, `[${label} pending: ${name}]`);
+      return appendReference(originalBody, `[${label} pending: ${name2}]`);
     }
     if (attachment.status === "expired") {
-      return appendReference(originalBody, `[${label} expired: ${name}; no cached copy available. Ask the sender to resend.]`);
+      return appendReference(originalBody, `[${label} expired: ${name2}; no cached copy available. Ask the sender to resend.]`);
     }
-    return appendReference(originalBody, `[${label} unavailable: ${name} (${attachment.status})]`);
+    return appendReference(originalBody, `[${label} unavailable: ${name2} (${attachment.status})]`);
   }
   if (attachment.kind === "file") {
-    const prefix = originalBody.trim() === name ? "" : originalBody;
-    return appendReference(prefix, `[File: ${name}]
+    const prefix = originalBody.trim() === name2 ? "" : originalBody;
+    return appendReference(prefix, `[File: ${name2}]
 [Local file: <${attachment.path}>]`);
   }
   if (exposeNonVisualPath) {
@@ -1061,11 +1115,117 @@ function renderAttachmentBody(originalBody, attachment, exposeNonVisualPath = tr
   return body;
 }
 
+// src/native-send.ts
+async function nativeOutboundDelivery(client, accountId, threadId2, messageIds, source) {
+  const receipts = [];
+  try {
+    if (!Array.isArray(messageIds) || !messageIds.length || messageIds.length > 256 || messageIds.some((id2) => typeof id2 !== "string" || !id2 || id2.length > 4096) || new Set(messageIds).size !== messageIds.length) throw Error("Message receipts unavailable");
+    for (const [index, messageId] of messageIds.entries()) {
+      const message = await client.message(accountId, messageId);
+      if (message.id !== messageId || message.accountId !== accountId || message.threadId !== threadId2 || message.direction !== "outgoing" || typeof message.serverId !== "string" || !/^[1-9]\d{0,19}$/.test(message.serverId) || BigInt(message.serverId) > 18446744073709551615n || source.serverIds?.[index] != null && source.serverIds[index] !== message.serverId) throw Error("Message receipt identity mismatch");
+      receipts.push({ messageId, serverId: message.serverId, accountId, threadId: threadId2 });
+    }
+  } catch {
+    return { messageId: "", meta: {
+      accountId,
+      threadId: threadId2,
+      ...source,
+      messageIds: receipts,
+      outcome: "unknown",
+      receiptState: "needs_review",
+      retryable: false,
+      note: "Send submitted. Inspect the durable send/job and retained receipts; do not resend automatically."
+    } };
+  }
+  return { messageId: receipts[0].messageId, meta: {
+    accountId,
+    threadId: threadId2,
+    serverId: receipts[0].serverId,
+    outcome: "sent",
+    ...source,
+    messageIds: receipts,
+    receiptState: "verified"
+  } };
+}
+async function submitNativeText(client, accountId, threadId2, text3, key, options = {}) {
+  let intent = await client.sendText(accountId, threadId2, text3, key);
+  const deadline = Date.now() + Math.max(1, Math.min(options.timeoutMs ?? 65e3, 65e3));
+  let delay = Math.max(1, Math.min(options.initialDelayMs ?? 250, 1e3));
+  while (["queued", "submitting"].includes(intent.state) && Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, Math.min(delay, deadline - Date.now())));
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    intent = await client.send(accountId, intent.id, AbortSignal.timeout(remaining));
+    delay = Math.min(delay * 2, 1e3);
+  }
+  if (!["accepted", "sent", "server_accepted"].includes(intent.state)) throw new Error(`Native send ${intent.id} requires inspection (${intent.state}); do not automatically resend`);
+  return intent;
+}
+
+// src/native-recall-state.ts
+function nativeRecallInfo(message) {
+  return message.recall;
+}
+function nativeRecallIdentity(threadId2, serverId) {
+  return JSON.stringify([threadId2, serverId]);
+}
+function validateNativeRecall(value) {
+  if (!value || typeof value.threadId !== "string" || !value.threadId || value.threadId.length > 4096 || typeof value.serverId !== "string" || !/^[1-9]\d{0,19}$/.test(value.serverId) || BigInt(value.serverId) > 18446744073709551615n || typeof value.observedAt !== "string" || value.observedAt.length > 128 || !Number.isFinite(Date.parse(value.observedAt)) || value.recalledAt !== void 0 && (typeof value.recalledAt !== "string" || value.recalledAt.length > 128 || !Number.isFinite(Date.parse(value.recalledAt))) || value.messageId !== void 0 && (typeof value.messageId !== "string" || !value.messageId || value.messageId.length > 4096)) throw Error("Invalid native recall observation; cursor retained");
+}
+function recalledNativeMessage(message, recall) {
+  return {
+    ...message,
+    type: 1e4,
+    body: "[Message recalled]",
+    quote: void 0,
+    link: void 0,
+    media: [],
+    mentions: { state: "unknown", userIds: [], self: null, all: null, source: null },
+    recall: { observedAt: recall.observedAt, ...recall.recalledAt ? { recalledAt: recall.recalledAt } : {} }
+  };
+}
+
 // src/native-media.ts
 function kind(type) {
   return type === 3 || type === 47 ? "image" : type === 34 ? "audio" : type === 43 ? "video" : type === 49 ? "file" : void 0;
 }
-var terminalJobs = /* @__PURE__ */ new Set(["accepted", "completed", "succeeded", "available", "failed", "cancelled", "expired", "needs_review"]);
+var terminalJobs = /* @__PURE__ */ new Set(["accepted", "completed", "succeeded", "available", "failed", "partial", "cancelled", "expired", "needs_review"]);
+var successfulSendJobs = /* @__PURE__ */ new Set(["accepted", "completed", "succeeded"]);
+var terminalIdentityErrors = /* @__PURE__ */ new Set(["media_identity_unavailable", "media_source_changed"]);
+function mediaSendResult(job) {
+  return job.result && typeof job.result === "object" && !Array.isArray(job.result) ? job.result : {};
+}
+function mediaSendReceiptIds(job, audioAsVoice) {
+  const result = mediaSendResult(job), ids = result.messageIds;
+  if (!successfulSendJobs.has(job.state) || result.profileProjection === "unknown" || !Array.isArray(ids) || !ids.length || ids.length > 256 || ids.some((id2) => typeof id2 !== "string" || !id2 || id2.length > 4096) || new Set(ids).size !== ids.length) return void 0;
+  if (audioAsVoice) {
+    const chunks = result.chunks;
+    if (!Array.isArray(chunks) || !chunks.length || chunks.length !== ids.length || chunks.some((chunk) => !chunk || chunk.state !== "accepted" || typeof chunk.serverMessageId !== "string")) return void 0;
+  } else if (ids.length !== 1) return void 0;
+  return ids;
+}
+async function waitNativeMediaSendReceipts(client, accountId, threadId2, initial, audioAsVoice, timeoutMs = 1e4) {
+  if (initial.accountId !== accountId || initial.threadId !== threadId2 || initial.kind !== "send") throw Error("Native media receipt job identity mismatch; inspect the submitted job and do not resend");
+  const deadline = Date.now() + Math.max(0, Math.min(timeoutMs, 1e4));
+  let job = initial, delay = 100;
+  while (successfulSendJobs.has(job.state) && !mediaSendReceiptIds(job, audioAsVoice) && Date.now() < deadline) {
+    const result = mediaSendResult(job);
+    if (["unknown", "not_applicable"].includes(String(result.profileProjection)) || audioAsVoice && Array.isArray(result.chunks) && result.chunks.some((chunk) => !chunk || chunk.state !== "accepted")) break;
+    await new Promise((resolve) => setTimeout(resolve, Math.min(delay, Math.max(0, deadline - Date.now()))));
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    let next;
+    try {
+      next = await client.job(accountId, initial.id, AbortSignal.timeout(remaining));
+    } catch {
+      break;
+    }
+    if (next.id !== initial.id || next.accountId !== accountId || next.threadId !== threadId2 || next.kind !== "send" || next.sourceId !== initial.sourceId || initial.serverMessageId != null && next.serverMessageId !== initial.serverMessageId) break;
+    job = next;
+    delay = Math.min(delay * 2, 1e3);
+  }
+  return job;
+}
 async function waitNativeMediaJob(client, accountId, initial, timeoutMs = 65e3, signal, assertCurrent) {
   const deadline = Date.now() + timeoutMs;
   let job = initial;
@@ -1103,6 +1263,43 @@ async function prepareImageRepresentation(bytes, mime, cfg) {
   }
   throw Error("Native model image representation exceeds its bound");
 }
+async function prepareNativeLink(params) {
+  const { message } = params;
+  const link = message.link;
+  const body = [`[Link]${link.title ? ` ${link.title}` : ""}`, link.description, link.url].filter(Boolean).join("\n").slice(0, 65536);
+  const unavailable = (status, reason) => ({
+    body: `${body}
+[Link preview ${status}]`,
+    pending: false,
+    retryable: false,
+    reason,
+    attachment: { kind: "image", status, filename: "link-preview" }
+  });
+  if (params.quality && !["best", "thumbnail"].includes(params.quality)) return unavailable("unsupported", "unsupported_media_variant");
+  let prepared;
+  try {
+    prepared = await prepareNativeAttachment({
+      ...params,
+      quality: "thumbnail",
+      message: { ...message, type: 3, appMessageType: void 0, quote: void 0, link: void 0 }
+    });
+  } catch (error) {
+    params.signal?.throwIfAborted();
+    params.assertCurrent?.();
+    if (!(error instanceof NativeApiError)) throw error;
+    if (terminalIdentityErrors.has(error.code) || error.code === "message_recalled") throw error;
+    return { ...unavailable("unavailable", error.code), retryable: error.retryable };
+  }
+  if (prepared.reason === "message_recalled" || terminalIdentityErrors.has(prepared.reason ?? "")) return prepared;
+  return {
+    ...prepared,
+    body: `${body}
+[Link preview]
+${prepared.body}`,
+    pending: false,
+    ...prepared.pending ? { attachment: { kind: "image", status: "pending", filename: "link-preview" } } : {}
+  };
+}
 async function prepareNativeQuote(params) {
   const { client, account, message } = params;
   const guard = () => {
@@ -1112,7 +1309,6 @@ async function prepareNativeQuote(params) {
   guard();
   const comment = (message.body ?? "").slice(0, 16384);
   const unavailable = (state) => ({ body: `${comment}${comment ? "\n\n" : ""}[Quoted message ${state}; original lookup is confined to this chat]`, pending: false, retryable: state === "unavailable", quote: { state } });
-  if (!message.quote) return unavailable("invalid");
   await params.beforeMediaAccess?.();
   guard();
   let resolution;
@@ -1121,10 +1317,13 @@ async function prepareNativeQuote(params) {
   } catch (error) {
     guard();
     if (!(error instanceof NativeApiError)) throw error;
-    return unavailable("unavailable");
+    if (error.code === "message_recalled") return { ...unavailable("recalled"), retryable: false, reason: "message_recalled" };
+    return terminalIdentityErrors.has(error.code) ? { ...unavailable("unavailable"), retryable: false, reason: error.code } : unavailable("unavailable");
   }
   guard();
   if (resolution.accountId !== message.accountId || resolution.messageId !== message.id || resolution.threadId !== message.threadId) throw Error("Native quote identity does not match its message");
+  if (resolution.state === "recalled" || resolution.message && nativeRecallInfo(resolution.message)) return { ...unavailable("recalled"), retryable: false, reason: "message_recalled" };
+  if (!message.quote) return unavailable("invalid");
   if (resolution.state === "embedded") {
     if (resolution.message != null || (message.quote.type === 1 ? typeof resolution.embeddedText !== "string" || resolution.embeddedText.length > 16384 : message.quote.type !== 3 || resolution.embeddedImage !== true)) throw Error("Invalid embedded quote resolution");
     const author = { senderId: resolution.senderId ?? null, direction: null };
@@ -1182,6 +1381,25 @@ async function prepareNativeQuote(params) {
   };
 }
 async function prepareNativeAttachment(params) {
+  try {
+    return await prepareNativeAttachmentInput(params);
+  } catch (error) {
+    params.signal?.throwIfAborted();
+    params.assertCurrent?.();
+    if (!(error instanceof NativeApiError) || !terminalIdentityErrors.has(error.code)) throw error;
+    if (params.message.type === 49 && params.message.appMessageType === 57) return {
+      body: `${(params.message.body ?? "").slice(0, 16384)}
+[Quoted message unavailable: stored source identity could not be verified]`,
+      quote: { state: "unavailable" },
+      pending: false,
+      retryable: false,
+      reason: error.code
+    };
+    const attachment = { kind: kind(params.message.type) ?? "file", filename: "attachment", status: "unavailable" };
+    return { body: renderAttachmentBody("", attachment), attachment, pending: false, retryable: false, reason: error.code };
+  }
+}
+async function prepareNativeAttachmentInput(params) {
   const { client, account, message, core } = params;
   const attachmentKind = kind(message.type);
   const guard = () => {
@@ -1189,6 +1407,7 @@ async function prepareNativeAttachment(params) {
     params.assertCurrent?.();
   };
   guard();
+  if (nativeRecallInfo(message)) return { body: "[Message recalled]", pending: false, retryable: false, reason: "message_recalled" };
   const authorize = async () => {
     guard();
     await params.beforeMediaAccess?.();
@@ -1196,6 +1415,7 @@ async function prepareNativeAttachment(params) {
   };
   if (message.type === 49 && message.appMessageType === 57) return prepareNativeQuote(params);
   if (message.type === 49 && message.appMessageType === 19) return { body: message.body?.slice(0, 65536) || "[Forwarded chat history unavailable]", pending: false };
+  if (message.type === 49 && [3, 4, 5].includes(message.appMessageType ?? 0) && message.link) return prepareNativeLink(params);
   if (message.type === 49 && message.appMessageType != null && message.appMessageType !== 6) return { body: `[Unsupported WeChat app message subtype ${message.appMessageType}]`, pending: false, retryable: false };
   if (!attachmentKind) return { body: message.type === 1 ? message.body ?? "" : `[Unsupported WeChat message type ${message.type}]`, pending: false };
   const accountId = account.native.accountId;
@@ -1223,34 +1443,38 @@ async function prepareNativeAttachment(params) {
   }
   let job;
   let transferError;
-  if (!asset && initialCandidate?.jobId) {
+  if (!asset && initialCandidate?.jobId && initialCandidate.state !== "recalled") {
     await authorize();
     job = await client.job(accountId, initialCandidate.jobId, params.signal);
     guard();
     if (job.accountId !== accountId || job.kind !== "download" || job.assetId != null && job.assetId !== initialCandidate.id) throw Error("Native download job identity does not match its attachment");
     assets = await scopedAssets();
     asset = select(assets, message.type, quality);
+    if (!asset && transferCandidate()?.state === "recalled") return { body: "[Message recalled]", pending: false, retryable: false, reason: "message_recalled" };
     if (!asset && ["queued", "running"].includes(job.state)) return { body: `[${attachmentKind} pending]`, pending: true, jobId: job.id, retryable: true };
   }
-  if (!asset && !job && params.download !== false && !["expired", "unsupported"].includes(transferCandidate()?.state ?? "")) {
+  if (!asset && !job && params.download !== false && !["expired", "unsupported", "recalled"].includes(transferCandidate()?.state ?? "")) {
+    await authorize();
     try {
-      await authorize();
       job = await client.transferMedia(accountId, { messageId: message.id, assetId: null, quality: transferQuality });
       guard();
       job = await waitNativeMediaJob(client, accountId, job, params.waitMs ?? 2e4, params.signal, guard);
       guard();
     } catch (error) {
       guard();
-      if (!(error instanceof NativeApiError) || error.retryable) return { body: `[${attachmentKind} pending: retrieval is unavailable]`, pending: true, jobId: job?.id, retryable: true };
+      if (!(error instanceof NativeApiError) || terminalIdentityErrors.has(error.code)) throw error;
+      if (error.retryable) return { body: `[${attachmentKind} pending: retrieval is unavailable]`, pending: true, jobId: job?.id, retryable: true };
       transferError = error;
     }
     assets = await scopedAssets();
     asset = select(assets, message.type, quality);
+    if (!asset && transferCandidate()?.state === "recalled") return { body: "[Message recalled]", pending: false, retryable: false, reason: "message_recalled" };
     if (!asset && job && ["queued", "running"].includes(job.state)) return { body: `[${attachmentKind} pending]`, pending: true, jobId: job.id, retryable: true };
   }
   const candidate = transferCandidate();
   const filename = basename(asset?.filename ?? candidate?.filename ?? `message-${createHash4("sha256").update(message.id).digest("hex").slice(0, 12)}.bin`).replace(/[\r\n\0]/g, "_");
   if (!asset) {
+    if (candidate?.state === "recalled" || transferError?.code === "message_recalled") return { body: "[Message recalled]", pending: false, retryable: false, reason: "message_recalled" };
     const state = candidate?.state === "expired" ? "expired" : candidate?.state === "unsupported" ? "unsupported" : "unavailable";
     const attachment2 = { kind: attachmentKind, filename, status: state, expiresAt: candidate?.expiresAt ?? void 0 };
     return {
@@ -1346,7 +1570,7 @@ async function prepareNativeAttachment(params) {
     pending: false
   };
 }
-async function sendNativeAttachment(client, account, threadId2, mediaUrl, audioAsVoice = false, key = randomUUID()) {
+async function sendNativeAttachment(client, account, threadId2, mediaUrl, audioAsVoice = false, key = randomUUID(), beforeSend) {
   const max = Math.min(account.mediaMaxMb * 1024 * 1024, NATIVE_MAX_SOURCE_BYTES);
   let bytes;
   let filename;
@@ -1361,7 +1585,7 @@ async function sendNativeAttachment(client, account, threadId2, mediaUrl, audioA
     }
     const reader = response.body?.getReader();
     if (!reader) throw new Error("Native outbound source has no bytes");
-    const chunks = [];
+    const chunks2 = [];
     let size = 0;
     try {
       while (true) {
@@ -1369,7 +1593,7 @@ async function sendNativeAttachment(client, account, threadId2, mediaUrl, audioA
         if (done) break;
         size += value.length;
         if (size > max) throw new Error("Native outbound source exceeds configured size");
-        chunks.push(value);
+        chunks2.push(value);
       }
     } catch (error) {
       await reader.cancel();
@@ -1379,7 +1603,7 @@ async function sendNativeAttachment(client, account, threadId2, mediaUrl, audioA
     }
     bytes = new Uint8Array(size);
     let offset = 0;
-    for (const chunk of chunks) {
+    for (const chunk of chunks2) {
       bytes.set(chunk, offset);
       offset += chunk.length;
     }
@@ -1391,7 +1615,7 @@ async function sendNativeAttachment(client, account, threadId2, mediaUrl, audioA
     try {
       const stat = await file.stat();
       if (!stat.isFile() || stat.size === 0 || stat.size > max) throw new Error("Native outbound source must be a bounded regular file");
-      const chunks = [];
+      const chunks2 = [];
       let size = 0;
       while (true) {
         const chunk = Buffer.alloc(Math.min(65536, max + 1 - size));
@@ -1399,9 +1623,9 @@ async function sendNativeAttachment(client, account, threadId2, mediaUrl, audioA
         if (!bytesRead) break;
         size += bytesRead;
         if (size > max) throw new Error("Native outbound source exceeds configured size");
-        chunks.push(chunk.subarray(0, bytesRead));
+        chunks2.push(chunk.subarray(0, bytesRead));
       }
-      bytes = Buffer.concat(chunks, size);
+      bytes = Buffer.concat(chunks2, size);
     } finally {
       await file.close();
     }
@@ -1410,43 +1634,39 @@ async function sendNativeAttachment(client, account, threadId2, mediaUrl, audioA
     mime = [".png", ".jpg", ".jpeg", ".gif", ".webp"].includes(extension) ? `image/${extension === ".jpg" ? "jpeg" : extension.slice(1)}` : extension === ".mp4" ? "video/mp4" : [".wav", ".mp3", ".ogg", ".m4a", ".flac", ".aac"].includes(extension) ? `audio/${extension.slice(1)}` : "application/octet-stream";
   }
   if (audioAsVoice && !mime.startsWith("audio/")) throw new Error("Voice sending requires an explicit audio attachment");
+  await beforeSend?.();
   const accountId = account.native.accountId;
   const source = await client.upload(accountId, bytes, filename, mime);
   const input = { threadId: threadId2, kind: audioAsVoice ? "voice" : mime.startsWith("image/") ? "image" : mime.startsWith("video/") ? "video" : "file", sourceId: source.id, standardSourceId: null, thumbnailSourceId: null, playSeconds: null, durationMs: null };
-  const job = await waitNativeMediaJob(client, accountId, await client.sendMedia(accountId, input, key), audioAsVoice ? 25 * 6e4 : 65e3);
-  if (!["accepted", "completed", "succeeded"].includes(job.state)) throw new Error(`Native media job ${job.id} requires inspection (${job.state}); retain completed items and do not automatically resend`);
-  return `agent-wechat-native:${accountId}:${job.id}`;
-}
-
-// src/native-send.ts
-async function submitNativeText(client, accountId, threadId2, text, key, options = {}) {
-  let intent = await client.sendText(accountId, threadId2, text, key);
-  const deadline = Date.now() + Math.max(1, Math.min(options.timeoutMs ?? 65e3, 65e3));
-  let delay = Math.max(1, Math.min(options.initialDelayMs ?? 250, 1e3));
-  while (["queued", "submitting"].includes(intent.state) && Date.now() < deadline) {
-    await new Promise((resolve) => setTimeout(resolve, Math.min(delay, deadline - Date.now())));
-    const remaining = deadline - Date.now();
-    if (remaining <= 0) break;
-    intent = await client.send(accountId, intent.id, AbortSignal.timeout(remaining));
-    delay = Math.min(delay * 2, 1e3);
-  }
-  if (!["accepted", "sent", "server_accepted"].includes(intent.state)) throw new Error(`Native send ${intent.id} requires inspection (${intent.state}); do not automatically resend`);
-  return intent;
+  await beforeSend?.();
+  let job = await waitNativeMediaJob(client, accountId, await client.sendMedia(accountId, input, key), audioAsVoice ? 25 * 6e4 : 65e3);
+  if (successfulSendJobs.has(job.state)) job = await waitNativeMediaSendReceipts(client, accountId, threadId2, job, audioAsVoice);
+  if (!successfulSendJobs.has(job.state)) throw new Error(`Native media job ${job.id} requires inspection (${job.state}); retain completed items and do not automatically resend`);
+  const result = mediaSendResult(job);
+  const chunks = Array.isArray(result.chunks) ? result.chunks.filter((chunk) => chunk && typeof chunk === "object") : [];
+  const serverIds = audioAsVoice ? chunks.filter((chunk) => chunk.state === "accepted" && typeof chunk.serverMessageId === "string").map((chunk) => chunk.serverMessageId) : job.serverMessageId ? [job.serverMessageId] : void 0;
+  return nativeOutboundDelivery(client, accountId, threadId2, mediaSendReceiptIds(job, audioAsVoice), { jobId: job.id, state: job.state, serverIds });
 }
 
 // src/outbound-media.ts
-async function sendWeChatMedia(cfg, to, text, mediaUrl, audioAsVoice = false, idempotencyKey) {
+async function sendWeChatMedia(cfg, to, text3, mediaUrl, audioAsVoice = false, idempotencyKey) {
   const account = resolveWeChatAccount(cfg);
   if (!account?.native) throw new Error("No native daemon configured");
   const { client } = await ensureNativeHost(account.native);
   const key = idempotencyKey ?? randomUUID2();
   if (!mediaUrl) {
     if (audioAsVoice) throw new Error("Voice sending requires an audio attachment");
-    const send = await submitNativeText(client, account.native.accountId, to, text, key);
-    return `agent-wechat-native:${account.native.accountId}:${send.id}`;
+    const send = await submitNativeText(client, account.native.accountId, to, text3, key);
+    return nativeOutboundDelivery(
+      client,
+      account.native.accountId,
+      to,
+      send.localMessageId ? [send.localMessageId] : [],
+      { sendId: send.id, state: send.state, serverIds: send.serverId ? [send.serverId] : void 0 }
+    );
   }
   const result = await sendNativeAttachment(client, account, to, mediaUrl, audioAsVoice, key);
-  if (text) await submitNativeText(client, account.native.accountId, to, text, createHash5("sha256").update(`${key}\0caption`).digest("hex"));
+  if (text3) await submitNativeText(client, account.native.accountId, to, text3, createHash5("sha256").update(`${key}\0caption`).digest("hex"));
   return result;
 }
 
@@ -1474,9 +1694,16 @@ var NativeConsumerState = class {
       for (const [id2, item] of Object.entries(parsed.items)) {
         if (item.message?.id !== id2 || item.message.accountId !== accountId || typeof item.message.threadId !== "string" || !["received", "dispatching", "handed_off", "completed", "ignored", "needs_review"].includes(item.state)) throw new Error("Invalid native custody record; state was preserved");
         if (item.cursor != null && !/^\d+$/.test(item.cursor) || item.groupContext != null && typeof item.groupContext !== "boolean") throw new Error("Invalid native group context record; state was preserved");
+        if (item.revision != null && (typeof item.revision !== "string" || !item.revision || item.revision.length > 64)) throw Error("Invalid native custody revision; state was preserved");
+        item.revision ??= randomUUID3();
         if (item.groupContext && (!item.cursor || item.origin !== "live" || item.state !== "ignored" || item.message.direction !== "incoming" || !item.message.threadId.endsWith("@chatroom"))) throw new Error("Invalid native buffered group context; state was preserved");
         if (item.state === "dispatching") item.state = "needs_review";
       }
+      if (parsed.recalls != null && (!parsed.recalls || typeof parsed.recalls !== "object" || Array.isArray(parsed.recalls))) throw Error("Invalid native recall state; state was preserved");
+      for (const [key, recall] of Object.entries(parsed.recalls ?? {})) {
+        validateNativeRecall(recall);
+        if (key !== nativeRecallIdentity(recall.threadId, recall.serverId)) throw Error("Invalid native recall identity; state was preserved");
+      }
       this.value = parsed;
       this.persist();
     }
@@ -1484,12 +1711,22 @@ var NativeConsumerState = class {
   get cursor() {
     return this.value.cursor;
   }
+  get accountId() {
+    return this.value.accountId;
+  }
   items() {
     return Object.values(this.value.items);
   }
   get(messageId) {
     return this.value.items[messageId];
   }
+  isRecalled(message) {
+    return !!nativeRecallInfo(message) || !!(message.serverId && this.value.recalls?.[nativeRecallIdentity(message.threadId, message.serverId)]);
+  }
+  isCurrent(message, revision) {
+    const current = this.get(message.id);
+    return !!current && (revision === void 0 || current.revision === revision) && !this.isRecalled(message) && JSON.stringify(current.message) === JSON.stringify(message);
+  }
   persist() {
     const directory = dirname2(this.file);
     mkdirSync(directory, { recursive: true, mode: 448 });
@@ -1533,42 +1770,129 @@ var NativeConsumerState = class {
   accept(cursor, message, origin = "unknown") {
     if (!/^\d+$/.test(cursor) || BigInt(cursor) < BigInt(this.value.cursor)) throw new Error("Native journal cursor cannot move backward");
     if (message && (!message.id || message.accountId !== this.value.accountId)) throw new Error("Native journal message crosses account boundary");
+    let replaced = false;
     this.mutate(() => {
-      if (message && !this.value.items[message.id]) {
+      if (message?.serverId && nativeRecallInfo(message)) this.rememberRecall({ messageId: message.id, threadId: message.threadId, serverId: message.serverId, ...nativeRecallInfo(message) });
+      if (message?.serverId) {
+        const recall = this.value.recalls?.[nativeRecallIdentity(message.threadId, message.serverId)];
+        if (recall) message = recalledNativeMessage(message, recall);
+      }
+      const existing = message ? this.value.items[message.id] : void 0;
+      replaced = !!message && !nativeRecallInfo(message) && !!existing && (existing.message.threadId !== message.threadId || existing.message.serverId !== message.serverId);
+      if (message && (!existing || replaced)) {
         const completed = Object.entries(this.value.items).filter(([, item]) => !item.readPending && !item.groupContext && item.phoneReadState !== "needs_review" && item.phoneReadState !== "rejected" && ["completed", "ignored"].includes(item.state));
         for (const [key] of completed.slice(0, Math.max(0, completed.length - 1e3))) delete this.value.items[key];
-        if (Object.keys(this.value.items).length >= 5e3) throw new Error("Native custody queue is full; operator review required");
-        this.value.items[message.id] = { message, origin, state: "received", cursor };
+        if (!existing && Object.keys(this.value.items).length >= 5e3) throw new Error("Native custody queue is full; operator review required");
+        if (replaced) {
+          for (const item of this.items()) {
+            const manifest = item.dispatchManifest;
+            if (!manifest || ![
+              ...manifest.messageIds,
+              ...(manifest.historyInputs ?? []).map((input) => input.id),
+              ...manifest.assets.flatMap((asset) => asset.sourceMessageId ? [asset.sourceMessageId] : [])
+            ].includes(message.id)) continue;
+            if (["dispatching", "handed_off"].includes(item.state)) item.state = "needs_review";
+            item.dispatchManifest = void 0;
+            item.manifestHash = void 0;
+            item.readPending = false;
+          }
+        }
+        this.value.items[message.id] = { message, revision: randomUUID3(), origin, state: nativeRecallInfo(message) ? "ignored" : "received", cursor };
       }
       this.value.cursor = cursor;
     });
+    return replaced;
+  }
+  /** Persist invalidation and the event cursor together, before consumer ACK. */
+  acceptRecall(cursor, recall) {
+    validateNativeRecall(recall);
+    if (!/^\d+$/.test(cursor) || BigInt(cursor) < BigInt(this.value.cursor)) throw Error("Native journal cursor cannot move backward");
+    let affected = [];
+    this.mutate(() => {
+      affected = this.rememberRecall(recall);
+      this.value.cursor = cursor;
+    });
+    return affected;
+  }
+  rememberRecall(recall) {
+    const hinted = recall.messageId ? this.get(recall.messageId)?.message : void 0;
+    if (hinted && (hinted.threadId !== recall.threadId || hinted.serverId !== recall.serverId)) {
+      const { messageId: _stale, ...exact } = recall;
+      recall = exact;
+    }
+    const key = nativeRecallIdentity(recall.threadId, recall.serverId);
+    this.value.recalls ??= {};
+    this.value.recalls[key] ??= {
+      threadId: recall.threadId,
+      serverId: recall.serverId,
+      observedAt: recall.observedAt,
+      ...recall.messageId ? { messageId: recall.messageId } : {},
+      ...recall.recalledAt ? { recalledAt: recall.recalledAt } : {}
+    };
+    const affected = /* @__PURE__ */ new Set();
+    for (const item of this.items()) {
+      if (item.message.threadId !== recall.threadId) continue;
+      const target = item.message.serverId === recall.serverId;
+      const quote = item.message.quote?.serverId === recall.serverId;
+      if (!target && !quote) continue;
+      affected.add(item.message.id);
+      item.message = target ? recalledNativeMessage(item.message, recall) : { ...item.message, quote: void 0 };
+      if (target) item.groupContext = false;
+      item.readPending = false;
+      if (["dispatching", "handed_off"].includes(item.state)) item.state = "needs_review";
+      else if (target && item.state === "received") item.state = "ignored";
+      item.invalidatedByRecall = true;
+      item.dispatchManifest = void 0;
+      item.manifestHash = void 0;
+    }
+    for (const item of this.items()) {
+      const manifest = item.dispatchManifest;
+      if (item.message.threadId !== recall.threadId || !manifest) continue;
+      const references = [
+        ...manifest.messageIds,
+        ...(manifest.historyInputs ?? []).map((input) => input.id),
+        ...manifest.assets.flatMap((asset) => asset.sourceMessageId ? [asset.sourceMessageId] : [])
+      ];
+      if (!references.some((id2) => affected.has(id2) || id2 === recall.messageId)) continue;
+      affected.add(item.message.id);
+      item.invalidatedByRecall = true;
+      item.readPending = false;
+      if (["dispatching", "handed_off"].includes(item.state)) item.state = "needs_review";
+      item.dispatchManifest = void 0;
+      item.manifestHash = void 0;
+    }
+    return [...affected];
   }
-  update(messageId, update) {
+  update(messageId, update, revision) {
     const item = this.value.items[messageId];
+    if (revision !== void 0 && item?.revision !== revision) return false;
     if (!item) throw new Error("Unknown native custody message");
     this.mutate(() => Object.assign(this.value.items[messageId], update));
+    return true;
   }
   groupHistory(threadId2, beforeId, limit) {
     const before = this.value.items[beforeId]?.cursor;
     if (!before || limit <= 0) return [];
     return this.items().filter((item) => item.groupContext && item.state === "ignored" && item.origin === "live" && item.message.threadId === threadId2 && item.cursor && BigInt(item.cursor) < BigInt(before)).sort((a, b) => BigInt(a.cursor) < BigInt(b.cursor) ? -1 : BigInt(a.cursor) > BigInt(b.cursor) ? 1 : 0).slice(-limit);
   }
-  bufferGroupMessage(messageId, limit) {
+  bufferGroupMessage(messageId, limit, revision) {
     const item = this.value.items[messageId];
+    if (revision !== void 0 && item?.revision !== revision) return false;
     if (!item || item.state !== "received" || item.origin !== "live" || item.message.direction !== "incoming" || !item.cursor || !item.message.threadId.endsWith("@chatroom") || !Number.isInteger(limit) || limit < 0 || limit > 200) throw new Error("Invalid native group history admission");
     this.mutate(() => {
       Object.assign(this.value.items[messageId], { state: "ignored", groupContext: limit > 0 });
       const history = this.items().filter((value) => value.groupContext).sort((a, b) => BigInt(a.cursor) < BigInt(b.cursor) ? -1 : 1);
-      const thread = history.filter((value) => value.message.threadId === item.message.threadId);
-      for (const value of thread.slice(0, Math.max(0, thread.length - limit))) value.groupContext = false;
+      const thread3 = history.filter((value) => value.message.threadId === item.message.threadId);
+      for (const value of thread3.slice(0, Math.max(0, thread3.length - limit))) value.groupContext = false;
       const retained = history.filter((value) => value.groupContext);
       for (const value of retained.slice(0, Math.max(0, retained.length - 1e3))) value.groupContext = false;
     });
+    return true;
   }
   beginDispatch(messageId, dispatchManifest, historyIds = []) {
-    if (this.value.items[messageId]?.state !== "received" || historyIds.some((id2) => !this.value.items[id2]?.groupContext || this.value.items[id2].message.threadId !== this.value.items[messageId].message.threadId)) throw new Error("Invalid native context dispatch custody");
+    if (this.value.items[messageId]?.state !== "received" || this.isRecalled(this.value.items[messageId].message) || historyIds.some((id2) => !this.value.items[id2]?.groupContext || this.value.items[id2].message.threadId !== this.value.items[messageId].message.threadId)) throw new Error("Invalid native context dispatch custody");
     this.mutate(() => {
-      Object.assign(this.value.items[messageId], { state: "dispatching", dispatchManifest });
+      Object.assign(this.value.items[messageId], { state: "dispatching", dispatchManifest, invalidatedByRecall: false });
       for (const id2 of historyIds) this.value.items[id2].groupContext = false;
     });
   }
@@ -1581,6 +1905,7 @@ var NativeConsumerState = class {
       if (!item || item.state !== "dispatching") throw new Error("Prepared input manifest is not in dispatch custody");
       return item;
     });
+    const revisions = items.map((item) => item.revision);
     if (new Set(items.map((item) => item.message.threadId)).size !== 1) throw new Error("Prepared input manifest crosses threads");
     const manifestHash = createHash6("sha256").update(JSON.stringify({
       accountId: this.value.accountId,
@@ -1591,8 +1916,15 @@ var NativeConsumerState = class {
       const runId = typeof args[0] === "string" ? args[0] : args[0]?.runId;
       if (typeof runId !== "string" || !runId || runId.length > 256) throw new Error("Prepared run callback has no valid runId");
       this.mutate(() => {
-        for (const id2 of exact) {
+        const currentHash = createHash6("sha256").update(JSON.stringify({
+          accountId: this.value.accountId,
+          messageIds: exact,
+          dispatchManifests: exact.map((id2) => this.value.items[id2]?.dispatchManifest ?? null)
+        })).digest("hex");
+        for (const [index, id2] of exact.entries()) {
           const item = this.value.items[id2];
+          if (!item || item.invalidatedByRecall || this.isRecalled(item.message)) throw Error("Native prepared input was invalidated by a recall");
+          if (item.revision !== revisions[index] || currentHash !== manifestHash) throw Error("Native prepared input source identity changed");
           if (item.runId && item.runId !== runId) throw new Error("Native prepared manifest was assigned to another run; operator review required");
           Object.assign(item, { state: "handed_off", runId, manifestHash, readPending: readPolicy === "on_model_dispatch", handoffUnconfirmed: false });
         }
@@ -1611,6 +1943,9 @@ var digest = (value) => createHash7("sha256").update(value).digest("hex");
 function prune() {
   for (const [id2, item] of pending) if (item.expires < Date.now()) pending.delete(id2);
 }
+function nativeSourceMessageSid(message) {
+  return `wechat-native:${message.accountId}:${message.id}:${digest(JSON.stringify([message.threadId, message.serverId ?? null]))}`;
+}
 function nativeDispatchManifest(params) {
   const history = params.history ?? [];
   if (history.length > 200 || history.some((message) => message.accountId !== params.message.accountId || message.threadId !== params.message.threadId || message.id === params.message.id)) throw Error("Invalid native history manifest");
@@ -1618,7 +1953,7 @@ function nativeDispatchManifest(params) {
     if (typeof asset.id !== "string" || !asset.id || asset.id.length > 2048 || !/^[a-f0-9]{64}$/.test(asset.sha256) || !Number.isSafeInteger(asset.byteLength) || asset.byteLength < 1 || asset.byteLength > 128 * 1024 * 1024 || typeof asset.path !== "string" || !isAbsolute3(asset.path) || asset.path.length > 4096 || typeof asset.mime !== "string" || asset.mime.length > 128 || !/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/.test(asset.mime) || !["image", "audio", "video", "file"].includes(asset.kind) || !["model_image", "file_reference"].includes(asset.role) || asset.role === "model_image" && (asset.kind !== "image" || !asset.mime.startsWith("image/") || !asset.runtimeMedia) || !["trigger", "history"].includes(asset.contextRole) || asset.sourceMessageId != null && (typeof asset.sourceMessageId !== "string" || !asset.sourceMessageId || asset.sourceMessageId.length > 8192 || ![params.message, ...history].some((message) => message.id === asset.messageId && message.type === 49 && message.appMessageType === 57 && message.quote?.type === 3)) || asset.contextRole === "history" && !history.some((message) => message.id === asset.messageId)) throw Error("Invalid native supplied asset manifest");
     return Object.freeze({ ...asset });
   }));
-  const messageSid = `wechat-native:${params.message.accountId}:${params.message.id}`;
+  const messageSid = nativeSourceMessageSid(params.message);
   const manifest = {
     schemaVersion: 2,
     runId: randomUUID4(),
@@ -1643,14 +1978,15 @@ function nativeDispatchManifest(params) {
         params.message.mentions,
         params.message.serverId,
         params.message.appMessageType,
-        params.message.quote
+        params.message.quote,
+        params.message.link
       ])),
       role: "trigger"
     })]),
     ...history.length ? { historyInputs: Object.freeze(history.map((message) => Object.freeze({
       id: message.id,
       version: message.version ?? "",
-      contentSha256: digest(JSON.stringify([message.id, message.version, message.senderId, message.type, message.body, message.mentions, message.serverId, message.appMessageType, message.quote])),
+      contentSha256: digest(JSON.stringify([message.id, message.version, message.senderId, message.type, message.body, message.mentions, message.serverId, message.appMessageType, message.quote, message.link])),
       role: "history"
     }))) } : {},
     assets,
@@ -1666,30 +2002,40 @@ function trackNativePreparedInput(manifest, record) {
   if (!enabled || pending.size >= 1024) return;
   pending.set(manifest.runId, { manifest, record, expires: Date.now() + 15 * 60 * 1e3 });
 }
+function invalidateNativePreparedInputs(accountId, messageIds) {
+  const ids = new Set(messageIds);
+  for (const [runId, item] of pending) {
+    if (item.manifest.accountId === accountId && [
+      ...item.manifest.messageIds,
+      ...(item.manifest.historyInputs ?? []).map((input) => input.id),
+      ...item.manifest.assets.flatMap((asset) => asset.sourceMessageId ? [asset.sourceMessageId] : [])
+    ].some((id2) => ids.has(id2))) pending.delete(runId);
+  }
+}
 function promptMatches(prompt, manifest) {
   if (typeof prompt !== "string" || Buffer.byteLength(prompt) > 1024 * 1024) return false;
-  const text = prompt.replace(/^\[[^\]\r\n]{1,96}\] /, "");
-  const candidates = [text];
+  const text3 = prompt.replace(/^\[[^\]\r\n]{1,96}\] /, "");
+  const candidates = [text3];
   const sender = `Conversation info: \u27E6openclaw:ctx\u27E7
 \`\`\`json
 ${JSON.stringify({ sender: { id: manifest.senderId } })}
 \`\`\`
 
 `;
-  if (manifest.threadId.endsWith("@chatroom") && text.startsWith(sender)) candidates.push(text.slice(sender.length));
-  return candidates.some((text2) => normalizedPromptMatches(text2, manifest));
+  if (manifest.threadId.endsWith("@chatroom") && text3.startsWith(sender)) candidates.push(text3.slice(sender.length));
+  return candidates.some((text4) => normalizedPromptMatches(text4, manifest));
 }
-function normalizedPromptMatches(text, manifest) {
+function normalizedPromptMatches(text3, manifest) {
   const runtimeAssets = manifest.assets.filter((asset) => asset.runtimeMedia);
   if (runtimeAssets.length) {
     if (runtimeAssets.length !== 1) return false;
     const asset = runtimeAssets[0];
-    const header = /^\[media attached: ([^\r\n]+) \(([^)\r\n]+)\) \| (media:\/\/inbound\/[^\]\r\n]+)\]\n/.exec(text);
+    const header = /^\[media attached: ([^\r\n]+) \(([^)\r\n]+)\) \| (media:\/\/inbound\/[^\]\r\n]+)\]\n/.exec(text3);
     if (!header || !isAbsolute3(header[1]) || basename2(header[1]) !== `input-${basename2(asset.path)}` || header[2] !== asset.mime || header[3] !== `media://inbound/${basename2(asset.path)}`) return false;
-    text = text.slice(header[0].length);
-    if (asset.kind === "video") text = text.replace(/\n\n\[Video attachment not analyzed: video understanding is disabled\]$/, "");
+    text3 = text3.slice(header[0].length);
+    if (asset.kind === "video") text3 = text3.replace(/\n\n\[Video attachment not analyzed: video understanding is disabled\]$/, "");
   }
-  return digest(text) === manifest.inputBodySha256;
+  return digest(text3) === manifest.inputBodySha256;
 }
 function currentMessageFacts(messages) {
   if (!Array.isArray(messages) || messages.length > 1e3) return [];
@@ -1750,8 +2096,8 @@ function observeNativeAgentEnd(event, ctx) {
   const blocks = typeof user.content === "string" ? [{ type: "text", text: user.content }] : user.content;
   if (!Array.isArray(blocks) || blocks.length > 32) return;
   if (blocks.some((block) => !["text", "image"].includes(block?.type) || block.type === "text" && typeof block.text !== "string")) return;
-  const text = blocks.filter((block) => block?.type === "text").map((block) => block.text).join("\n");
-  if (!promptMatches(text, m)) return;
+  const text3 = blocks.filter((block) => block?.type === "text").map((block) => block.text).join("\n");
+  if (!promptMatches(text3, m)) return;
   const images = blocks.filter((block) => block?.type === "image");
   const expectedImages = m.assets.filter((asset) => asset.role === "model_image");
   if (images.length !== expectedImages.length) return;
@@ -1761,7 +2107,7 @@ function observeNativeAgentEnd(event, ctx) {
     const bytes = Buffer.from(image.data, "base64");
     if (bytes.length !== asset.byteLength || digest(bytes) !== asset.sha256) return;
   }
-  if (m.assets.some((asset) => asset.role === "file_reference" && !text.includes(asset.path))) return;
+  if (m.assets.some((asset) => asset.role === "file_reference" && !text3.includes(asset.path))) return;
   item.record(m.runId);
   pending.delete(m.runId);
 }
@@ -1876,22 +2222,22 @@ async function projectNativeRead(client, accountId, state) {
   for (const threadId2 of threads) {
     for (let attempt = 0; attempt < 2; attempt++) {
       let cursor;
-      let thread;
+      let thread3;
       const seen = /* @__PURE__ */ new Set();
       for (let pageIndex = 0; pageIndex < 100; pageIndex++) {
         const page = await client.threads(accountId, cursor);
-        thread = page.items.find((value) => !isNativeTombstone(value) && value.id === threadId2);
-        if (thread || !page.nextCursor) break;
+        thread3 = page.items.find((value) => !isNativeTombstone(value) && value.id === threadId2);
+        if (thread3 || !page.nextCursor) break;
         if (seen.has(page.nextCursor)) throw new Error("Native thread pagination did not advance");
         seen.add(page.nextCursor);
         cursor = page.nextCursor;
       }
-      if (!thread) break;
+      if (!thread3) break;
       try {
-        const receipt = await client.markRead(accountId, thread.id, thread.readStateVersion);
+        const receipt = await client.markRead(accountId, thread3.id, thread3.readStateVersion);
         const notification = receipt?.phoneNotification?.state;
         const phoneReadState = notification === "accepted" || notification === "rejected" || notification === "needs_review" ? notification : void 0;
-        for (const item of pending2.filter((item2) => item2.message.threadId === threadId2)) state.update(item.message.id, { readPending: false, phoneReadState });
+        for (const item of pending2.filter((item2) => item2.message.threadId === threadId2)) state.update(item.message.id, { readPending: false, phoneReadState }, item.revision);
         break;
       } catch (error) {
         if (error instanceof NativeApiError && error.status === 409 && attempt === 0) continue;
@@ -1900,13 +2246,72 @@ async function projectNativeRead(client, accountId, state) {
     }
   }
 }
+var NativeInputInvalidated = class extends Error {
+};
+async function acceptNativeEvent(client, accountId, state, event) {
+  if (state.accountId !== accountId) throw Error("Native event crosses its custody account boundary");
+  if (event.kind === "message.recalled") {
+    const affected = state.acceptRecall(event.cursor, event.data);
+    invalidateNativePreparedInputs(accountId, affected);
+    return void 0;
+  }
+  let message;
+  if (event.kind === "message.committed") {
+    if (typeof event.data.messageId !== "string") throw Error("Native committed message identity is missing; cursor retained");
+    message = await client.message(accountId, event.data.messageId);
+    if (message.id !== event.data.messageId || message.accountId !== accountId || message.threadId !== event.data.threadId) throw Error("Native committed message identity mismatch");
+  }
+  const replaced = state.accept(event.cursor, message, typeof event.data.origin === "string" ? event.data.origin : "unknown");
+  if (replaced && message) invalidateNativePreparedInputs(accountId, [message.id]);
+  return message;
+}
+async function recheckNativeInputs(client, state, messages) {
+  for (const message of messages) {
+    if (!state.isCurrent(message)) throw new NativeInputInvalidated();
+    const current = await client.message(message.accountId, message.id);
+    if (current.accountId !== message.accountId || current.threadId !== message.threadId || current.id !== message.id || current.serverId !== message.serverId) throw Error("Native input identity changed; delivery held for review");
+    const recall = nativeRecallInfo(current);
+    if (recall && current.serverId) {
+      const affected = state.acceptRecall(state.cursor, { ...recall, messageId: current.id, threadId: current.threadId, serverId: current.serverId });
+      invalidateNativePreparedInputs(message.accountId, [current.id, ...affected]);
+      throw new NativeInputInvalidated();
+    }
+    if (message.quote) {
+      const quote = await client.quotedMessage(message.accountId, message.id);
+      if (quote.accountId !== message.accountId || quote.threadId !== message.threadId || quote.messageId !== message.id) throw Error("Native quote identity changed");
+      if (quote.state === "recalled" || quote.message && nativeRecallInfo(quote.message)) {
+        const affected = state.acceptRecall(state.cursor, {
+          threadId: message.threadId,
+          serverId: message.quote.serverId,
+          observedAt: quote.message && nativeRecallInfo(quote.message)?.observedAt || (/* @__PURE__ */ new Date()).toISOString()
+        });
+        invalidateNativePreparedInputs(message.accountId, affected);
+        throw new NativeInputInvalidated();
+      }
+    }
+    if (!state.isCurrent(message)) throw new NativeInputInvalidated();
+  }
+}
 async function dispatchNativeMessage(params) {
+  const revision = params.state.get(params.message.id)?.revision;
+  try {
+    return await dispatchNativeMessageInput(params, revision);
+  } catch (error) {
+    const item = params.state.get(params.message.id);
+    if (params.state.isRecalled(params.message)) return "ignored";
+    if (error instanceof NativeInputInvalidated && item?.state === "received") return "pending";
+    if (item) params.state.update(params.message.id, { state: "needs_review" }, revision);
+    return "needs_review";
+  }
+}
+async function dispatchNativeMessageInput(params, revision) {
   const { client, state, account, message, cfg, core } = params;
   const readPolicy = account.native?.readPolicy ?? "on_inbound";
   const custody = state.get(message.id);
-  if (!custody || custody.state !== "received") return "needs_review";
+  if (state.isRecalled(message)) return "ignored";
+  if (!custody || custody.state !== "received" || !state.isCurrent(message, revision)) return "needs_review";
   if (custody.origin !== "live" || message.direction !== "incoming" || ![1, 3, 34, 43, 47, 49].includes(message.type) || message.type === 1 && !message.body || !message.senderId) {
-    state.update(message.id, { state: "ignored" });
+    state.update(message.id, { state: "ignored" }, revision);
     return "ignored";
   }
   const isGroup = message.threadId.endsWith("@chatroom");
@@ -1941,32 +2346,50 @@ async function dispatchNativeMessage(params) {
   const unauthorizedDirectCommand = !isGroup && ingress.ingress.reasonCode === "control_command_unauthorized";
   if (ingress.ingress.admission !== "dispatch" && !unauthorizedDirectCommand) {
     if (isGroup && policy.requireMention && !wasMentioned && !hasControlCommand && (await senderAdmission(message.senderId)).ingress.admission === "dispatch") {
-      state.bufferGroupMessage(message.id, nativeGroupHistoryLimit(cfg));
+      state.bufferGroupMessage(message.id, nativeGroupHistoryLimit(cfg), revision);
       return "ignored";
     }
-    state.update(message.id, { state: "ignored" });
+    state.update(message.id, { state: "ignored" }, revision);
     return "ignored";
   }
   let preparedMedia;
   const allowQuotedMessage = async (original) => original.direction === "outgoing" || !!original.senderId && (await senderAdmission(original.senderId)).ingress.admission === "dispatch";
-  try {
-    preparedMedia = await (params.prepareAttachment ?? prepareNativeAttachment)({ client, account, message, core, cfg, allowQuotedMessage });
-  } catch {
-    state.update(message.id, { state: "needs_review" });
-    return "needs_review";
-  }
+  const assertCurrent = () => {
+    params.signal?.throwIfAborted();
+    if (!state.isCurrent(message, revision)) throw new NativeInputInvalidated();
+  };
+  const recheck = async (inputs) => {
+    assertCurrent();
+    await recheckNativeInputs(client, state, inputs);
+    assertCurrent();
+  };
+  await recheck([message]);
+  preparedMedia = await (params.prepareAttachment ?? prepareNativeAttachment)({ client, account, message, core, cfg, allowQuotedMessage, assertCurrent });
   if (preparedMedia.pending) return "pending";
   preparedMedia = await transcribeNativeAttachment(preparedMedia, core, cfg);
+  await recheck([message]);
   const buffered = isGroup && !hasControlCommand ? state.groupHistory(message.threadId, message.id, nativeGroupHistoryLimit(cfg)) : [];
   const admitted = [];
   for (const item of buffered) {
     if (item.message.senderId && (await senderAdmission(item.message.senderId)).ingress.admission === "dispatch") admitted.push(item.message);
   }
   const history = await prepareNativeHistory(admitted, async (historical) => transcribeNativeAttachment(
-    await (params.prepareAttachment ?? prepareNativeAttachment)({ client, account, message: historical, core, cfg, allowQuotedMessage }),
+    await (params.prepareAttachment ?? prepareNativeAttachment)({
+      client,
+      account,
+      message: historical,
+      core,
+      cfg,
+      allowQuotedMessage,
+      assertCurrent: () => {
+        assertCurrent();
+        if (!state.isCurrent(historical)) throw new NativeInputInvalidated();
+      }
+    }),
     core,
     cfg
   ));
+  await recheck([message, ...admitted]);
   const context = buildNativeContext(history, message, preparedMedia);
   const inputBody = context.inputBody;
   const route = core.channel.routing.resolveAgentRoute({
@@ -1996,7 +2419,7 @@ async function dispatchNativeMessage(params) {
     SenderId: message.senderId,
     Provider: "agent-wechat",
     Surface: "agent-wechat",
-    MessageSid: `wechat-native:${account.native.accountId}:${message.id}`,
+    MessageSid: nativeSourceMessageSid(message),
     WasMentioned: isGroup ? wasMentioned : void 0,
     Attachments: context.attachments,
     InboundHistory: context.history,
@@ -2006,6 +2429,7 @@ async function dispatchNativeMessage(params) {
     ...context.mediaPath ? { MediaPath: context.mediaPath, MediaUrl: context.mediaPath, MediaType: context.mediaMime } : {}
   });
   await core.channel.session.recordInboundSession({ storePath, sessionKey: route.sessionKey, ctx });
+  await recheck([message, ...admitted]);
   const pipeline = (params.createPipeline ?? createChannelMessageReplyPipeline)({ cfg, agentId: route.agentId, channel: "agent-wechat", accountId: account.accountId });
   const { onModelSelected, ...prefixOptions } = pipeline;
   const dispatchManifest = nativeDispatchManifest({
@@ -2018,9 +2442,11 @@ async function dispatchNativeMessage(params) {
     assets: context.assets,
     history: admitted
   });
+  assertCurrent();
   state.beginDispatch(message.id, dispatchManifest, buffered.map((item) => item.message.id));
-  const callback = readPolicy !== "on_inbound" && (message.type === 1 || message.type === 49 && message.appMessageType === 19 && !!message.body || preparedMedia.quote?.type === 1 && ["resolved", "embedded"].includes(preparedMedia.quote.state) || preparedMedia.attachment?.status === "ready" && preparedMedia.suppliedAssets?.length) ? state.preparedCallback([message.id], readPolicy) : void 0;
+  const callback = readPolicy !== "on_inbound" && (message.type === 1 || message.type === 49 && message.appMessageType === 19 && !!message.body || message.type === 49 && [3, 4, 5].includes(message.appMessageType ?? 0) && !!message.link || preparedMedia.quote?.type === 1 && ["resolved", "embedded"].includes(preparedMedia.quote.state) || preparedMedia.attachment?.status === "ready" && preparedMedia.suppliedAssets?.length) ? state.preparedCallback([message.id], readPolicy) : void 0;
   if (callback) trackNativePreparedInput(dispatchManifest, callback);
+  const beforeSend = () => recheck([message, ...admitted]);
   let failed = false;
   let delivery = 0;
   try {
@@ -2030,15 +2456,19 @@ async function dispatchNativeMessage(params) {
       dispatcherOptions: {
         ...prefixOptions,
         deliver: async (payload) => {
+          params.signal?.throwIfAborted();
+          if (state.get(message.id)?.invalidatedByRecall) return;
+          await beforeSend();
           const urls = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
           if (urls.length > 16) throw new Error("Native reply media count exceeds its bound");
           if (payload.audioAsVoice && !urls.length) throw new Error("Native voice reply requires an audio attachment");
-          for (const url of urls) {
-            const key = createHash8("sha256").update(`${account.native.accountId}\0${message.id}\0${delivery++}`).digest("hex");
-            await sendNativeAttachment(client, account, message.threadId, url, payload.audioAsVoice === true, key);
+          for (const url2 of urls) {
+            const key = createHash8("sha256").update(`${dispatchManifest.messageSid}\0${delivery++}`).digest("hex");
+            await sendNativeAttachment(client, account, message.threadId, url2, payload.audioAsVoice === true, key, beforeSend);
           }
           if (payload.text) {
-            const key = createHash8("sha256").update(`${account.native.accountId}\0${message.id}\0${delivery++}`).digest("hex");
+            await beforeSend();
+            const key = createHash8("sha256").update(`${dispatchManifest.messageSid}\0${delivery++}`).digest("hex");
             await submitNativeText(client, account.native.accountId, message.threadId, payload.text, key);
           }
           if (urls.length || payload.text) params.onDelivered?.();
@@ -2053,18 +2483,34 @@ async function dispatchNativeMessage(params) {
       // and media-snapshot bridge; unsupported or ambiguous handoffs leave reads unchanged.
       replyOptions: { runId: dispatchManifest.runId, onModelSelected, onPreparedAgentRunStart: callback }
     });
+    params.signal?.throwIfAborted();
+    if (state.get(message.id)?.revision !== revision || state.get(message.id)?.dispatchManifest?.runId !== dispatchManifest.runId) return state.isRecalled(message) ? "ignored" : "needs_review";
+    if (state.get(message.id)?.invalidatedByRecall) return state.isRecalled(message) ? "ignored" : "needs_review";
     const readPending = readPolicy === "on_inbound" && !failed && ingress.ingress.admission === "dispatch" ? true : state.get(message.id)?.readPending;
     state.update(message.id, {
       state: failed ? "needs_review" : "completed",
       readPending,
       handoffUnconfirmed: readPolicy === "on_model_dispatch" && !state.get(message.id)?.runId
-    });
+    }, revision);
     return failed ? "needs_review" : "completed";
   } catch {
-    state.update(message.id, { state: "needs_review" });
+    if (state.isRecalled(message)) return "ignored";
+    state.update(message.id, { state: "needs_review" }, revision);
     return "needs_review";
   }
 }
+async function synchronizeNativeEvents(client, accountId, state) {
+  for (let index = 0; index < 100; index++) {
+    const page = await client.events(accountId, state.cursor, 200);
+    if (!page.items.length) return;
+    const before = state.cursor;
+    for (const event of page.items) await acceptNativeEvent(client, accountId, state, event);
+    if (state.cursor === before) throw Error("Native recovery event cursor did not advance");
+    await client.ack(accountId, "openclaw", state.cursor);
+    if (page.items.length < 200) return;
+  }
+  throw Error("Native recovery backlog remains; no model input was dispatched");
+}
 function startNativeReadPump(task, failed, intervalMs = 5e3) {
   let active2 = false, stopped = false;
   const timer = setInterval(() => {
@@ -2110,6 +2556,7 @@ async function startNativeMonitor(opts) {
         message: item.message,
         cfg,
         core,
+        signal: opts.abortSignal,
         onDelivered: () => opts.setStatus({ accountId: account.accountId, lastOutboundAt: Date.now() })
       });
     }
@@ -2130,9 +2577,24 @@ async function startNativeMonitor(opts) {
       handoffUnconfirmed
     });
   };
-  await process2();
+  let processing;
+  let processAgain = false;
+  let intakeReady = false;
+  const scheduleProcess = () => {
+    processAgain = true;
+    if (processing || opts.abortSignal.aborted || !intakeReady) return;
+    processing = (async () => {
+      do {
+        processAgain = false;
+        await process2();
+      } while (processAgain && !opts.abortSignal.aborted);
+    })().catch(() => opts.log?.error?.("Native input processing was interrupted; durable custody was retained")).finally(() => {
+      processing = void 0;
+    });
+  };
   const stopReadPump = startNativeReadPump(async () => {
     await flushRead();
+    scheduleProcess();
     if (!opts.abortSignal.aborted) opts.setStatus({
       accountId: opts.account.accountId,
       handoffUnconfirmed: native.readPolicy === "on_model_dispatch" && state.items().some((value) => value.handoffUnconfirmed)
@@ -2142,18 +2604,15 @@ async function startNativeMonitor(opts) {
     while (!opts.abortSignal.aborted) {
       try {
         if (state.cursor !== "0") await host2.client.ack(native.accountId, "openclaw", state.cursor);
-        await process2();
+        intakeReady = false;
+        await synchronizeNativeEvents(host2.client, native.accountId, state);
+        intakeReady = true;
+        scheduleProcess();
         for await (const event of host2.client.watch(native.accountId, state.cursor, opts.abortSignal)) {
-          let message;
-          if (event.kind === "message.committed") {
-            if (typeof event.data.messageId !== "string") throw new Error("Native committed message identity is missing; cursor retained");
-            message = await host2.client.message(native.accountId, event.data.messageId);
-            if (message.threadId !== event.data.threadId) throw new Error("Native committed message thread identity mismatch");
-          }
-          state.accept(event.cursor, message, typeof event.data.origin === "string" ? event.data.origin : "unknown");
-          if (message?.direction === "incoming" && event.data.origin === "live") opts.setStatus({ accountId: opts.account.accountId, lastInboundAt: Date.now() });
+          const message = await acceptNativeEvent(host2.client, native.accountId, state, event);
+          if (message?.direction === "incoming" && event.data.origin === "live" && !nativeRecallInfo(message)) opts.setStatus({ accountId: opts.account.accountId, lastInboundAt: Date.now() });
           await host2.client.ack(native.accountId, "openclaw", state.cursor);
-          await process2();
+          scheduleProcess();
           backoff = 250;
         }
         if (!opts.abortSignal.aborted) throw new Error("Native event stream closed");
@@ -2223,11 +2682,17 @@ async function nativeLoginWait(accountId, timeoutMs = 3e4, stopAtQr = false) {
   }
   return { connected: false, message: "Native login remains pending; wait on the same operation rather than starting a replacement" };
 }
-async function sendNativeText(account, threadId2, text, key = randomUUID5()) {
+async function sendNativeText(account, threadId2, text3, key = randomUUID5()) {
   const native = account.native;
   const { client } = await ensureNativeHost(native);
-  const send = await submitNativeText(client, native.accountId, threadId2, text, key);
-  return `agent-wechat-native:${native.accountId}:${send.id}`;
+  const send = await submitNativeText(client, native.accountId, threadId2, text3, key);
+  return nativeOutboundDelivery(
+    client,
+    native.accountId,
+    threadId2,
+    send.localMessageId ? [send.localMessageId] : [],
+    { sendId: send.id, state: send.state, serverIds: send.serverId ? [send.serverId] : void 0 }
+  );
 }
 function createNativeLoginTool(account) {
   return {
@@ -2254,10 +2719,10 @@ function createNativeLoginTool(account) {
 }
 
 // src/channel.ts
-async function sendWeChatText(cfg, to, text) {
+async function sendWeChatText(cfg, to, text3) {
   const account = resolveWeChatAccount(cfg);
   if (!account?.serverUrl) throw new Error("No native daemon configured");
-  return sendNativeText(account, to, text);
+  return sendNativeText(account, to, text3);
 }
 var wechatMessageAdapter = createChannelMessageAdapterFromOutbound({
   id: "agent-wechat",
@@ -2267,13 +2732,13 @@ var wechatMessageAdapter = createChannelMessageAdapterFromOutbound({
     messageSendingHooks: true
   },
   outbound: {
-    sendText: async ({ cfg, to, text }) => ({
+    sendText: async ({ cfg, to, text: text3 }) => ({
       channel: "agent-wechat",
-      messageId: await sendWeChatText(cfg, to, text)
+      ...await sendWeChatText(cfg, to, text3)
     }),
-    sendMedia: async ({ cfg, to, text, mediaUrl, audioAsVoice }) => ({
+    sendMedia: async ({ cfg, to, text: text3, mediaUrl, audioAsVoice }) => ({
       channel: "agent-wechat",
-      messageId: await sendWeChatMedia(cfg, to, text, mediaUrl, audioAsVoice)
+      ...await sendWeChatMedia(cfg, to, text3, mediaUrl, audioAsVoice)
     })
   }
 });
@@ -2396,7 +2861,7 @@ var wechatPlugin = {
   },
   // ---- Mention adapter ----
   mentions: {
-    stripMentions: ({ text, ctx }) => normalizeWeChatCommandBody(text, {
+    stripMentions: ({ text: text3, ctx }) => normalizeWeChatCommandBody(text3, {
       isGroup: ctx.ChatType === "group",
       wasMentioned: ctx.WasMentioned === true
     })
@@ -2415,13 +2880,13 @@ var wechatPlugin = {
   // ---- Outbound adapter for OpenClaw hosts using the outbound hook ----
   outbound: {
     deliveryMode: "direct",
-    sendText: async ({ cfg, to, text }) => ({
+    sendText: async ({ cfg, to, text: text3 }) => ({
       channel: "agent-wechat",
-      messageId: await sendWeChatText(cfg, to, text)
+      ...await sendWeChatText(cfg, to, text3)
     }),
-    sendMedia: async ({ cfg, to, text, mediaUrl, audioAsVoice }) => ({
+    sendMedia: async ({ cfg, to, text: text3, mediaUrl, audioAsVoice }) => ({
       channel: "agent-wechat",
-      messageId: await sendWeChatMedia(cfg, to, text, mediaUrl, audioAsVoice)
+      ...await sendWeChatMedia(cfg, to, text3, mediaUrl, audioAsVoice)
     })
   },
   message: wechatMessageAdapter,
@@ -2602,9 +3067,9 @@ function createNativeFacade(config, dependencies = {}) {
     try {
       const host2 = dependencies.endpoint ? void 0 : await ensureNativeHost(config);
       const headers = new Headers();
-      for (const name of ["content-type", "accept", "range", "if-none-match", "if-range", "last-event-id", "idempotency-key"]) {
-        const value = req.headers[name];
-        if (typeof value === "string") headers.set(name, value);
+      for (const name2 of ["content-type", "accept", "range", "if-none-match", "if-range", "last-event-id", "idempotency-key"]) {
+        const value = req.headers[name2];
+        if (typeof value === "string") headers.set(name2, value);
       }
       const length = req.headers["content-length"];
       if (length && (!/^\d+$/.test(length) || Number(length) > MAX_BODY)) {
@@ -2628,9 +3093,9 @@ function createNativeFacade(config, dependencies = {}) {
         response = await (dependencies.fetch ?? fetch)(new URL(relative, dependencies.endpoint), init);
       }
       res.statusCode = response.status;
-      for (const name of ["content-type", "content-length", "content-range", "accept-ranges", "etag", "cache-control", "content-disposition", "x-content-type-options"]) {
-        const value = response.headers.get(name);
-        if (value) res.setHeader(name, value);
+      for (const name2 of ["content-type", "content-length", "content-range", "accept-ranges", "etag", "cache-control", "content-disposition", "x-content-type-options"]) {
+        const value = response.headers.get(name2);
+        if (value) res.setHeader(name2, value);
       }
       res.setHeader("x-content-type-options", "nosniff");
       const reader = response.body?.getReader();
@@ -2689,18 +3154,29 @@ function object(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw Error("Expected tool arguments");
   return value;
 }
-function string(value, name, max = 4096) {
-  if (typeof value !== "string" || !value.trim() || value.length > max || /[\u0000-\u001f\u007f]/.test(value)) throw Error(`Invalid ${name}`);
+function string(value, name2, max = 4096) {
+  if (typeof value !== "string" || !value.trim() || value.length > max || /[\u0000-\u001f\u007f]/.test(value)) throw Error(`Invalid ${name2}`);
   return value.trim();
 }
 function threadId(value) {
   return string(string(value, "thread ID").replace(/^(?:agent-)?wechat:(?:group:)?/i, ""), "thread ID");
 }
 function messageResult(message, retrievalTool = "wechat_media") {
+  if (nativeRecallInfo(message)) return {
+    id: message.id,
+    threadId: message.threadId,
+    serverId: message.serverId,
+    direction: message.direction,
+    type: 1e4,
+    body: "[Message recalled]",
+    status: "recalled",
+    recall: nativeRecallInfo(message)
+  };
   const isQuote = message.type === 49 && message.appMessageType === 57;
   const isForward = message.type === 49 && message.appMessageType === 19;
-  const kind2 = isQuote ? "quote" : isForward ? "forwarded_history" : message.type === 3 ? "image" : message.type === 47 ? "sticker" : message.type === 34 ? "voice" : message.type === 43 ? "video" : message.type === 49 && (message.appMessageType == null || message.appMessageType === 6) ? "file" : "unsupported";
-  const body = message.type === 1 || isForward ? message.body ?? "" : isQuote ? `${message.body ?? ""}
+  const isLink = message.type === 49 && [3, 4, 5].includes(message.appMessageType ?? 0) && !!message.link;
+  const kind2 = isQuote ? "quote" : isForward ? "forwarded_history" : isLink ? "link_preview" : message.type === 3 ? "image" : message.type === 47 ? "sticker" : message.type === 34 ? "voice" : message.type === 43 ? "video" : message.type === 49 && (message.appMessageType == null || message.appMessageType === 6) ? "file" : "unsupported";
+  const body = message.type === 1 || isForward || isLink ? message.body ?? "" : isQuote ? `${message.body ?? ""}
 [Quoted original not retrieved; use ${retrievalTool} with this message ID]` : `[WeChat ${kind2} message; attachment content has not been retrieved by this tool]`;
   return {
     id: message.id,
@@ -2711,6 +3187,7 @@ function messageResult(message, retrievalTool = "wechat_media") {
     type: message.type,
     appMessageType: message.appMessageType,
     quote: message.quote,
+    link: isLink ? message.link : void 0,
     createdAt: message.createdAt,
     body: body.slice(0, 4e3),
     bodyTruncated: body.length > 4e3,
@@ -2728,6 +3205,7 @@ function createLookupTools(context, dependencies, archive) {
   if (!currentConfig()) return [];
   const selected = resolveWeChatAccount(currentConfig());
   if (!selected?.native || !selected.enabled) return [];
+  const configurationKey = nativeConfigurationKey(selected.native);
   if (!archive && context.messageChannel !== "agent-wechat") return [];
   if (!archive && context.agentAccountId && context.agentAccountId !== selected.accountId) return [];
   if (!archive && context.deliveryContext?.channel === "agent-wechat" && context.deliveryContext.accountId && context.deliveryContext.accountId !== selected.accountId) return [];
@@ -2749,9 +3227,9 @@ function createLookupTools(context, dependencies, archive) {
     if (!currentThread) return [];
   }
   const selectedId = selected.native.accountId;
-  const tool = (name, action, description, properties, required = []) => ({
-    name,
-    label: name.replaceAll("_", " "),
+  const tool = (name2, action, description, properties, required = []) => ({
+    name: name2,
+    label: name2.replaceAll("_", " "),
     description,
     // The pinned host's tool_call wrapper JSON-serializes image blocks. Its
     // public direct-only surface preserves actual image content for vision.
@@ -2764,7 +3242,7 @@ function createLookupTools(context, dependencies, archive) {
         context.assertInvocationCurrent?.();
         const cfg2 = currentConfig();
         const account2 = resolveWeChatAccount(cfg2);
-        if (!account2?.enabled || !account2.native || account2.native.accountId !== selectedId || account2.accountId !== selected.accountId) throw Error("WeChat account configuration changed; start a new turn");
+        if (!account2?.enabled || !account2.native || account2.native.accountId !== selectedId || account2.accountId !== selected.accountId || nativeConfigurationKey(account2.native) !== configurationKey) throw Error("WeChat account configuration changed; start a new turn");
         return { cfg: cfg2, account: account2, native: account2.native };
       };
       const { cfg, account, native } = guard();
@@ -2806,10 +3284,10 @@ function createLookupTools(context, dependencies, archive) {
       if (action === "threads") {
         const page = await client.threads(accountId, { limit, cursor, ...query ? { query } : {} });
         const items = [];
-        for (const thread of page.items) {
-          if (isNativeTombstone(thread)) continue;
-          if (thread.accountId !== accountId) throw Error("Thread response crosses an account boundary");
-          items.push({ id: thread.id, peerId: thread.peerId, kind: thread.kind, displayName: thread.displayName, unreadCount: thread.unreadCount });
+        for (const thread3 of page.items) {
+          if (isNativeTombstone(thread3)) continue;
+          if (thread3.accountId !== accountId) throw Error("Thread response crosses an account boundary");
+          items.push({ id: thread3.id, peerId: thread3.peerId, kind: thread3.kind, displayName: thread3.displayName, unreadCount: thread3.unreadCount });
         }
         result = { ...page, items, scope: "local_profile", note: "Locally stored threads; coverage may be partial. This lookup does not mark threads read." };
       } else if (action === "message" || action === "media") {
@@ -2819,6 +3297,18 @@ function createLookupTools(context, dependencies, archive) {
         if (message.id !== messageId || message.accountId !== accountId || !archive && message.threadId !== conversation || message.direction !== "outgoing" && !await allowed(message.senderId ?? void 0)) throw Error("Message is outside the permitted conversation or sender policy");
         result = messageResult(message, archive ? "wechat_archive_media" : "wechat_media");
         if (action === "media") {
+          const checkRecall = async () => {
+            guard();
+            const latest = await client.message(accountId, messageId);
+            guard();
+            if (latest.id !== message.id || latest.accountId !== accountId || latest.threadId !== message.threadId || latest.serverId !== message.serverId) throw Error("Native media message identity changed");
+            if (nativeRecallInfo(latest)) throw new NativeApiError(410, "message_recalled", false);
+            if (message.quote) {
+              const quote = await client.quotedMessage(accountId, message.id);
+              guard();
+              if (quote.state === "recalled" || quote.message && nativeRecallInfo(quote.message)) throw new NativeApiError(410, "message_recalled", false);
+            }
+          };
           let prepared;
           try {
             prepared = await prepareNativeAttachment({
@@ -2835,6 +3325,7 @@ function createLookupTools(context, dependencies, archive) {
               allowQuotedMessage: async (original) => original.direction === "outgoing" || await allowed(original.senderId ?? void 0),
               beforeMediaAccess: async () => {
                 if (!await allowed(requesterSenderId) || message.direction !== "outgoing" && !await allowed(message.senderId ?? void 0)) throw Error("WeChat conversation access is no longer allowed");
+                await checkRecall();
               }
             });
           } catch (error) {
@@ -2843,7 +3334,7 @@ function createLookupTools(context, dependencies, archive) {
             const details2 = {
               messageId: message.id,
               threadId: message.threadId,
-              status: error.retryable ? "pending" : ["unsupported_profile", "unsupported_media", "unsupported_media_variant"].includes(error.code) ? "unsupported" : "unavailable",
+              status: error.code === "message_recalled" ? "recalled" : error.retryable ? "pending" : ["unsupported_profile", "unsupported_media", "unsupported_media_variant"].includes(error.code) ? "unsupported" : "unavailable",
               retryable: error.retryable,
               reason: error.code
             };
@@ -2854,9 +3345,10 @@ function createLookupTools(context, dependencies, archive) {
           const details = {
             messageId: message.id,
             threadId: message.threadId,
-            status: prepared.pending ? "pending" : prepared.attachment?.status ?? prepared.quote?.state ?? "unsupported",
+            status: prepared.reason === "message_recalled" ? "recalled" : prepared.pending ? "pending" : prepared.attachment?.status ?? prepared.quote?.state ?? "unsupported",
             attachment: prepared.attachment,
             quote: prepared.quote,
+            link: ["message_recalled", "media_identity_unavailable", "media_source_changed"].includes(prepared.reason ?? "") ? void 0 : message.link,
             variant: prepared.variant,
             jobId: prepared.jobId,
             retryable: prepared.retryable ?? false,
@@ -2866,6 +3358,13 @@ function createLookupTools(context, dependencies, archive) {
           const image = prepared.suppliedAssets?.find((asset) => asset.role === "model_image");
           const output = image ? await imageResultFromFile({ label: "WeChat attachment", path: image.path, extraText: JSON.stringify(details), details }) : { content: [{ type: "text", text: JSON.stringify(details) }], details };
           guard();
+          try {
+            await checkRecall();
+          } catch (error) {
+            if (!(error instanceof NativeApiError) || error.code !== "message_recalled") throw error;
+            const details2 = { messageId: message.id, threadId: message.threadId, status: "recalled", reason: "message_recalled", retryable: false };
+            return { content: [{ type: "text", text: JSON.stringify(details2) }], details: details2 };
+          }
           return output;
         }
       } else {
@@ -2914,6 +3413,257 @@ function registerNativeHistoryTools(api) {
   api.registerTool({ contextVersion: 2, create: (context) => createNativeArchiveTools(context) }, { names: archiveNames, optional: true });
 }
 
+// src/native-share-tool.ts
+import { resolveStableChannelMessageIngress as resolveStableChannelMessageIngress3 } from "openclaw/plugin-sdk/channel-ingress-runtime";
+var name = "wechat_send_share";
+function text(value, label, max, multiline = false) {
+  if (typeof value !== "string" || !value.trim() || Buffer.byteLength(value) > max || (multiline ? /[\u0000-\u0008\u000b-\u001f\u007f]/ : /[\u0000-\u001f\u007f]/).test(value)) throw Error(`Invalid ${label}`);
+  return value;
+}
+function thread(value) {
+  return text(text(value, "current conversation", 256).replace(/^(?:agent-)?wechat:(?:group:)?/i, "").trim(), "current conversation", 256);
+}
+function url(value, label) {
+  const raw = text(value, label, 8192);
+  const parsed = new URL(raw);
+  if (!["https:", "http:"].includes(parsed.protocol) || !parsed.hostname || parsed.username || parsed.password) throw Error(`Invalid ${label}`);
+  return raw;
+}
+function createNativeShareTools(context, dependencies = {}) {
+  const currentConfig = () => context.getRuntimeConfig?.() ?? context.runtimeConfig ?? context.config;
+  if (!currentConfig()) return [];
+  const selected = resolveWeChatAccount(currentConfig());
+  if (!selected?.enabled || !selected.native || context.messageChannel !== "agent-wechat" || context.agentAccountId && context.agentAccountId !== selected.accountId || context.deliveryContext?.channel === "agent-wechat" && context.deliveryContext.accountId && context.deliveryContext.accountId !== selected.accountId) return [];
+  let conversation, requester;
+  try {
+    const native = context.nativeChannelId ? thread(context.nativeChannelId) : void 0;
+    const delivery = context.deliveryContext?.channel === "agent-wechat" && context.deliveryContext.to ? thread(context.deliveryContext.to) : void 0;
+    if (native && delivery && native !== delivery) return [];
+    conversation = native ?? delivery;
+    if (!conversation) return [];
+    requester = text(context.requesterSenderId, "requester sender", 256);
+  } catch {
+    return [];
+  }
+  const configurationKey = nativeConfigurationKey(selected.native);
+  const fields = ["title", "url", "description", "thumbnailUrl", "idempotencyKey"];
+  return [{
+    name,
+    label: "Send WeChat share",
+    description: "Send a URL share card to the current WeChat conversation, with an explicit title, URL, optional description and public thumbnail URL. Does not fetch or summarize the linked page. Use one idempotencyKey per intended share and reuse it after timeouts; never retry an uncertain send with a new key. Returns a durable send ID and state. Accepted means server acceptance; recipient rendering requires verification.",
+    parameters: { type: "object", additionalProperties: false, required: ["title", "url", "idempotencyKey"], properties: {
+      title: { type: "string", minLength: 1, maxLength: 16384 },
+      url: { type: "string", minLength: 1, maxLength: 8192 },
+      description: { type: "string", maxLength: 16384 },
+      thumbnailUrl: { type: "string", minLength: 1, maxLength: 8192, description: "Public HTTP(S) image URL advertised as the card thumbnail; no upload or page scraping." },
+      idempotencyKey: { type: "string", minLength: 1, maxLength: 200, description: "Stable unique key for this logical share. Reuse the same key and identical fields when inspecting/retrying this request." }
+    } },
+    execute: async (_callId, input, signal) => {
+      if (!input || typeof input !== "object" || Array.isArray(input)) throw Error("Expected share arguments");
+      const args = input;
+      if (Object.keys(args).some((key2) => !fields.includes(key2))) throw Error("Share sending is restricted to the current conversation");
+      const key = text(args.idempotencyKey, "idempotency key", 200);
+      const request = {
+        kind: "share",
+        threadId: conversation,
+        title: text(args.title, "title", 16384, true),
+        url: url(args.url, "URL"),
+        ...args.description !== void 0 ? { description: args.description === "" ? "" : text(args.description, "description", 16384, true) } : {},
+        ...args.thumbnailUrl !== void 0 ? { thumbnailUrl: url(args.thumbnailUrl, "thumbnail URL") } : {}
+      };
+      const guard = () => {
+        signal?.throwIfAborted();
+        context.assertInvocationCurrent?.();
+        const cfg = currentConfig(), account = resolveWeChatAccount(cfg);
+        if (!account?.enabled || !account.native || account.accountId !== selected.accountId || account.native.accountId !== selected.native.accountId || nativeConfigurationKey(account.native) !== configurationKey) throw Error("WeChat account configuration changed; start a new turn");
+        return { cfg, account, native: account.native };
+      };
+      const core = dependencies.core ?? getWeChatRuntime();
+      const authorize = async () => {
+        const { cfg, account } = guard();
+        const result = await resolveWeChatIngress({
+          resolve: core.channel.inbound?.ingress?.resolveStable ?? resolveStableChannelMessageIngress3,
+          cfg,
+          accountId: account.accountId,
+          policy: resolveWeChatPolicyContext({ account, cfg, chatId: conversation }),
+          isGroup: conversation.endsWith("@chatroom"),
+          chatId: conversation,
+          senderId: requester,
+          readStoreAllowFrom: async () => core.channel.pairing.readAllowFromStore({ channel: "agent-wechat", accountId: account.accountId, env: process.env }).catch(() => [])
+        });
+        guard();
+        if (result.ingress.admission !== "dispatch") throw Error("WeChat conversation access is no longer allowed");
+      };
+      await authorize();
+      const { native } = guard();
+      const { client } = await (dependencies.host ?? ensureNativeHost)(native);
+      await authorize();
+      let intent;
+      try {
+        intent = await client.sendShare(native.accountId, request, key, signal);
+      } catch (error) {
+        if (!(error instanceof NativeApiError) || error.status >= 500 || error.code === "timeout") {
+          const details2 = { threadId: conversation, idempotencyKey: key, state: "submission_unknown", note: "Inspect the send by this idempotency key. Do not resend with a new key." };
+          return { content: [{ type: "text", text: JSON.stringify(details2) }], details: details2, isError: true };
+        }
+        throw error;
+      }
+      if (intent.accountId !== native.accountId || intent.destination !== conversation || !intent.id) throw Error("Share receipt crosses an account or conversation boundary; inspect the original idempotency key before another send");
+      const delivery = intent.state === "accepted" && intent.localMessageId && intent.serverId ? await nativeOutboundDelivery(client, native.accountId, conversation, [intent.localMessageId], { sendId: intent.id, state: intent.state, serverIds: [intent.serverId] }) : void 0;
+      const details = {
+        id: intent.id,
+        threadId: conversation,
+        idempotencyKey: key,
+        state: intent.state,
+        serverId: intent.serverId,
+        messageId: delivery?.messageId || void 0,
+        receiptState: delivery?.meta.receiptState,
+        reason: intent.errorCode,
+        note: ["accepted", "sent", "server_accepted"].includes(intent.state) ? "Server accepted; recipient rendering is not confirmed." : "Inspect this send ID or reuse the identical request/key. Do not send again with a new key."
+      };
+      return { content: [{ type: "text", text: JSON.stringify(details) }], details, isError: ["failed", "needs_review", "cancelled"].includes(intent.state) };
+    }
+  }];
+}
+function registerNativeShareTools(api) {
+  api.registerTool({ contextVersion: 2, create: (context) => createNativeShareTools(context) }, { names: [name] });
+}
+
+// src/native-recall-tools.ts
+import { createHash as createHash9 } from "node:crypto";
+import { resolveStableChannelMessageIngress as resolveStableChannelMessageIngress4 } from "openclaw/plugin-sdk/channel-ingress-runtime";
+var names2 = ["wechat_recall"];
+function text2(value, label) {
+  if (typeof value !== "string" || !value.trim() || value.length > 4096 || /[\u0000-\u001f\u007f]/.test(value)) throw Error(`Invalid ${label}`);
+  return value.trim();
+}
+function thread2(value) {
+  return text2(text2(value, "conversation").replace(/^(?:agent-)?wechat:(?:group:)?/i, ""), "conversation");
+}
+function nativeRecallKey(accountId, threadId2, messageId, serverId) {
+  return `openclaw-recall-${createHash9("sha256").update(JSON.stringify([accountId, threadId2, messageId, serverId])).digest("hex")}`;
+}
+function createNativeRecallTools(context, dependencies = {}) {
+  const currentConfig = () => context.getRuntimeConfig?.() ?? context.runtimeConfig ?? context.config;
+  if (!currentConfig()) return [];
+  const selected = resolveWeChatAccount(currentConfig());
+  if (!selected?.enabled || !selected.native || context.messageChannel !== "agent-wechat" || context.agentAccountId && context.agentAccountId !== selected.accountId || context.deliveryContext?.channel === "agent-wechat" && context.deliveryContext.accountId && context.deliveryContext.accountId !== selected.accountId) return [];
+  let conversation, requester;
+  try {
+    const nativeThread = context.nativeChannelId ? thread2(context.nativeChannelId) : void 0;
+    const delivered = context.deliveryContext?.channel === "agent-wechat" && context.deliveryContext.to ? thread2(context.deliveryContext.to) : void 0;
+    if (nativeThread && delivered && nativeThread !== delivered) return [];
+    conversation = text2(nativeThread ?? delivered, "conversation");
+    requester = text2(context.requesterSenderId, "requester");
+  } catch {
+    return [];
+  }
+  const accountId = selected.native.accountId;
+  const configurationKey = nativeConfigurationKey(selected.native);
+  return [{
+    name: names2[0],
+    label: "WeChat Recall",
+    description: "Recall one own sent message in the current WeChat conversation by its exact opaque message ID from a verified send receipt or wechat_history, or inspect a retained recalled placeholder without another native mutation. The daemon checks eligibility. Returns the durable operation and confirmed, rejected, pending or uncertain result. Never invent IDs or resubmit an uncertain action with a new key; prior model input and completed actions cannot be erased.",
+    parameters: { type: "object", additionalProperties: false, properties: {
+      messageId: { type: "string", minLength: 1, maxLength: 4096, description: "Exact stored message ID in this conversation; send/job/operation IDs are not message IDs." },
+      serverId: { type: "string", pattern: "^[1-9][0-9]{0,19}$", description: "Exact decimal server ID from the same verified receipt or history entry. The stored local message ID alone may be reused." }
+    }, required: ["messageId", "serverId"] },
+    execute: async (_callId, input, signal) => {
+      if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((key2) => !["messageId", "serverId"].includes(key2))) throw Error("Recall is restricted to a message ID in the current conversation");
+      const messageId = text2(input.messageId, "message ID");
+      const serverId = text2(input.serverId, "server ID");
+      if (!/^[1-9]\d{0,19}$/.test(serverId) || BigInt(serverId) > 18446744073709551615n) throw Error("Invalid exact server message ID");
+      const guard = () => {
+        signal?.throwIfAborted();
+        context.assertInvocationCurrent?.();
+        const cfg = currentConfig(), account = resolveWeChatAccount(cfg);
+        if (!account?.enabled || !account.native || account.accountId !== selected.accountId || account.native.accountId !== accountId || nativeConfigurationKey(account.native) !== configurationKey) throw Error("WeChat account configuration changed; start a new turn");
+        return { cfg, account, native: account.native };
+      };
+      const allowed = async () => {
+        const { cfg, account } = guard();
+        const core = dependencies.core ?? getWeChatRuntime();
+        const ingress = await resolveWeChatIngress({
+          resolve: core.channel.inbound?.ingress?.resolveStable ?? resolveStableChannelMessageIngress4,
+          cfg,
+          accountId: account.accountId,
+          policy: resolveWeChatPolicyContext({ account, cfg, chatId: conversation }),
+          isGroup: conversation.endsWith("@chatroom"),
+          chatId: conversation,
+          senderId: requester,
+          readStoreAllowFrom: async () => core.channel.pairing.readAllowFromStore({ channel: "agent-wechat", accountId: account.accountId, env: process.env }).catch(() => [])
+        });
+        guard();
+        if (ingress.ingress.admission !== "dispatch") throw Error("WeChat conversation access is no longer allowed");
+      };
+      await allowed();
+      const { native } = guard();
+      const { client } = await (dependencies.host ?? ensureNativeHost)(native);
+      guard();
+      const message = await client.message(accountId, messageId);
+      guard();
+      const retainedRecall = !!nativeRecallInfo(message);
+      if (message.id !== messageId || message.accountId !== accountId || message.threadId !== conversation || message.direction !== "outgoing" && !retainedRecall) throw Error("Recall target is outside this conversation or was not sent by this account");
+      if (message.serverId !== serverId) throw Error("The exact server identity does not match this receipt; the local message identity may have been reused");
+      await allowed();
+      guard();
+      const key = nativeRecallKey(accountId, conversation, messageId, serverId);
+      let operation;
+      let operationId;
+      const result = (status2, extra = {}) => {
+        const details = {
+          messageId,
+          serverId,
+          threadId: conversation,
+          accountId,
+          action: retainedRecall ? "inspect_recalled" : "recall",
+          idempotencyKey: key,
+          operationId,
+          operationState: operation?.state,
+          status: status2,
+          retryable: false,
+          ...extra
+        };
+        return { content: [{ type: "text", text: JSON.stringify(details) }], details };
+      };
+      try {
+        operation = await client.recallMessage(accountId, messageId, serverId, key, signal);
+        const checkOperation = (candidate) => {
+          if (!candidate || typeof candidate.id !== "string" || !candidate.id || operationId && candidate.id !== operationId || candidate.accountId !== accountId || candidate.kind !== "message_recall") throw Error("Recall operation identity is invalid");
+        };
+        checkOperation(operation);
+        operationId = operation.id;
+        const deadline = Date.now() + Math.max(0, Math.min(dependencies.waitMs ?? 2e3, 1e4));
+        while (["queued", "running", "submitting"].includes(operation.state) && Date.now() < deadline) {
+          await new Promise((resolve) => setTimeout(resolve, Math.min(250, deadline - Date.now())));
+          guard();
+          const remaining = Math.max(1, deadline - Date.now());
+          const next = await client.operation(accountId, operation.id, signal ? AbortSignal.any([signal, AbortSignal.timeout(remaining)]) : AbortSignal.timeout(remaining));
+          checkOperation(next);
+          operation = next;
+        }
+        guard();
+      } catch (error) {
+        const reason = error instanceof NativeApiError ? error.code : "recall_result_unavailable";
+        return result("needs_review", { reason, note: "Inspect the existing operation or repeat only this same message with the same idempotency key. No automatic second submission was made." });
+      }
+      const receipt = operation.result && typeof operation.result === "object" ? operation.result : {};
+      if (receipt.messageId !== void 0 && receipt.messageId !== messageId || receipt.threadId !== void 0 && receipt.threadId !== conversation || receipt.serverId !== void 0 && receipt.serverId !== serverId) throw Error("Recall operation target identity is invalid");
+      const exactReceipt = receipt.messageId === messageId && receipt.threadId === conversation && receipt.serverId === serverId;
+      const status = operation.state === "succeeded" && exactReceipt && ["recalled", "already_recalled"].includes(String(receipt.status)) ? String(receipt.status) : ["queued", "running", "submitting"].includes(operation.state) ? "pending" : operation.state === "failed" && exactReceipt && ["not_self", "not_eligible", "unavailable", "not_found"].includes(String(receipt.status)) ? String(receipt.status) : "needs_review";
+      const boundedState = (value) => typeof value === "string" && /^[a-z0-9_]{1,80}$/.test(value) ? value : void 0;
+      return result(status, {
+        remoteOutcome: boundedState(receipt.remoteOutcome),
+        profileProjection: boundedState(receipt.profileProjection),
+        note: status === "pending" || status === "needs_review" ? "Inspect this durable operation; do not automatically submit a replacement recall." : void 0
+      });
+    }
+  }];
+}
+function registerNativeRecallTools(api) {
+  api.registerTool({ contextVersion: 2, create: (context) => createNativeRecallTools(context) }, { names: names2 });
+}
+
 // index.ts
 var plugin = {
   id: "agent-wechat",
@@ -2925,6 +3675,8 @@ var plugin = {
     const selected = resolveWeChatAccount(api.config);
     api.registerChannel({ plugin: wechatPlugin });
     registerNativeHistoryTools(api);
+    registerNativeShareTools(api);
+    registerNativeRecallTools(api);
     const stopFacade = selected?.native ? registerNativeFacade(api, selected.native) : () => {
     };
     const stopPreparedBoundary = selected?.native?.readPolicy && selected.native.readPolicy !== "on_inbound" ? registerNativePreparedBoundary(api) : () => {