@agent-wechat/agent-wechat 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/index.js

@@ -22,7 +22,7 @@ var nativeConfigSchema = {
       }
     }] },
     consumerStateDir: { type: "string" },
-    readPolicy: { type: "string", enum: ["never", "on_model_dispatch"] },
+    readPolicy: { type: "string", enum: ["never", "on_inbound", "on_model_dispatch"] },
     gatewayFacade: { type: "object", additionalProperties: false, required: ["enabled"], properties: { enabled: { type: "boolean" }, prefix: { type: "string" } } }
   }
 };
@@ -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))
@@ -169,6 +169,7 @@ var NativeWeChatClient = class {
   token;
   fetchImpl;
   timeoutMs;
+  streamIdleTimeoutMs;
   constructor(options) {
     this.baseUrl = validateNativeBaseUrl(options.baseUrl);
     const nodeEnvironment = globalThis.process?.env;
@@ -179,6 +180,9 @@ var NativeWeChatClient = class {
     this.token = options.token;
     this.fetchImpl = options.fetch ?? fetch;
     this.timeoutMs = options.timeoutMs ?? 3e4;
+    this.streamIdleTimeoutMs = options.streamIdleTimeoutMs ?? 45e3;
+    if (!Number.isInteger(this.streamIdleTimeoutMs) || this.streamIdleTimeoutMs < 1 || this.streamIdleTimeoutMs > 3e5)
+      throw new Error("Invalid native stream idle timeout");
   }
   async response(path, init = {}, stream = false) {
     const headers = new Headers(init.headers);
@@ -279,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" });
@@ -318,8 +338,8 @@ var NativeWeChatClient = class {
   groups(accountId, options) {
     return this.request(`v1/accounts/${id(accountId)}/groups${listQuery(options)}`);
   }
-  thread(accountId, threadId) {
-    return this.request(`v1/accounts/${id(accountId)}/threads/${id(threadId)}`);
+  thread(accountId, threadId2) {
+    return this.request(`v1/accounts/${id(accountId)}/threads/${id(threadId2)}`);
   }
   contact(accountId, username) {
     return this.request(`v1/accounts/${id(accountId)}/contacts/${id(username)}`);
@@ -357,12 +377,12 @@ var NativeWeChatClient = class {
   syncGroups(accountId) {
     return this.request(`v1/accounts/${id(accountId)}/group-sync`, { method: "POST", body: "{}" });
   }
-  async messages(accountId, threadId, options) {
-    const result = await this.request(`v1/accounts/${id(accountId)}/threads/${id(threadId)}/messages${listQuery(options)}`);
+  async messages(accountId, threadId2, options) {
+    const result = await this.request(`v1/accounts/${id(accountId)}/threads/${id(threadId2)}/messages${listQuery(options)}`);
     for (const msg of result.items) {
       if (isNativeTombstone(msg))
         continue;
-      if (typeof msg.id !== "string" || msg.accountId !== accountId || msg.threadId !== threadId || msg.serverId != null && (typeof msg.serverId !== "string" || !/^\d+$/.test(msg.serverId)))
+      if (typeof msg.id !== "string" || msg.accountId !== accountId || msg.threadId !== threadId2 || msg.serverId != null && (typeof msg.serverId !== "string" || !/^\d+$/.test(msg.serverId)))
         throw new Error("Invalid native message identity");
     }
     return result;
@@ -373,14 +393,37 @@ var NativeWeChatClient = class {
       throw new Error("Invalid native message identity");
     return message;
   }
-  sendText(accountId, threadId, text, idempotencyKey) {
+  /** Resolve only the stored original in this message's own conversation. */
+  async quotedMessage(accountId, messageId) {
+    const quote = await this.request(`v1/accounts/${id(accountId)}/messages/${id(messageId)}/quote`);
+    if (quote.accountId !== accountId || quote.messageId !== messageId || typeof quote.threadId !== "string" || !["resolved", "embedded", "missing", "invalid", "unsupported", "ambiguous"].includes(quote.state) || (quote.state === "resolved" ? !quote.message || quote.message.accountId !== accountId || quote.message.threadId !== quote.threadId || quote.message.id === messageId : quote.message != null))
+      throw new Error("Invalid native quote identity");
+    return quote;
+  }
+  /** Account-wide local search, with the daemon's query-bound opaque cursor. */
+  async searchMessages(accountId, options) {
+    const result = await this.request(`v1/accounts/${id(accountId)}/messages${listQuery(options)}`);
+    for (const message of result.items) {
+      if (isNativeTombstone(message))
+        continue;
+      if (typeof message.id !== "string" || message.accountId !== accountId || typeof message.threadId !== "string" || !message.threadId || message.serverId != null && (typeof message.serverId !== "string" || !/^\d+$/.test(message.serverId)))
+        throw new Error("Invalid native archive message identity");
+    }
+    return result;
+  }
+  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, 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");
@@ -389,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) {
@@ -426,26 +469,21 @@ var NativeWeChatClient = class {
   }
   async mediaContent(accountId, assetId, options = {}) {
     const max = options.maxBytes ?? 128 * 1024 * 1024;
-    if (!Number.isInteger(max) || max < 1 || max > 128 * 1024 * 1024 || options.range && !/^bytes=(?:\d+-\d*|-\d+)$/.test(options.range))
+    if (!Number.isInteger(max) || max < 1 || max > 128 * 1024 * 1024 || options.range && !/^bytes=(?:\d+-\d*|-\d+)$/.test(options.range) || options.representation != null && !["original", "preview"].includes(options.representation))
       throw new Error("Invalid bounded content request");
-    const response = await this.response(`v1/accounts/${id(accountId)}/media/${id(assetId)}/content`, { signal: options.signal, headers: options.range ? { Range: options.range } : {} });
+    const query = options.representation === "preview" ? "?representation=preview" : "";
+    const response = await this.response(`v1/accounts/${id(accountId)}/media/${id(assetId)}/content${query}`, { signal: options.signal, headers: options.range ? { Range: options.range } : {} });
     const length = response.headers.get("content-length");
     if (length && (!/^\d+$/.test(length) || Number(length) > max)) {
       await response.body?.cancel();
       throw new Error("Native media response exceeds its bound");
     }
-    return { bytes: await this.readBounded(response, max), contentType: response.headers.get("content-type") ?? "application/octet-stream", etag: response.headers.get("etag"), contentRange: response.headers.get("content-range"), status: response.status };
+    return { bytes: await this.readBounded(response, max), contentType: response.headers.get("content-type") ?? "application/octet-stream", etag: response.headers.get("etag"), contentRange: response.headers.get("content-range"), sourceSha256: response.headers.get("x-source-sha256"), status: response.status };
   }
-  markRead(accountId, threadId, messageIds, expectedVersion) {
-    if (!messageIds.length || messageIds.length > 200 || messageIds.some((value) => typeof value !== "string" || !value) || typeof expectedVersion !== "string")
-      throw new Error("Invalid exact-ID read projection");
-    return this.request(`v1/accounts/${id(accountId)}/threads/${id(threadId)}/read-state`, { method: "POST", body: JSON.stringify({ messageIds: [...new Set(messageIds)], expectedVersion }) });
-  }
-  markReadThrough(accountId, threadId, throughMessageId, expectedVersion) {
-    id(throughMessageId);
-    if (typeof expectedVersion !== "string" || !expectedVersion)
+  markRead(accountId, threadId2, expectedVersion) {
+    if (typeof expectedVersion !== "string" || !expectedVersion || expectedVersion.length > 128)
       throw new Error("Read version is required");
-    return this.request(`v1/accounts/${id(accountId)}/threads/${id(threadId)}/read-state`, { method: "POST", body: JSON.stringify({ throughMessageId, expectedVersion }) });
+    return this.request(`v1/accounts/${id(accountId)}/threads/${id(threadId2)}/read-state`, { method: "POST", body: JSON.stringify({ expectedVersion }) });
   }
   events(accountId, after = "0", limit = 100) {
     if (!Number.isInteger(limit) || limit < 1 || limit > 200)
@@ -456,12 +494,27 @@ var NativeWeChatClient = class {
     return this.request(`v1/accounts/${id(accountId)}/consumers/${id(consumerId)}/ack`, { method: "POST", body: JSON.stringify({ cursor: decimal(cursor) }) });
   }
   async *watch(accountId, after = "0", signal) {
-    const response = await this.response(`v1/accounts/${id(accountId)}/events/stream?after=${decimal(after)}`, { signal, headers: { Accept: "text/event-stream" } }, true);
-    if (!response.headers.get("content-type")?.startsWith("text/event-stream"))
-      throw new Error("Expected native SSE response");
-    const reader = response.body?.getReader();
-    if (!reader)
-      throw new Error("Native SSE has no body");
+    const connection = new AbortController();
+    const streamSignal = signal ? AbortSignal.any([signal, connection.signal]) : connection.signal;
+    const bounded = async (work, milliseconds, reason) => {
+      if (streamSignal.aborted)
+        throw streamSignal.reason;
+      let timer;
+      let onAbort = () => {
+      };
+      const interrupted = new Promise((_resolve, reject) => {
+        onAbort = () => reject(streamSignal.reason ?? new Error("Native SSE cancelled"));
+        streamSignal.addEventListener("abort", onAbort, { once: true });
+        timer = setTimeout(() => connection.abort(new Error(reason)), milliseconds);
+      });
+      try {
+        return await Promise.race([work(), interrupted]);
+      } finally {
+        clearTimeout(timer);
+        streamSignal.removeEventListener("abort", onAbort);
+      }
+    };
+    let reader;
     const decoder = new TextDecoder();
     let buffer = "";
     let data = [];
@@ -469,8 +522,17 @@ var NativeWeChatClient = class {
     let eventCursor = "";
     let eventType = "";
     try {
+      const response = await bounded(() => this.response(`v1/accounts/${id(accountId)}/events/stream?after=${decimal(after)}`, { signal: streamSignal, headers: { Accept: "text/event-stream" } }, true), this.timeoutMs, "Native SSE connection timeout");
+      if (!response.headers.get("content-type")?.startsWith("text/event-stream")) {
+        await response.body?.cancel();
+        throw new Error("Expected native SSE response");
+      }
+      reader = response.body?.getReader();
+      if (!reader)
+        throw new Error("Native SSE has no body");
       while (true) {
-        const { value, done } = await reader.read();
+        const activeReader = reader;
+        const { value, done } = await bounded(() => activeReader.read(), this.streamIdleTimeoutMs, "Native SSE idle timeout");
         if (done)
           break;
         buffer += decoder.decode(value, { stream: true });
@@ -510,9 +572,12 @@ var NativeWeChatClient = class {
         }
       }
     } finally {
-      await reader.cancel().catch(() => {
-      });
-      reader.releaseLock();
+      connection.abort();
+      if (reader) {
+        await reader.cancel().catch(() => {
+        });
+        reader.releaseLock();
+      }
     }
   }
 };
@@ -533,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();
@@ -546,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();
@@ -596,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(() => {
@@ -606,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) {
@@ -621,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", () => {
@@ -648,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));
@@ -709,7 +807,7 @@ function collectWeChatStatusIssues(accounts) {
         accountId: snapshot.accountId,
         kind: "runtime",
         message: "Prepared model handoff was not confirmed by this OpenClaw host; automatic read state remains unchanged.",
-        fix: "Use a compatible prepared-run SDK hook, or select native.readPolicy=never while retaining explicit local read control."
+        fix: "Select native.readPolicy=on_inbound to mark successfully handled conversations read without model hooks, or use a compatible prepared-run SDK hook."
       });
     }
     if ((snapshot.needsReview ?? 0) > 0) {
@@ -980,67 +1078,178 @@ 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}]
-[Local file: ${attachment.path}]`);
+    const prefix = originalBody.trim() === name2 ? "" : originalBody;
+    return appendReference(prefix, `[File: ${name2}]
+[Local file: <${attachment.path}>]`);
   }
   if (exposeNonVisualPath) {
     if (attachment.kind === "audio") {
-      return appendReference(originalBody || "<media:audio>", `[Voice message file: ${attachment.path}]`);
+      return appendReference(originalBody || "<media:audio>", `[Voice message file: <${attachment.path}>]`);
     }
     if (attachment.kind === "video") {
-      return appendReference(originalBody || "<media:video>", `[Video file: ${attachment.path}]`);
+      return appendReference(originalBody || "<media:video>", `[Video file: <${attachment.path}>]`);
     }
   }
-  const body = originalBody || (attachment.kind === "image" ? "<media:image>" : originalBody);
+  let body = originalBody || (attachment.kind === "image" ? "<media:image>" : originalBody);
+  if (attachment.kind === "image") body = appendReference(body, `[Image file: <${attachment.path}>]`);
   if (attachment.kind === "image" && attachment.quality === "thumbnail") {
     return appendReference(body, "[Image preview only: thumbnail quality]");
   }
   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"]);
-async function waitNativeMediaJob(client, accountId, initial, timeoutMs = 65e3) {
+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;
   let delay = 250;
   while (!terminalJobs.has(job.state) && Date.now() < deadline) {
+    signal?.throwIfAborted();
+    assertCurrent?.();
     await new Promise((resolve) => setTimeout(resolve, Math.min(delay, Math.max(0, deadline - Date.now()))));
     const remaining = deadline - Date.now();
     if (remaining <= 0) break;
-    job = await client.job(accountId, job.id, AbortSignal.timeout(remaining));
+    signal?.throwIfAborted();
+    assertCurrent?.();
+    job = await client.job(accountId, job.id, signal ? AbortSignal.any([signal, AbortSignal.timeout(remaining)]) : AbortSignal.timeout(remaining));
     delay = Math.min(delay * 2, 1e3);
   }
   return job;
 }
-function select(assets, type) {
+function select(assets, type, quality = "best") {
   const preferred = type === 34 ? ["normal"] : type === 43 ? ["normal", "original"] : ["original", "standard", "thumbnail", "encoded"];
   const rank = (asset) => {
     const index = preferred.indexOf(asset.actualVariant ?? asset.variant);
     return index < 0 ? preferred.length : index;
   };
-  return [...assets].sort((a, b) => rank(a) - rank(b)).find((asset) => asset.state === "available" && (type !== 34 || (asset.actualVariant ?? asset.variant) === "normal"));
+  return [...assets].sort((a, b) => rank(a) - rank(b)).find((asset) => asset.state === "available" && (quality === "best" ? type !== 34 || (asset.actualVariant ?? asset.variant) === "normal" : (asset.actualVariant ?? asset.variant) === quality));
 }
 async function prepareImageRepresentation(bytes, mime, cfg) {
   const configured = cfg?.agents?.defaults?.imageMaxDimensionPx;
@@ -1054,45 +1263,241 @@ 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 = () => {
+    params.signal?.throwIfAborted();
+    params.assertCurrent?.();
+  };
+  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 } });
+  await params.beforeMediaAccess?.();
+  guard();
+  let resolution;
+  try {
+    resolution = await client.quotedMessage(account.native.accountId, message.id);
+  } catch (error) {
+    guard();
+    if (!(error instanceof NativeApiError)) throw error;
+    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 };
+    if (params.allowQuotedMessage && !await params.allowQuotedMessage(author)) return unavailable("not permitted");
+    guard();
+    const quote2 = { state: "embedded", senderId: resolution.senderId ?? void 0, type: message.quote.type };
+    const prefix2 = `${comment}${comment ? "\n\n" : ""}[Quoted ${message.quote.type === 3 ? "image" : "text"} from ${resolution.senderId ?? "unknown sender"}; embedded in quote, original not stored]
+`;
+    if (message.quote.type === 1) return { body: `${prefix2}${resolution.embeddedText}
+[/Quoted message]`, pending: false, quote: quote2 };
+    const beforeMediaAccess2 = async () => {
+      await params.beforeMediaAccess?.();
+      guard();
+      if (params.allowQuotedMessage && !await params.allowQuotedMessage(author)) throw Error("Quoted message is no longer permitted");
+      guard();
+    };
+    const prepared2 = await prepareNativeAttachment({ ...params, message: { ...message, type: 3, appMessageType: void 0, quote: void 0 }, beforeMediaAccess: beforeMediaAccess2 });
+    return {
+      ...prepared2,
+      body: `${prefix2}${prepared2.body}
+[/Quoted message]`,
+      pending: false,
+      quote: quote2,
+      ...prepared2.pending ? { attachment: { kind: "image", status: "pending", filename: "quoted-image" } } : {}
+    };
+  }
+  if (resolution.state !== "resolved") {
+    if (!["missing", "invalid", "unsupported", "ambiguous"].includes(resolution.state) || resolution.message != null) throw Error("Invalid native quote resolution");
+    return unavailable(resolution.state);
+  }
+  const original = resolution.message;
+  if (!original || original.accountId !== message.accountId || original.threadId !== message.threadId || original.id === message.id || original.serverId !== message.quote.serverId || original.type !== message.quote.type || ![1, 3].includes(original.type)) throw Error("Native quoted original crosses its message boundary");
+  if (params.allowQuotedMessage && !await params.allowQuotedMessage(original)) return unavailable("not permitted");
+  guard();
+  const quote = { state: "resolved", messageId: original.id, senderId: original.senderId ?? void 0, type: original.type };
+  const prefix = `${comment}${comment ? "\n\n" : ""}[Quoted ${original.type === 3 ? "image" : "text"} from ${original.senderId ?? "unknown sender"}; message ${original.id}]
+`;
+  if (original.type === 1) return { body: `${prefix}${(original.body ?? "").slice(0, 16384)}
+[/Quoted message]`, pending: false, quote };
+  const beforeMediaAccess = async () => {
+    await params.beforeMediaAccess?.();
+    guard();
+    if (params.allowQuotedMessage && !await params.allowQuotedMessage(original)) throw Error("Quoted message is no longer permitted");
+    guard();
+  };
+  const prepared = await prepareNativeAttachment({ ...params, message: original, beforeMediaAccess });
+  return {
+    ...prepared,
+    body: `${prefix}${prepared.body}
+[/Quoted message]`,
+    pending: false,
+    quote,
+    ...prepared.pending ? { attachment: { kind: "image", status: "pending", filename: "quoted-image" } } : {},
+    suppliedAssets: prepared.suppliedAssets?.map((asset) => ({ ...asset, sourceMessageId: original.id }))
+  };
+}
 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 = () => {
+    params.signal?.throwIfAborted();
+    params.assertCurrent?.();
+  };
+  guard();
+  if (nativeRecallInfo(message)) return { body: "[Message recalled]", pending: false, retryable: false, reason: "message_recalled" };
+  const authorize = async () => {
+    guard();
+    await params.beforeMediaAccess?.();
+    guard();
+  };
+  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;
   const maxBytes = Math.min(account.mediaMaxMb * 1024 * 1024, 128 * 1024 * 1024);
   const scopedAssets = async () => {
+    await authorize();
     const items = (await client.mediaAssets(accountId, message.id)).items;
+    guard();
     if (items.some((asset2) => asset2.accountId !== accountId || asset2.messageId !== message.id)) throw Error("Native attachment identity does not match its message");
     return items;
   };
+  const quality = params.quality ?? "best";
+  const transferQuality = quality === "best" && (message.type === 34 || message.type === 43) ? "normal" : quality;
   let assets = await scopedAssets();
-  let asset = select(assets, message.type);
-  if (!asset && !assets.some((value) => ["expired", "unsupported"].includes(value.state))) {
+  let asset = select(assets, message.type, quality);
+  const relevant = () => assets.filter((value) => transferQuality === "best" || value.variant === transferQuality);
+  const transferCandidate = () => {
+    const order = ["original", "normal", "standard", "thumbnail", "encoded"];
+    return [...relevant()].sort((a, b) => order.indexOf(a.variant) - order.indexOf(b.variant))[0];
+  };
+  const initialCandidate = transferCandidate();
+  if (!asset && initialCandidate?.byteLength != null && initialCandidate.byteLength > maxBytes) {
+    const attachment2 = { kind: attachmentKind, filename: basename(initialCandidate.filename ?? "attachment"), status: "too_large" };
+    return { body: renderAttachmentBody("", attachment2), attachment: attachment2, pending: false, retryable: false };
+  }
+  let job;
+  let transferError;
+  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", "recalled"].includes(transferCandidate()?.state ?? "")) {
+    await authorize();
     try {
-      const job = await client.transferMedia(accountId, { messageId: message.id, assetId: null, quality: message.type === 34 || message.type === 43 ? "normal" : "best" });
-      const completed = await waitNativeMediaJob(client, accountId, job, params.waitMs ?? 2e4);
-      if (["queued", "running"].includes(completed.state)) return { body: `[${attachmentKind} pending]`, pending: true };
-      assets = await scopedAssets();
-      asset = select(assets, message.type);
-    } catch {
-      return { body: `[${attachmentKind} pending: retrieval is unavailable]`, pending: true };
+      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) || 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 filename = basename(asset?.filename ?? `message-${createHash4("sha256").update(message.id).digest("hex").slice(0, 12)}.bin`).replace(/[\r\n\0]/g, "_");
+  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) {
-    const state = assets.find((value) => value.state === "expired") ? "expired" : assets.find((value) => value.state === "unsupported") ? "unsupported" : "unavailable";
-    const attachment2 = { kind: attachmentKind, filename, status: state };
-    return { body: renderAttachmentBody("", attachment2), attachment: attachment2, pending: false };
+    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 {
+      body: renderAttachmentBody("", attachment2),
+      attachment: attachment2,
+      pending: false,
+      jobId: job?.id,
+      retryable: state === "expired" || state === "unsupported" ? false : transferError ? false : job?.retryable ?? params.download === false,
+      reason: transferError?.code ?? (job?.reason && /^[a-z0-9_]{1,80}$/.test(job.reason) ? job.reason : void 0)
+    };
   }
   if (asset.byteLength != null && asset.byteLength > maxBytes) {
     const attachment2 = { kind: attachmentKind, filename, status: "too_large" };
     return { body: renderAttachmentBody("", attachment2), attachment: attachment2, pending: false };
   }
-  const content = await client.mediaContent(accountId, asset.id, { maxBytes });
+  await authorize();
+  const content = await client.mediaContent(accountId, asset.id, { maxBytes, signal: params.signal });
+  guard();
   const mime = content.contentType.split(";", 1)[0].trim().toLowerCase();
   if (!/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/.test(mime)) throw Error("Native attachment MIME type is unsupported");
   const hash = createHash4("sha256").update(content.bytes).digest("hex");
   if (!asset.sha256 || hash !== asset.sha256 || asset.byteLength != null && asset.byteLength !== content.bytes.length) throw new Error("Native attachment integrity did not verify");
+  await authorize();
   const saved = await saveManagedAttachment({ data: Buffer.from(content.bytes).toString("base64"), mime, filename, maxBytes, saveMediaBuffer: core.channel.media.saveMediaBuffer });
   const actual = asset.actualVariant ?? asset.variant;
   const attachment = {
@@ -1105,13 +1510,27 @@ async function prepareNativeAttachment(params) {
   };
   let suppliedPath = saved.path, suppliedMime = mime, suppliedHash = hash, suppliedLength = content.bytes.length;
   let body = renderAttachmentBody("", attachment);
-  if (attachmentKind === "image" && params.cfg) {
-    const representation = await prepareImageRepresentation(Buffer.from(content.bytes), mime, params.cfg);
-    if (representation.preview) {
+  if (attachmentKind === "image" && (params.cfg || mime === "image/x-wxgf")) {
+    let imageBytes = Buffer.from(content.bytes), imageMime = mime;
+    const wxgf = mime === "image/x-wxgf";
+    if (wxgf) {
+      const preview = asset.preview;
+      if (!preview || preview.sourceSha256 !== hash || !/^[a-f0-9]{64}$/.test(preview.sha256) || !Number.isInteger(preview.byteLength) || preview.byteLength <= 0 || preview.byteLength > 16 * 1024 * 1024 || !["image/jpeg", "image/png"].includes(preview.contentType)) throw Error("Native WXGF preview metadata did not verify");
+      await authorize();
+      const derived = await client.mediaContent(accountId, asset.id, { maxBytes: preview.byteLength, representation: "preview", signal: params.signal });
+      guard();
+      const derivedMime = derived.contentType.split(";", 1)[0].trim().toLowerCase();
+      if (derived.sourceSha256 !== hash || derivedMime !== preview.contentType || derived.bytes.length !== preview.byteLength || createHash4("sha256").update(derived.bytes).digest("hex") !== preview.sha256) throw Error("Native WXGF preview integrity did not verify");
+      imageBytes = Buffer.from(derived.bytes);
+      imageMime = derivedMime;
+    }
+    const representation = await prepareImageRepresentation(imageBytes, imageMime, params.cfg);
+    if (wxgf || representation.preview) {
+      const extension = representation.mime === "image/png" ? "png" : "jpg";
       const normalized = await saveManagedAttachment({
         data: representation.bytes.toString("base64"),
         mime: representation.mime,
-        filename: `${filename}.model.jpg`,
+        filename: `${filename}.model.${extension}`,
         maxBytes: 5 * 1024 * 1024,
         saveMediaBuffer: core.channel.media.saveMediaBuffer
       });
@@ -1119,13 +1538,18 @@ async function prepareNativeAttachment(params) {
       suppliedMime = representation.mime;
       suppliedHash = normalized.sha256;
       suppliedLength = normalized.size;
-      body += `
+      body += wxgf ? `
+[Model image: WXGF still preview; original retained separately; animation and transparency are not represented]` : `
 [Model image: prepared still preview; original retained separately]`;
     }
   }
+  guard();
   return {
     body,
     attachment,
+    jobId: job?.id,
+    retryable: false,
+    variant: actual,
     suppliedAssets: [{
       id: asset.id,
       sha256: suppliedHash,
@@ -1146,7 +1570,7 @@ async function prepareNativeAttachment(params) {
     pending: false
   };
 }
-async function sendNativeAttachment(client, account, threadId, 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;
@@ -1161,7 +1585,7 @@ async function sendNativeAttachment(client, account, threadId, mediaUrl, audioAs
     }
     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) {
@@ -1169,7 +1593,7 @@ async function sendNativeAttachment(client, account, threadId, mediaUrl, audioAs
         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();
@@ -1179,7 +1603,7 @@ async function sendNativeAttachment(client, account, threadId, mediaUrl, audioAs
     }
     bytes = new Uint8Array(size);
     let offset = 0;
-    for (const chunk of chunks) {
+    for (const chunk of chunks2) {
       bytes.set(chunk, offset);
       offset += chunk.length;
     }
@@ -1191,7 +1615,7 @@ async function sendNativeAttachment(client, account, threadId, mediaUrl, audioAs
     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));
@@ -1199,9 +1623,9 @@ async function sendNativeAttachment(client, account, threadId, mediaUrl, audioAs
         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();
     }
@@ -1210,43 +1634,39 @@ async function sendNativeAttachment(client, account, threadId, mediaUrl, audioAs
     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, 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, threadId, text, key, options = {}) {
-  let intent = await client.sendText(accountId, threadId, 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;
+  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 };
+  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;
 }
 
@@ -1273,8 +1693,17 @@ var NativeConsumerState = class {
       if (parsed.schemaVersion !== 1 || parsed.serverId !== serverId || parsed.accountId !== accountId || !/^\d+$/.test(parsed.cursor) || !parsed.items || typeof parsed.items !== "object") throw new Error("Native consumer identity or schema mismatch; state was preserved");
       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();
     }
@@ -1282,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 });
@@ -1331,20 +1770,131 @@ 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]) {
-        const completed = Object.entries(this.value.items).filter(([, item]) => !item.readPending && ["completed", "ignored"].includes(item.state));
+      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" };
+        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;
   }
-  update(messageId, update) {
+  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, 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, 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 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" || 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, invalidatedByRecall: false });
+      for (const id2 of historyIds) this.value.items[id2].groupContext = false;
+    });
   }
   /** Synchronous bounded receipt at the SDK's prepared-run callback boundary. */
   preparedCallback(messageIds, readPolicy, previous) {
@@ -1355,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,
@@ -1365,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 });
         }
@@ -1385,12 +1943,17 @@ 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");
   const assets = Object.freeze((params.assets ?? []).map((asset) => {
-    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) || asset.contextRole !== "trigger") throw Error("Invalid native supplied asset manifest");
+    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(),
@@ -1413,10 +1976,19 @@ function nativeDispatchManifest(params) {
         params.message.type,
         params.message.body,
         params.message.mentions,
-        params.message.serverId
+        params.message.serverId,
+        params.message.appMessageType,
+        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, message.link])),
+      role: "history"
+    }))) } : {},
     assets,
     policySha256: digest(JSON.stringify(params.policy ?? null)),
     // Exact released 2026.10.2 source-turn identity. Requiring it in the later
@@ -1430,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 [];
@@ -1514,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;
@@ -1525,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);
 }
@@ -1543,28 +2125,119 @@ function registerNativePreparedBoundary(api) {
   };
 }
 
+// src/native-history.ts
+import { buildHistoryContextFromEntries, buildInboundHistoryFromEntries, DEFAULT_GROUP_HISTORY_LIMIT } from "openclaw/plugin-sdk/reply-history";
+function nativeGroupHistoryLimit(cfg) {
+  const limit = cfg?.messages?.groupChat?.historyLimit;
+  return Number.isInteger(limit) && limit >= 0 ? Math.min(limit, 200) : DEFAULT_GROUP_HISTORY_LIMIT;
+}
+async function transcribeNativeAttachment(prepared, core, cfg) {
+  const attachment = prepared.attachment;
+  if (attachment?.kind !== "audio" || attachment.status !== "ready" || !attachment.path) return prepared;
+  let transcript = "";
+  try {
+    transcript = (await core.mediaUnderstanding.transcribeAudioFile({ filePath: attachment.path, cfg, mime: attachment.mime })).text?.trim() ?? "";
+  } catch {
+  }
+  return { ...prepared, body: `${prepared.body}
+${transcript ? `[Voice transcript: ${transcript.slice(0, 1e4)}]` : "[Voice transcription unavailable]"}` };
+}
+async function prepareNativeHistory(messages, prepare) {
+  const result = new Array(messages.length);
+  let next = 0;
+  await Promise.all(Array.from({ length: Math.min(3, messages.length) }, async () => {
+    for (let index = next++; index < messages.length; index = next++) {
+      const message = messages[index];
+      let prepared;
+      try {
+        prepared = await prepare(message);
+      } catch {
+        prepared = { body: `[Attachment unavailable for message ${message.id}: retrieval or integrity verification failed]`, pending: false };
+      }
+      if (message.type === 1 && prepared.body.length > 4096) prepared = { ...prepared, body: `${prepared.body.slice(0, 4096)}
+[Message truncated; use wechat_history or wechat_search for the stored message]` };
+      result[index] = { message, prepared };
+    }
+  }));
+  return result;
+}
+function buildNativeContext(history, message, prepared) {
+  const all = [...history, { message, prepared }];
+  const image = history.length ? [...all].reverse().find((item) => item.prepared.attachment?.kind === "image" && item.prepared.attachment.status === "ready" && item.prepared.mediaPath) : void 0;
+  const selected = history.length ? image : all.at(-1);
+  const assets = all.flatMap((item) => (item.prepared.suppliedAssets ?? []).map((asset) => {
+    const contextRole = item.message.id === message.id ? "trigger" : "history";
+    if (item === selected) return { ...asset, contextRole, messageId: item.message.id };
+    return {
+      ...asset,
+      contextRole,
+      messageId: item.message.id,
+      runtimeMedia: false,
+      role: "file_reference",
+      path: asset.sourcePath ?? asset.path,
+      sha256: asset.sourceSha256 ?? asset.sha256,
+      byteLength: asset.sourceByteLength ?? asset.byteLength,
+      mime: asset.sourceMime ?? asset.mime
+    };
+  }));
+  const entries = history.map((item) => ({
+    sender: item.message.senderId,
+    body: item.prepared.body,
+    timestamp: item.message.createdAt ? Date.parse(item.message.createdAt) : void 0,
+    messageId: item.message.id
+  }));
+  const inputBody = entries.length ? buildHistoryContextFromEntries({
+    entries,
+    currentMessage: prepared.body,
+    excludeLast: false,
+    formatEntry: (entry) => `${entry.sender}: ${entry.body}`
+  }) : prepared.body;
+  const attachments = all.flatMap((item) => {
+    const attachment = item.prepared.attachment;
+    return attachment?.status === "ready" && attachment.path ? [{
+      path: attachment.path,
+      filename: attachment.filename,
+      kind: attachment.kind,
+      messageId: item.message.id,
+      sender: item.message.senderId
+    }] : [];
+  });
+  return {
+    inputBody,
+    attachments,
+    assets,
+    history: buildInboundHistoryFromEntries({ entries, limit: entries.length }),
+    mediaPath: selected?.prepared.mediaPath,
+    mediaMime: selected?.prepared.mediaMime
+  };
+}
+
 // src/native-monitor.ts
 function nativeWasMentioned(message) {
   return message.mentions?.state === "known" && message.mentions.self === true;
 }
 async function projectNativeRead(client, accountId, state) {
-  for (const item of state.items().filter((value) => value.readPending && value.runId)) {
+  const pending2 = state.items().filter((value) => value.readPending);
+  const threads = [...new Set(pending2.map((item) => item.message.threadId))];
+  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 === item.message.threadId);
-        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 {
-        await client.markRead(accountId, thread.id, [item.message.id], thread.readStateVersion);
-        state.update(item.message.id, { readPending: false });
+        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 }, item.revision);
         break;
       } catch (error) {
         if (error instanceof NativeApiError && error.status === 409 && attempt === 0) continue;
@@ -1573,12 +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");
@@ -1586,8 +2319,20 @@ async function dispatchNativeMessage(params) {
   const policy = resolveWeChatPolicyContext({ account, cfg, chatId: message.threadId });
   const allowTextCommands = core.channel.commands.shouldHandleTextCommands({ cfg, surface: "agent-wechat" });
   const commandBody = normalizeWeChatCommandBody(message.type === 1 ? message.body ?? "" : "", { isGroup, wasMentioned });
+  const hasControlCommand = allowTextCommands && core.channel.commands.isControlCommandMessage(commandBody, cfg);
+  const resolve = core.channel.inbound?.ingress?.resolveStable ?? resolveStableChannelMessageIngress;
+  const senderAdmission = (senderId) => resolveWeChatIngress({
+    resolve,
+    cfg,
+    accountId: account.accountId,
+    policy,
+    isGroup,
+    chatId: message.threadId,
+    senderId,
+    readStoreAllowFrom: async () => core.channel.pairing.readAllowFromStore({ channel: "agent-wechat", accountId: account.accountId, env: process.env }).catch(() => [])
+  });
   const ingress = await resolveWeChatIngress({
-    resolve: core.channel.inbound?.ingress?.resolveStable ?? resolveStableChannelMessageIngress,
+    resolve,
     cfg,
     accountId: account.accountId,
     policy,
@@ -1595,33 +2340,58 @@ async function dispatchNativeMessage(params) {
     chatId: message.threadId,
     senderId: message.senderId,
     readStoreAllowFrom: async () => core.channel.pairing.readAllowFromStore({ channel: "agent-wechat", accountId: account.accountId, env: process.env }).catch(() => []),
-    command: { allowTextCommands, hasControlCommand: allowTextCommands && core.channel.commands.isControlCommandMessage(commandBody, cfg) },
+    command: { allowTextCommands, hasControlCommand },
     mention: { wasMentioned, allowTextCommands }
   });
   const unauthorizedDirectCommand = !isGroup && ingress.ingress.reasonCode === "control_command_unauthorized";
   if (ingress.ingress.admission !== "dispatch" && !unauthorizedDirectCommand) {
-    state.update(message.id, { state: "ignored" });
+    if (isGroup && policy.requireMention && !wasMentioned && !hasControlCommand && (await senderAdmission(message.senderId)).ingress.admission === "dispatch") {
+      state.bufferGroupMessage(message.id, nativeGroupHistoryLimit(cfg), revision);
+      return "ignored";
+    }
+    state.update(message.id, { state: "ignored" }, revision);
     return "ignored";
   }
   let preparedMedia;
-  try {
-    preparedMedia = await (params.prepareAttachment ?? prepareNativeAttachment)({ client, account, message, core, cfg });
-  } catch {
-    state.update(message.id, { state: "needs_review" });
-    return "needs_review";
-  }
+  const allowQuotedMessage = async (original) => original.direction === "outgoing" || !!original.senderId && (await senderAdmission(original.senderId)).ingress.admission === "dispatch";
+  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";
-  let inputBody = preparedMedia.body;
-  if (preparedMedia.attachment?.kind === "audio" && preparedMedia.attachment.status === "ready" && preparedMedia.attachment.path) {
-    try {
-      const transcript = await core.mediaUnderstanding.transcribeAudioFile({ filePath: preparedMedia.attachment.path, cfg, mime: preparedMedia.attachment.mime });
-      if (transcript.text?.trim()) inputBody += `
-[Voice transcript: ${transcript.text.trim().slice(0, 1e4)}]`;
-      else inputBody += "\n[Voice transcription unavailable]";
-    } catch {
-      inputBody += "\n[Voice transcription unavailable]";
-    }
-  }
+  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,
+      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({
     cfg,
     channel: "agent-wechat",
@@ -1649,14 +2419,17 @@ 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,
     CommandAuthorized: core.channel.commands.shouldComputeCommandAuthorized(commandBody, cfg) ? ingress.commandAccess.authorized : void 0,
     OriginatingChannel: "agent-wechat",
     OriginatingTo: `wechat:${message.threadId}`,
-    ...preparedMedia.mediaPath ? { MediaPath: preparedMedia.mediaPath, MediaUrl: preparedMedia.mediaPath, MediaType: preparedMedia.mediaMime } : {}
+    ...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({
@@ -1666,11 +2439,14 @@ async function dispatchNativeMessage(params) {
     agentId: route.agentId,
     channelAccountId: account.accountId,
     policy,
-    assets: preparedMedia.suppliedAssets ?? []
+    assets: context.assets,
+    history: admitted
   });
-  state.update(message.id, { state: "dispatching", dispatchManifest });
-  const callback = message.type === 1 || preparedMedia.attachment?.status === "ready" && preparedMedia.suppliedAssets?.length ? state.preparedCallback([message.id], account.native?.readPolicy ?? "on_model_dispatch") : void 0;
+  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 || 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 {
@@ -1680,17 +2456,22 @@ 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?.();
         },
         onError: () => {
           failed = true;
@@ -1702,14 +2483,34 @@ async function dispatchNativeMessage(params) {
       // and media-snapshot bridge; unsupported or ambiguous handoffs leave reads unchanged.
       replyOptions: { runId: dispatchManifest.runId, onModelSelected, onPreparedAgentRunStart: callback }
     });
-    const prepared = Boolean(state.get(message.id)?.runId);
-    state.update(message.id, { state: failed ? "needs_review" : "completed", handoffUnconfirmed: !prepared });
+    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(() => {
@@ -1737,23 +2538,35 @@ async function startNativeMonitor(opts) {
   const core = getWeChatRuntime();
   let backoff = 250;
   let readTask;
-  const flushRead = () => readTask ??= projectNativeRead(host2.client, native.accountId, state).finally(() => {
-    readTask = void 0;
-  });
+  const flushRead = () => {
+    if (native.readPolicy === "never") return Promise.resolve();
+    return readTask ??= projectNativeRead(host2.client, native.accountId, state).finally(() => {
+      readTask = void 0;
+    });
+  };
   const process2 = async () => {
     const cfg = core.config.current();
     const account = resolveWeChatAccount(cfg, opts.account.accountId) ?? opts.account;
     if (account.backend !== "native" || JSON.stringify(account.native) !== JSON.stringify(native)) throw new Error("Native service configuration changed; restart required before processing");
     for (const item of state.items().filter((value) => value.state === "received")) {
-      await dispatchNativeMessage({ client: host2.client, state, account, message: item.message, cfg, core });
+      await dispatchNativeMessage({
+        client: host2.client,
+        state,
+        account,
+        message: item.message,
+        cfg,
+        core,
+        signal: opts.abortSignal,
+        onDelivered: () => opts.setStatus({ accountId: account.accountId, lastOutboundAt: Date.now() })
+      });
     }
     try {
       await flushRead();
     } catch {
-      opts.log?.error?.("Native read projection is pending; exact input IDs retained for retry");
+      opts.log?.error?.("Native read projection is pending; thread read receipt retained for retry");
     }
-    const needsReview = state.items().filter((value) => value.state === "needs_review").length;
-    const handoffUnconfirmed = native.readPolicy !== "never" && state.items().some((value) => value.handoffUnconfirmed);
+    const needsReview = state.items().filter((value) => value.state === "needs_review" || value.phoneReadState === "needs_review" || value.phoneReadState === "rejected").length;
+    const handoffUnconfirmed = native.readPolicy === "on_model_dispatch" && state.items().some((value) => value.handoffUnconfirmed);
     const accountStatus = await host2.client.account(native.accountId);
     opts.setStatus({
       accountId: account.accountId,
@@ -1764,29 +2577,42 @@ 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 !== "never" && state.items().some((value) => value.handoffUnconfirmed)
+      handoffUnconfirmed: native.readPolicy === "on_model_dispatch" && state.items().some((value) => value.handoffUnconfirmed)
     });
-  }, () => opts.log?.error?.("Native read projection remains pending; exact input IDs retained"));
+  }, () => opts.log?.error?.("Native read projection remains pending; thread read receipts retained"));
   try {
     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");
+          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");
@@ -1856,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, threadId, 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, threadId, 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 {
@@ -1887,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",
@@ -1900,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)
     })
   }
 });
@@ -2029,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
     })
@@ -2048,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,
@@ -2235,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)) {
@@ -2261,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();
@@ -2310,6 +3142,528 @@ function registerNativeFacade(api, config) {
   return handler.stop;
 }
 
+// src/native-history-tools.ts
+import { resolveStableChannelMessageIngress as resolveStableChannelMessageIngress2 } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { imageResultFromFile } from "openclaw/plugin-sdk/channel-actions";
+var pageSchema = { limit: { type: "integer", minimum: 1, maximum: 50, default: 20 }, cursor: { type: "string", maxLength: 8192, description: "Opaque nextCursor from the same tool and query; do not invent one." } };
+var names = ["wechat_history", "wechat_search", "wechat_message", "wechat_media"];
+var archiveNames = ["wechat_archive_threads", "wechat_archive_search", "wechat_archive_history", "wechat_archive_message", "wechat_archive_media"];
+var messageIdSchema = { type: "string", minLength: 1, maxLength: 4096 };
+var qualities = ["best", "original", "standard", "thumbnail", "normal", "encoded"];
+function object(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw Error("Expected tool arguments");
+  return value;
+}
+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 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,
+    threadId: message.threadId,
+    serverId: message.serverId,
+    senderId: message.senderId,
+    direction: message.direction,
+    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,
+    attachment: message.type !== 1 && !isForward && kind2 !== "unsupported" ? { kind: kind2, retrievalTool, messageId: message.id } : void 0
+  };
+}
+function createNativeHistoryTools(context, dependencies = {}) {
+  return createLookupTools(context, dependencies, false);
+}
+function createNativeArchiveTools(context, dependencies = {}) {
+  return createLookupTools(context, dependencies, true);
+}
+function createLookupTools(context, dependencies, archive) {
+  const currentConfig = () => context.getRuntimeConfig?.() ?? context.runtimeConfig ?? context.config;
+  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 [];
+  let currentThread;
+  let requesterSenderId;
+  const target = context.deliveryContext?.channel === "agent-wechat" ? context.deliveryContext.to : void 0;
+  if (!archive) {
+    try {
+      if (context.nativeChannelId) currentThread = threadId(context.nativeChannelId);
+      if (target) {
+        const deliveryThread = threadId(target);
+        if (currentThread && currentThread !== deliveryThread) return [];
+        currentThread ??= deliveryThread;
+      }
+      requesterSenderId = string(context.requesterSenderId, "requester sender ID");
+    } catch {
+      return [];
+    }
+    if (!currentThread) return [];
+  }
+  const selectedId = selected.native.accountId;
+  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.
+    ...action === "media" ? { catalogMode: "direct-only" } : {},
+    parameters: { type: "object", additionalProperties: false, properties, required },
+    execute: async (_callId, input, signal) => {
+      const args = object(input);
+      const guard = () => {
+        signal?.throwIfAborted();
+        context.assertInvocationCurrent?.();
+        const cfg2 = currentConfig();
+        const account2 = resolveWeChatAccount(cfg2);
+        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();
+      if (Object.keys(args).some((key) => !Object.hasOwn(properties, key))) throw Error(archive ? "Unknown archive lookup argument" : "Unknown lookup argument; WeChat history is restricted to the current conversation");
+      const limit = args.limit ?? 20;
+      if (!Number.isInteger(limit) || limit < 1 || limit > 50) throw Error("limit must be 1\u201350");
+      const cursor = args.cursor === void 0 ? void 0 : string(args.cursor, "cursor", 8192);
+      const query = args.query === void 0 ? void 0 : string(args.query, "query", 256);
+      if (query && Buffer.byteLength(query) > 256) throw Error("Search query exceeds 256 UTF-8 bytes");
+      if (action === "search" && !query) throw Error("A non-empty search query is required");
+      const conversation = archive ? args.threadId === void 0 ? void 0 : threadId(args.threadId) : currentThread;
+      if (action === "history" && !conversation) throw Error("A thread ID is required");
+      const messageId = Object.hasOwn(properties, "messageId") ? string(args.messageId, "message ID") : void 0;
+      if (args.download !== void 0 && typeof args.download !== "boolean") throw Error("download must be a boolean");
+      const quality = args.quality ?? "best";
+      if (!qualities.includes(quality)) throw Error("Invalid media quality");
+      const core = dependencies.core ?? getWeChatRuntime();
+      const allowed = async (sender) => {
+        if (archive) return true;
+        const { cfg: cfg2, account: account2 } = guard();
+        const result2 = await resolveWeChatIngress({
+          resolve: core.channel.inbound?.ingress?.resolveStable ?? resolveStableChannelMessageIngress2,
+          cfg: cfg2,
+          accountId: account2.accountId,
+          policy: resolveWeChatPolicyContext({ account: account2, cfg: cfg2, chatId: conversation }),
+          isGroup: conversation.endsWith("@chatroom"),
+          chatId: conversation,
+          senderId: sender,
+          readStoreAllowFrom: async () => core.channel.pairing.readAllowFromStore({ channel: "agent-wechat", accountId: account2.accountId, env: process.env }).catch(() => [])
+        });
+        return result2.ingress.admission === "dispatch";
+      };
+      if (!await allowed(requesterSenderId)) throw Error("WeChat conversation access is no longer allowed");
+      guard();
+      const { client } = await (dependencies.host ?? ensureNativeHost)(native);
+      guard();
+      const accountId = native.accountId;
+      let result;
+      if (action === "threads") {
+        const page = await client.threads(accountId, { limit, cursor, ...query ? { query } : {} });
+        const items = [];
+        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") {
+        const message = await client.message(accountId, messageId);
+        guard();
+        if (!await allowed(requesterSenderId)) throw Error("WeChat conversation access is no longer allowed");
+        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({
+              client,
+              account,
+              message,
+              core,
+              cfg,
+              quality,
+              download: args.download !== false,
+              waitMs: 2e3,
+              signal,
+              assertCurrent: guard,
+              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) {
+            guard();
+            if (!(error instanceof NativeApiError)) throw error;
+            const details2 = {
+              messageId: message.id,
+              threadId: message.threadId,
+              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
+            };
+            return { content: [{ type: "text", text: JSON.stringify(details2) }], details: details2 };
+          }
+          guard();
+          if (!await allowed(requesterSenderId) || message.direction !== "outgoing" && !await allowed(message.senderId ?? void 0)) throw Error("WeChat conversation access is no longer allowed");
+          const details = {
+            messageId: message.id,
+            threadId: message.threadId,
+            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,
+            reason: prepared.reason,
+            body: prepared.body
+          };
+          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 {
+        const options = { limit, cursor, ...action === "search" ? { query } : {} };
+        const page = conversation ? await client.messages(accountId, conversation, options) : await client.searchMessages(accountId, options);
+        const items = [];
+        for (const message of page.items) {
+          if (isNativeTombstone(message)) continue;
+          if (conversation && message.threadId !== conversation || message.accountId !== accountId) throw Error("WeChat history response crosses a conversation boundary");
+          if (message.direction === "outgoing" || await allowed(message.senderId ?? void 0)) items.push(messageResult(message, archive ? "wechat_archive_media" : "wechat_media"));
+        }
+        result = {
+          ...page,
+          items,
+          scope: "local_profile",
+          searchMode: action === "search" ? "case_insensitive_substring" : void 0,
+          note: archive ? "Account-wide local history may be partial. These reads do not mark threads read or download attachments." : "Local history may be partial. A filtered page can be empty with a nextCursor. These reads do not mark a conversation read or download attachments."
+        };
+      }
+      guard();
+      return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
+    }
+  });
+  const querySchema = { type: "string", minLength: 1, maxLength: 256 };
+  const mediaSchema = {
+    messageId: messageIdSchema,
+    download: { type: "boolean", default: true, description: "Set false to use cached media only without requesting a WeChat transfer." },
+    quality: { type: "string", enum: qualities, default: "best", description: "best uses the best cached image, normal video or decoded voice. Explicit variants are strict and may be unavailable." }
+  };
+  if (archive) return [
+    tool(archiveNames[0], "threads", "List or find locally stored threads across the configured WeChat account. Optional case-insensitive query matches thread IDs and display names. Includes groups and peers, with opaque pagination; no read marking.", { query: querySchema, ...pageSchema }),
+    tool(archiveNames[1], "search", "Search locally stored messages across every thread in the configured WeChat account, including other senders. Optional threadId narrows the search. Follow nextCursor with the same query and thread selection; no remote backfill or read marking.", { query: querySchema, threadId: messageIdSchema, ...pageSchema }, ["query"]),
+    tool(archiveNames[2], "history", "Read the locally stored history of any thread in the configured WeChat account, newest first, without sender filtering or read marking. Use wechat_archive_threads to find thread IDs.", { threadId: messageIdSchema, ...pageSchema }, ["threadId"]),
+    tool(archiveNames[3], "message", "Look up a stored message in any thread of the configured WeChat account by its exact opaque message ID. Use wechat_archive_media to retrieve its attachment.", { messageId: messageIdSchema }, ["messageId"]),
+    tool(archiveNames[4], "media", "Retrieve an attachment or quoted text/image from any thread in the configured WeChat account by its message ID. Use the parent quote message ID for quotes. Returns verified managed file paths and an image preview for vision. Cached bytes first; missing media requests a bounded server-owned download unless download=false. Preserve pending/expired/unavailable results and never automatically retry retryable=false. No sends or read marking.", mediaSchema, ["messageId"])
+  ];
+  return [
+    tool(names[0], "history", "Read the current WeChat conversation's locally stored messages, newest first, beyond the recent inbound buffer. Follow nextCursor for older history; no remote history backfill or read marking.", { ...pageSchema }),
+    tool(names[1], "search", "Search the current WeChat conversation's locally stored message text by case-insensitive substring, beyond buffered messages. Follow nextCursor with the same query in this conversation.", { query: querySchema, ...pageSchema }, ["query"]),
+    tool(names[2], "message", "Look up a stored message by its exact opaque message ID in the current WeChat conversation. Media is described without downloading it; use wechat_media to retrieve its attachment. Long text is bounded.", { messageId: messageIdSchema }, ["messageId"]),
+    tool(names[3], "media", "Retrieve a message attachment or quoted text/image from the current WeChat conversation. Use the parent quote message ID for quotes. Returns a verified local file path and an image preview for vision when applicable. Uses cached bytes first; download defaults to true and requests a bounded server-owned transfer if missing. Pending results may be checked again; never automatically retry confirmed expiry or retryable=false. Does not send messages or mark the thread read.", mediaSchema, ["messageId"])
+  ];
+}
+function registerNativeHistoryTools(api) {
+  api.registerTool({ contextVersion: 2, create: (context) => createNativeHistoryTools(context) }, { names });
+  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",
@@ -2320,9 +3674,13 @@ var plugin = {
     setWeChatRuntime(api.runtime);
     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 = registerNativePreparedBoundary(api);
+    const stopPreparedBoundary = selected?.native?.readPolicy && selected.native.readPolicy !== "on_inbound" ? registerNativePreparedBoundary(api) : () => {
+    };
     api.registerService({
       id: "agent-wechat-native",
       reload: { configPrefixes: ["plugins.entries.agent-wechat.config", "channels.agent-wechat", "secrets"] },