@prismshadow/penguin-server 0.2.8 → 0.2.9

package/dist/index.js

@@ -15,7 +15,7 @@ import {
   modelCredentialMissing,
   storeApiToken,
   toUserInfo
-} from "./chunk-UGAFPYVX.js";
+} from "./chunk-OTYHSDV7.js";
 import {
   acquireServerLock,
   liveServerLock,
@@ -29,7 +29,7 @@ import {
   AuthSessionsRepo,
   UsersRepo,
   openDatabase
-} from "./chunk-622KL7BQ.js";
+} from "./chunk-WL5FUO3A.js";
 import "./chunk-4SXGU7RO.js";
 
 // src/index.ts
@@ -39,7 +39,7 @@ import { config as loadDotenv } from "dotenv";
 import { serve } from "@hono/node-server";
 
 // src/app.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import fs30 from "fs";
 import fsp3 from "fs/promises";
 import path28 from "path";
@@ -369,6 +369,29 @@ var ErrorsRepo = class {
       message: r.message
     }));
   }
+  /**
+   * Deletes the rows a matching read would have returned, and answers how many went.
+   *
+   * The WHERE comes from the same `conds` the SELECTs use, so the delete can never reach a row
+   * the caller's own reads could not: narrowing a filter narrows both halves together, and
+   * there is no second expression to drift.
+   *
+   * `includeGlobal` is deliberately not accepted. Unattributed rows belong to no Project and
+   * appear in EVERY Project's admin view, so a Project-scoped clear that took them would empty
+   * them out of every other Project's panel as well — the same line deleteByProject and
+   * deleteByAgent already draw. Clearing them is an admin-wide act and needs an admin-wide
+   * surface, not a side effect of tidying one Project.
+   *
+   * The `Omit` on the parameter says that, but it does not enforce it: excess-property checking
+   * only fires on a fresh object literal, so a caller already holding an `ErrorFilter` could
+   * forward one carrying `includeGlobal: true` and compile clean. Hence the explicit `false`
+   * below — the guard is in the query, where a future caller cannot get around it.
+   */
+  deleteFiltered(projectId, f = {}) {
+    const { where, params } = this.conds(projectId, { ...f, includeGlobal: false });
+    const res = this.db.prepare(`DELETE FROM error_records WHERE ${where}`).run(params);
+    return Number(res.changes);
+  }
   /** Cascading cleanup on Agent deletion (unattributed errors carry no agent_id and are unaffected). */
   deleteByAgent(projectId, agentId) {
     this.db.prepare("DELETE FROM error_records WHERE project_id = ? AND agent_id = ?").run(projectId, agentId);
@@ -4508,182 +4531,652 @@ async function collectUnderCap(chunks, maxBytes, what) {
   return Buffer.concat(parts);
 }
 
-// src/runtime/messaging/error-kind.ts
-var CODES_EXPLAINED_IN_CHAT = /* @__PURE__ */ new Set([
-  "messaging_image_fetch_failed",
-  "messaging_file_fetch_failed",
-  "messaging_file_send_failed"
-]);
-function messagingErrorKind(err, code) {
-  if (!CODES_EXPLAINED_IN_CHAT.has(code)) return "unexpected";
-  if (err instanceof MessagingPermissionError || err instanceof MessagingMediaTooLargeError || err instanceof MessagingUnsupportedError) {
-    return "expected";
-  }
-  return "unexpected";
+// src/runtime/messaging/qq-api.ts
+import { WebSocket } from "undici";
+var QQ_API_BASE = "https://api.bot.qq.com";
+var QQ_INTENT_GROUP_AND_C2C = 1 << 25;
+var CALL_TIMEOUT_MS = 15e3;
+var TOKEN_REFRESH_MARGIN_SEC = 60;
+var OP = {
+  DISPATCH: 0,
+  HEARTBEAT: 1,
+  IDENTIFY: 2,
+  RESUME: 6,
+  RECONNECT: 7,
+  INVALID_SESSION: 9,
+  HELLO: 10,
+  HEARTBEAT_ACK: 11
+};
+function closeCodeInvalidatesSession(code) {
+  return code === 4006 || code === 4007 || code >= 4900 && code <= 4913;
 }
-
-// src/runtime/messaging/markdown.ts
-import remarkGfm from "remark-gfm";
-import remarkParse from "remark-parse";
-import { unified } from "unified";
-var processor = unified().use(remarkParse).use(remarkGfm);
-function parseMarkdown(text) {
-  return processor.parse(text);
+function closeCodeIsFatal(code) {
+  return code === 4914 || code === 4915;
 }
-var SAFE_LINK_SCHEMES = /* @__PURE__ */ new Set([
-  "http:",
-  "https:",
-  "mailto:",
-  "tel:",
-  "tg:"
-]);
-function isSafeUrl(url) {
-  if (url === "" || url.startsWith("#")) return false;
-  try {
-    return SAFE_LINK_SCHEMES.has(new URL(url, "https://example.invalid/").protocol);
-  } catch {
-    return false;
+function closeCodeIsRoutine(code) {
+  return code === 4009 || code >= 4900 && code <= 4913;
+}
+var MessagingConnectionClosedError = class extends Error {
+  constructor(message, closeCode, recovers) {
+    super(message);
+    this.closeCode = closeCode;
+    this.recovers = recovers;
+    this.name = "MessagingConnectionClosedError";
   }
+  closeCode;
+  recovers;
+};
+var QQ_HANDSHAKE_TIMEOUT_MS = 3e4;
+function defaultGatewayRetryMs(failures) {
+  return Math.min(1e3 * 2 ** (failures - 1), 6e4);
 }
-function spanOf(node) {
-  const { position } = node;
-  if (position?.start.offset === void 0 || position.end.offset === void 0) return null;
-  return { from: position.start.offset, to: position.end.offset };
+function fetchErrorText(err) {
+  if (err instanceof Error) {
+    if (err.name === "TimeoutError" || err.name === "AbortError") return "request timed out";
+    const cause = err.cause;
+    if (cause instanceof Error && cause.message !== "") return cause.message;
+    return err.message;
+  }
+  return String(err);
 }
-var BLOCK_PARENTS = /* @__PURE__ */ new Set([
-  "root",
-  "blockquote",
-  "list",
-  "listItem",
-  "table",
-  "footnoteDefinition"
+var QQ_BODY_INDEPENDENT_SEND_CODES = /* @__PURE__ */ new Set([
+  40034128,
+  40034005,
+  304103,
+  40034024,
+  40034105,
+  40054013
 ]);
-function lineStart(text, offset) {
-  return text.lastIndexOf("\n", offset - 1) + 1;
-}
-function longestBacktickRun(value) {
-  let best = 0;
-  let run2 = 0;
-  for (const ch of value) {
-    run2 = ch === "`" ? run2 + 1 : 0;
-    if (run2 > best) best = run2;
+function qqSendErrorText(errCode, message) {
+  if (errCode === 40034128) {
+    return `${message} \u2014 QQ allows only a few replies to one message, within minutes of it`;
   }
-  return best;
-}
-function splitHard(text, max) {
-  const out = [];
-  let rest = text;
-  while (rest.length > max) {
-    const window = rest.slice(0, max);
-    const space = window.search(/\s\S*$/);
-    const cut = space > max / 2 ? space : max;
-    out.push(rest.slice(0, cut));
-    rest = rest.slice(cut).replace(/^\s+/, "");
+  if (errCode === 40034005 || errCode === 304103 || errCode === 40034024) {
+    return `${message} \u2014 the QQ message being replied to has expired`;
   }
-  if (rest !== "") out.push(rest);
-  return out;
-}
-function splitLines(src, max) {
-  const out = [];
-  let buf = "";
-  for (const line of src.split("\n")) {
-    if (buf !== "" && buf.length + 1 + line.length > max) {
-      out.push(buf);
-      buf = "";
-    }
-    if (line.length > max) {
-      if (buf !== "") {
-        out.push(buf);
-        buf = "";
-      }
-      for (const piece of splitHard(line, max)) out.push(piece);
-      continue;
-    }
-    buf = buf === "" ? line : `${buf}
-${line}`;
+  if (errCode === 40034105 || errCode === 40054013) {
+    return `${message} \u2014 this QQ user has turned off messages from bots`;
   }
-  if (buf !== "") out.push(buf);
-  return out;
-}
-function splitFencedCode(value, lang, max) {
-  const language = typeof lang === "string" ? lang : "";
-  const fence = "`".repeat(Math.max(3, longestBacktickRun(value) + 1));
-  const open2 = `${fence}${language}`;
-  const room = max - open2.length - fence.length - 2;
-  if (room <= 0) return splitHard(value, max);
-  return splitLines(value, room).map((piece) => `${open2}
-${piece}
-${fence}`);
+  return message;
 }
-function splitBlock(text, node, max) {
-  const span = spanOf(node);
-  if (span === null) return [];
-  const src = text.slice(span.from, span.to);
-  if (src.length <= max) return [src];
-  if (node.type === "code") return splitFencedCode(node.value, node.lang, max);
-  const children = "children" in node ? node.children : [];
-  const snap = BLOCK_PARENTS.has(node.type);
-  const cuts = [];
-  for (const child of children.slice(1)) {
-    const childSpan = spanOf(child);
-    if (childSpan === null) continue;
-    const at = snap ? lineStart(text, childSpan.from) : childSpan.from;
-    if (at > span.from && at < span.to && at !== cuts.at(-1)) cuts.push(at);
+var QQApiError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "QQApiError";
   }
-  if (cuts.length === 0) return splitLines(src, max);
-  const bounds = [span.from, ...cuts, span.to];
-  const out = [];
-  let buf = "";
-  for (let i = 0; i + 1 < bounds.length; i += 1) {
-    const piece = text.slice(bounds[i], bounds[i + 1]);
-    if (buf !== "" && buf.length + piece.length > max) {
-      out.push(buf);
-      buf = "";
+  code;
+};
+function tokenCacheOf(creds) {
+  let token = "";
+  let expiresAtMs = 0;
+  let inFlight = null;
+  const exchange = async () => {
+    let res;
+    try {
+      res = await fetch(`${QQ_API_BASE}/app/getAppAccessToken`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ appId: creds.appId, clientSecret: creds.appSecret }),
+        signal: AbortSignal.timeout(CALL_TIMEOUT_MS)
+      });
+    } catch (err) {
+      throw new Error(`Token exchange failed: ${fetchErrorText(err)}`);
     }
-    if (piece.length > max) {
-      if (buf !== "") {
-        out.push(buf);
-        buf = "";
-      }
-      for (const part of splitLines(piece, max)) out.push(part);
-      continue;
+    const body = await res.json().catch(() => null);
+    if (body === null || typeof body.access_token !== "string" || body.access_token === "") {
+      const detail = body?.message ?? `HTTP ${res.status}`;
+      const code = body?.code ?? body?.err_code;
+      throw new Error(
+        `Token exchange failed: ${detail}${code !== void 0 ? ` (code ${code})` : ""}`
+      );
     }
-    buf += piece;
-  }
-  if (buf !== "") out.push(buf);
-  return out;
-}
-function chunkMarkdown(text, max) {
-  const trimmed = text.trim();
-  if (trimmed === "") return [];
-  if (trimmed.length <= max) return [trimmed];
-  const root = parseMarkdown(text);
-  const out = [];
-  let buf = "";
-  const flush = () => {
-    const piece = buf.trim();
-    if (piece !== "") out.push(piece);
-    buf = "";
+    const ttl = Number(body.expires_in);
+    const seconds = Number.isFinite(ttl) && ttl > 0 ? Math.min(ttl, 7200) : 7200;
+    token = body.access_token;
+    expiresAtMs = Date.now() + Math.max(seconds - TOKEN_REFRESH_MARGIN_SEC, 1) * 1e3;
+    return token;
   };
-  const blocks = root.children;
-  for (const [i, block4] of blocks.entries()) {
-    const span = spanOf(block4);
-    if (span === null) continue;
-    const to = spanOf(blocks[i + 1] ?? block4)?.from ?? span.to;
-    const src = text.slice(span.from, Math.max(to, span.to));
-    if (src.trimEnd().length > max) {
-      flush();
-      for (const piece of splitBlock(text, block4, max)) {
-        buf = piece;
-        flush();
-      }
-      continue;
+  return {
+    async get() {
+      if (token !== "" && Date.now() < expiresAtMs) return token;
+      inFlight ??= exchange().finally(() => {
+        inFlight = null;
+      });
+      return inFlight;
+    },
+    invalidate() {
+      expiresAtMs = 0;
     }
-    if (buf !== "" && (buf + src).trimEnd().length > max) flush();
-    buf += src;
-  }
-  flush();
-  return out;
+  };
+}
+function createProductionClient(creds) {
+  const tokens = tokenCacheOf(creds);
+  const post = async (path32, payload, retry = true) => {
+    const token = await tokens.get();
+    let res;
+    try {
+      res = await fetch(`${QQ_API_BASE}${path32}`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `QQBot ${token}` },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(CALL_TIMEOUT_MS)
+      });
+    } catch (err) {
+      throw new Error(`Message send failed: ${fetchErrorText(err)}`);
+    }
+    if (res.status >= 200 && res.status < 300) return;
+    const body = await res.json().catch(() => null);
+    if (res.status === 401) {
+      tokens.invalidate();
+      if (retry) return post(path32, payload, false);
+    }
+    const errCode = body?.err_code ?? body?.code;
+    const detail = qqSendErrorText(errCode, body?.message ?? `HTTP ${res.status}`);
+    throw new QQApiError(
+      `Message send failed: ${detail}${errCode !== void 0 ? ` (code ${errCode})` : ""}`,
+      errCode
+    );
+  };
+  return {
+    tokens,
+    async checkCredentials() {
+      await tokens.get();
+    },
+    sendMessage(args) {
+      const path32 = args.kind === "group" ? `/v2/groups/${encodeURIComponent(args.openid)}/messages` : `/v2/users/${encodeURIComponent(args.openid)}/messages`;
+      const markdown = args.markdown;
+      return post(path32, {
+        // "传了 markdown 后此字段必须为空" — the platform rejects a payload carrying both.
+        content: markdown === void 0 ? args.content : "",
+        // 0 = plain text, 2 = markdown. Rich media (7) needs a publicly reachable URL for the
+        // bytes, which is why this channel refuses outbound files (see qq-connector).
+        msg_type: markdown === void 0 ? 0 : 2,
+        ...markdown !== void 0 ? { markdown: { content: markdown } } : {},
+        msg_id: args.msgId,
+        msg_seq: args.msgSeq
+      });
+    }
+  };
+}
+function createQQTransport(opts = {}) {
+  const retryMs = opts.gatewayRetryMs ?? defaultGatewayRetryMs;
+  const createSocket = opts.createSocket ?? ((url) => new WebSocket(url));
+  const handshakeMs = opts.handshakeTimeoutMs ?? QQ_HANDSHAKE_TIMEOUT_MS;
+  return {
+    createClient: (creds) => createProductionClient(creds),
+    async openGateway(creds, handlers) {
+      const session = new GatewaySession(createProductionClient(creds), handlers, {
+        retryMs,
+        createSocket,
+        handshakeMs
+      });
+      session.start();
+      return { close: () => session.close() };
+    }
+  };
+}
+var GatewaySession = class {
+  constructor(client, handlers, opts) {
+    this.client = client;
+    this.handlers = handlers;
+    this.opts = opts;
+  }
+  client;
+  handlers;
+  opts;
+  ws = null;
+  closed = false;
+  failures = 0;
+  /** The resume handle from READY; null until the first successful identify. */
+  sessionId = null;
+  /** Latest dispatch sequence (the heartbeat's `d`, and the resume's). */
+  seq = null;
+  /** Cached `GET /gateway` URL (see the class doc: 2 QPM). */
+  gatewayUrl = null;
+  heartbeat = null;
+  retryTimer = null;
+  /** Armed with the socket, disarmed by the handshake: see QQ_HANDSHAKE_TIMEOUT_MS. */
+  handshakeTimer = null;
+  /** When the last HEARTBEAT_ACK arrived, against which the heartbeat tick measures silence. */
+  lastAckAt = 0;
+  /**
+   * What this outage has already reported; the retries stay quiet until a handshake succeeds.
+   *
+   * One report per outage is what keeps a backoff loop from filling the error table. A routine
+   * close is now filed `expected`, though, so letting it claim the slot outright would silence
+   * the outage behind it: a socket the platform expires at 4009 followed by an auth refusal on
+   * every retry would leave the dashboard reading zero defects for a binding that is down until
+   * a person acts. So a routine report is spent once more — by the first failure that is not
+   * routine — and only then does the outage go quiet.
+   */
+  reported = "none";
+  start() {
+    void this.connect();
+  }
+  close() {
+    this.closed = true;
+    this.stopHeartbeat();
+    this.disarmHandshake();
+    if (this.retryTimer !== null) clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+    const ws = this.ws;
+    this.ws = null;
+    try {
+      ws?.close();
+    } catch {
+    }
+  }
+  async connect() {
+    if (this.closed) return;
+    try {
+      const token = await this.client.tokens.get();
+      if (this.closed) return;
+      this.gatewayUrl ??= await this.fetchGatewayUrl(token);
+      if (this.closed) return;
+      this.openSocket(this.gatewayUrl, token);
+    } catch (err) {
+      this.fail(err);
+    }
+  }
+  async fetchGatewayUrl(token) {
+    let res;
+    try {
+      res = await fetch(`${QQ_API_BASE}/gateway`, {
+        headers: { authorization: `QQBot ${token}` },
+        signal: AbortSignal.timeout(CALL_TIMEOUT_MS)
+      });
+    } catch (err) {
+      throw new Error(`Gateway lookup failed: ${fetchErrorText(err)}`);
+    }
+    const body = await res.json().catch(() => null);
+    if (body === null || typeof body.url !== "string" || body.url === "") {
+      throw new Error(`Gateway lookup failed: ${body?.message ?? `HTTP ${res.status}`}`);
+    }
+    return body.url;
+  }
+  openSocket(url, token) {
+    const ws = this.opts.createSocket(url);
+    this.ws = ws;
+    this.handshakeTimer = setTimeout(() => {
+      this.handshakeTimer = null;
+      this.dropSocket(ws, new Error("gateway handshake did not complete"));
+    }, this.opts.handshakeMs);
+    this.handshakeTimer.unref?.();
+    ws.addEventListener("message", (evt) => {
+      if (this.ws !== ws) return;
+      this.onFrame(String(evt.data), token);
+    });
+    ws.addEventListener("error", () => {
+    });
+    ws.addEventListener("close", (evt) => {
+      if (this.ws !== ws) return;
+      this.stopHeartbeat();
+      this.disarmHandshake();
+      this.ws = null;
+      if (closeCodeInvalidatesSession(evt.code)) {
+        this.sessionId = null;
+        this.seq = null;
+      }
+      if (closeCodeIsFatal(evt.code)) {
+        this.closed = true;
+        this.handlers.onError?.(
+          new MessagingConnectionClosedError(
+            `gateway refused this bot (close code ${evt.code}) \u2014 it is delisted or banned on the QQ open platform`,
+            evt.code,
+            false
+          )
+        );
+        return;
+      }
+      this.fail(
+        new MessagingConnectionClosedError(
+          `gateway connection closed (code ${evt.code})`,
+          evt.code,
+          closeCodeIsRoutine(evt.code)
+        )
+      );
+    });
+  }
+  onFrame(raw, token) {
+    let frame;
+    try {
+      frame = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (typeof frame.s === "number") this.seq = frame.s;
+    switch (frame.op) {
+      case OP.HELLO: {
+        const interval = frame.d?.heartbeat_interval;
+        this.startHeartbeat(typeof interval === "number" && interval > 0 ? interval : 45e3);
+        this.send(
+          this.sessionId !== null ? {
+            op: OP.RESUME,
+            d: { token: `QQBot ${token}`, session_id: this.sessionId, seq: this.seq ?? 0 }
+          } : {
+            op: OP.IDENTIFY,
+            d: {
+              token: `QQBot ${token}`,
+              intents: QQ_INTENT_GROUP_AND_C2C,
+              // Unsharded: this product runs one connection per bot.
+              shard: [0, 1],
+              // Documented as having no effect today; sent empty rather than inventing values.
+              properties: {}
+            }
+          }
+        );
+        return;
+      }
+      case OP.DISPATCH:
+        this.onDispatch(frame);
+        return;
+      case OP.INVALID_SESSION:
+        this.sessionId = null;
+        this.seq = null;
+        this.ws?.close();
+        return;
+      case OP.RECONNECT:
+        this.ws?.close();
+        return;
+      case OP.HEARTBEAT_ACK:
+        this.lastAckAt = Date.now();
+        return;
+      default:
+        return;
+    }
+  }
+  onDispatch(frame) {
+    if (frame.t === "READY") {
+      const d = frame.d;
+      if (typeof d?.session_id === "string") this.sessionId = d.session_id;
+      this.onHandshake();
+      return;
+    }
+    if (frame.t === "RESUMED") {
+      this.onHandshake();
+      return;
+    }
+    const evt = normalizeDispatch(frame);
+    if (evt !== null) void this.handlers.onMessage(evt);
+  }
+  /** A handshake completed: the outage (if any) is over and the backoff resets. */
+  onHandshake() {
+    this.disarmHandshake();
+    this.failures = 0;
+    this.reported = "none";
+    this.handlers.onReady?.();
+  }
+  disarmHandshake() {
+    if (this.handshakeTimer !== null) clearTimeout(this.handshakeTimer);
+    this.handshakeTimer = null;
+  }
+  /**
+   * Abandons a socket the session has given up on and starts the backoff itself.
+   *
+   * The `close` handler is not enough on its own here: the failure both watchdogs cover is
+   * a socket that never fires `close`, and asking a half-open one to close is a request the
+   * far end may never answer. Detaching first makes the `close` that may eventually arrive
+   * a no-op (every listener is gated on `this.ws === ws`).
+   */
+  dropSocket(ws, err) {
+    if (this.ws !== ws) return;
+    this.stopHeartbeat();
+    this.disarmHandshake();
+    this.ws = null;
+    try {
+      ws.close();
+    } catch {
+    }
+    this.fail(err);
+  }
+  startHeartbeat(intervalMs) {
+    this.stopHeartbeat();
+    const ws = this.ws;
+    if (ws === null) return;
+    this.lastAckAt = Date.now();
+    this.heartbeat = setInterval(() => {
+      if (Date.now() - this.lastAckAt > intervalMs * 2) {
+        this.dropSocket(ws, new Error("gateway stopped acknowledging heartbeats"));
+        return;
+      }
+      this.send({ op: OP.HEARTBEAT, d: this.seq });
+    }, intervalMs);
+    this.heartbeat.unref?.();
+  }
+  stopHeartbeat() {
+    if (this.heartbeat !== null) clearInterval(this.heartbeat);
+    this.heartbeat = null;
+  }
+  send(frame) {
+    try {
+      if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(JSON.stringify(frame));
+    } catch {
+    }
+  }
+  /**
+   * One report per outage, then retry with backoff — the Telegram poll loop's contract, with
+   * the one exception `reported` documents: a routine close does not get to be the whole story
+   * of an outage that turns out to need a person.
+   */
+  fail(err) {
+    if (this.closed) return;
+    this.failures += 1;
+    const routine = err instanceof MessagingConnectionClosedError && err.recovers;
+    if (this.reported === "none" || this.reported === "routine" && !routine) {
+      this.reported = routine ? "routine" : "defect";
+      this.handlers.onError?.(err);
+    }
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      void this.connect();
+    }, this.opts.retryMs(this.failures));
+    this.retryTimer.unref?.();
+  }
+};
+function normalizeDispatch(frame) {
+  const d = frame.d;
+  if (d === void 0 || typeof d.id !== "string" || d.id === "") return null;
+  const content = typeof d.content === "string" ? d.content.trim() : "";
+  if (frame.t === "C2C_MESSAGE_CREATE") {
+    const openid = d.author?.user_openid;
+    if (typeof openid !== "string" || openid === "") return null;
+    return { kind: "c2c", openid, messageId: d.id, content, senderOpenid: openid };
+  }
+  if (frame.t === "GROUP_AT_MESSAGE_CREATE") {
+    const openid = d.group_openid;
+    if (typeof openid !== "string" || openid === "") return null;
+    const sender = d.author?.member_openid;
+    return {
+      kind: "group",
+      openid,
+      messageId: d.id,
+      content,
+      ...typeof sender === "string" && sender !== "" ? { senderOpenid: sender } : {}
+    };
+  }
+  return null;
+}
+
+// src/runtime/messaging/error-kind.ts
+var CODES_EXPLAINED_IN_CHAT = /* @__PURE__ */ new Set([
+  "messaging_image_fetch_failed",
+  "messaging_file_fetch_failed",
+  "messaging_file_send_failed"
+]);
+function messagingErrorKind(err, code) {
+  if (err instanceof MessagingConnectionClosedError) {
+    return err.recovers ? "expected" : "unexpected";
+  }
+  if (!CODES_EXPLAINED_IN_CHAT.has(code)) return "unexpected";
+  if (err instanceof MessagingPermissionError || err instanceof MessagingMediaTooLargeError || err instanceof MessagingUnsupportedError) {
+    return "expected";
+  }
+  return "unexpected";
+}
+
+// src/runtime/messaging/markdown.ts
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+var processor = unified().use(remarkParse).use(remarkGfm);
+function parseMarkdown(text) {
+  return processor.parse(text);
+}
+var SAFE_LINK_SCHEMES = /* @__PURE__ */ new Set([
+  "http:",
+  "https:",
+  "mailto:",
+  "tel:",
+  "tg:"
+]);
+function isSafeUrl(url) {
+  if (url === "" || url.startsWith("#")) return false;
+  try {
+    return SAFE_LINK_SCHEMES.has(new URL(url, "https://example.invalid/").protocol);
+  } catch {
+    return false;
+  }
+}
+function spanOf(node) {
+  const { position } = node;
+  if (position?.start.offset === void 0 || position.end.offset === void 0) return null;
+  return { from: position.start.offset, to: position.end.offset };
+}
+var BLOCK_PARENTS = /* @__PURE__ */ new Set([
+  "root",
+  "blockquote",
+  "list",
+  "listItem",
+  "table",
+  "footnoteDefinition"
+]);
+function lineStart(text, offset) {
+  return text.lastIndexOf("\n", offset - 1) + 1;
+}
+function longestBacktickRun(value) {
+  let best = 0;
+  let run2 = 0;
+  for (const ch of value) {
+    run2 = ch === "`" ? run2 + 1 : 0;
+    if (run2 > best) best = run2;
+  }
+  return best;
+}
+function splitHard(text, max) {
+  const out = [];
+  let rest = text;
+  while (rest.length > max) {
+    const window = rest.slice(0, max);
+    const space = window.search(/\s\S*$/);
+    const cut = space > max / 2 ? space : max;
+    out.push(rest.slice(0, cut));
+    rest = rest.slice(cut).replace(/^\s+/, "");
+  }
+  if (rest !== "") out.push(rest);
+  return out;
+}
+function splitLines(src, max) {
+  const out = [];
+  let buf = "";
+  for (const line of src.split("\n")) {
+    if (buf !== "" && buf.length + 1 + line.length > max) {
+      out.push(buf);
+      buf = "";
+    }
+    if (line.length > max) {
+      if (buf !== "") {
+        out.push(buf);
+        buf = "";
+      }
+      for (const piece of splitHard(line, max)) out.push(piece);
+      continue;
+    }
+    buf = buf === "" ? line : `${buf}
+${line}`;
+  }
+  if (buf !== "") out.push(buf);
+  return out;
+}
+function splitFencedCode(value, lang, max) {
+  const language = typeof lang === "string" ? lang : "";
+  const fence = "`".repeat(Math.max(3, longestBacktickRun(value) + 1));
+  const open2 = `${fence}${language}`;
+  const room = max - open2.length - fence.length - 2;
+  if (room <= 0) return splitHard(value, max);
+  return splitLines(value, room).map((piece) => `${open2}
+${piece}
+${fence}`);
+}
+function splitBlock(text, node, max) {
+  const span = spanOf(node);
+  if (span === null) return [];
+  const src = text.slice(span.from, span.to);
+  if (src.length <= max) return [src];
+  if (node.type === "code") return splitFencedCode(node.value, node.lang, max);
+  const children = "children" in node ? node.children : [];
+  const snap = BLOCK_PARENTS.has(node.type);
+  const cuts = [];
+  for (const child of children.slice(1)) {
+    const childSpan = spanOf(child);
+    if (childSpan === null) continue;
+    const at = snap ? lineStart(text, childSpan.from) : childSpan.from;
+    if (at > span.from && at < span.to && at !== cuts.at(-1)) cuts.push(at);
+  }
+  if (cuts.length === 0) return splitLines(src, max);
+  const bounds = [span.from, ...cuts, span.to];
+  const out = [];
+  let buf = "";
+  for (let i = 0; i + 1 < bounds.length; i += 1) {
+    const piece = text.slice(bounds[i], bounds[i + 1]);
+    if (buf !== "" && buf.length + piece.length > max) {
+      out.push(buf);
+      buf = "";
+    }
+    if (piece.length > max) {
+      if (buf !== "") {
+        out.push(buf);
+        buf = "";
+      }
+      for (const part of splitLines(piece, max)) out.push(part);
+      continue;
+    }
+    buf += piece;
+  }
+  if (buf !== "") out.push(buf);
+  return out;
+}
+function chunkMarkdown(text, max) {
+  const trimmed = text.trim();
+  if (trimmed === "") return [];
+  if (trimmed.length <= max) return [trimmed];
+  const root = parseMarkdown(text);
+  const out = [];
+  let buf = "";
+  const flush = () => {
+    const piece = buf.trim();
+    if (piece !== "") out.push(piece);
+    buf = "";
+  };
+  const blocks = root.children;
+  for (const [i, block5] of blocks.entries()) {
+    const span = spanOf(block5);
+    if (span === null) continue;
+    const to = spanOf(blocks[i + 1] ?? block5)?.from ?? span.to;
+    const src = text.slice(span.from, Math.max(to, span.to));
+    if (src.trimEnd().length > max) {
+      flush();
+      for (const piece of splitBlock(text, block5, max)) {
+        buf = piece;
+        flush();
+      }
+      continue;
+    }
+    if (buf !== "" && (buf + src).trimEnd().length > max) flush();
+    buf += src;
+  }
+  flush();
+  return out;
 }
 
 // src/runtime/messaging/reply-files.ts
@@ -6595,7 +7088,7 @@ function telegramHtmlOf(markdown) {
 import { FormData, fetch as undiciFetch2 } from "undici";
 var TELEGRAM_API_BASE = "https://api.telegram.org";
 var TELEGRAM_MAX_DOWNLOAD_BYTES = 20 * 1024 * 1024;
-var CALL_TIMEOUT_MS = 15e3;
+var CALL_TIMEOUT_MS2 = 15e3;
 var TRANSFER_TIMEOUT_MS = 6e4;
 var TelegramApiError = class extends Error {
   constructor(message, errorCode) {
@@ -6614,7 +7107,7 @@ function conflictText(description) {
   }
   return null;
 }
-function fetchErrorText(err) {
+function fetchErrorText2(err) {
   if (err instanceof Error) {
     if (err.name === "TimeoutError" || err.name === "AbortError") return "request timed out";
     const cause = err.cause;
@@ -6641,7 +7134,7 @@ function createTelegramTransport(opts = {}) {
   return {
     createClient(creds) {
       const send = async (method, body, headers, opts2) => {
-        const deadline = AbortSignal.timeout(opts2?.timeoutMs ?? CALL_TIMEOUT_MS);
+        const deadline = AbortSignal.timeout(opts2?.timeoutMs ?? CALL_TIMEOUT_MS2);
         const signal = opts2?.signal ? AbortSignal.any([opts2.signal, deadline]) : deadline;
         let res;
         try {
@@ -6652,7 +7145,7 @@ function createTelegramTransport(opts = {}) {
             signal
           });
         } catch (err) {
-          throw new Error(`${method} failed: ${fetchErrorText(err)}`);
+          throw new Error(`${method} failed: ${fetchErrorText2(err)}`);
         }
         const parsed = await res.json().catch(() => null);
         if (parsed === null || parsed.ok !== true) {
@@ -6720,7 +7213,7 @@ function createTelegramTransport(opts = {}) {
               }
             );
           } catch (err) {
-            throw new Error(`file download failed: ${fetchErrorText(err)}`);
+            throw new Error(`file download failed: ${fetchErrorText2(err)}`);
           }
           if (!res.ok || res.body === null) {
             throw new Error(`file download failed: HTTP ${res.status}`);
@@ -7035,885 +7528,878 @@ var TelegramConnector = class {
   }
 };
 
-// src/runtime/messaging/qq-api.ts
-import { WebSocket } from "undici";
-var QQ_API_BASE = "https://api.bot.qq.com";
-var QQ_INTENT_GROUP_AND_C2C = 1 << 25;
-var CALL_TIMEOUT_MS2 = 15e3;
-var TOKEN_REFRESH_MARGIN_SEC = 60;
-var OP = {
-  DISPATCH: 0,
-  HEARTBEAT: 1,
-  IDENTIFY: 2,
-  RESUME: 6,
-  RECONNECT: 7,
-  INVALID_SESSION: 9,
-  HELLO: 10,
-  HEARTBEAT_ACK: 11
-};
-function closeCodeInvalidatesSession(code) {
-  return code === 4006 || code === 4007 || code >= 4900 && code <= 4913;
+// src/runtime/messaging/qq-markdown.ts
+var LIST_INDENT2 = "    ";
+var RULE2 = "***";
+var INLINE_SPECIALS = /[\\`*_~[\]<]/g;
+function esc3(text) {
+  return text.replace(INLINE_SPECIALS, (ch) => `\\${ch}`);
+}
+function guardLineStarts2(text) {
+  return text.split("\n").map((line) => line.replace(/^(\s*)([#>\-+=])/, "$1\\$2").replace(/^(\s*\d+)([.)])/, "$1\\$2")).join("\n");
+}
+function escLines(value) {
+  return guardLineStarts2(esc3(value));
+}
+function href2(url) {
+  return url.replaceAll("(", "%28").replaceAll(")", "%29");
+}
+function inline3(nodes) {
+  return nodes.map(phrasing3).join("");
+}
+function phrasing3(node) {
+  switch (node.type) {
+    case "text":
+      return esc3(node.value);
+    case "strong":
+      return `**${inline3(node.children)}**`;
+    case "emphasis":
+      return `*${inline3(node.children)}*`;
+    case "delete":
+      return `~~${inline3(node.children)}~~`;
+    case "inlineCode":
+      return esc3(node.value);
+    case "link": {
+      const label = inline3(node.children);
+      return isSafeUrl(node.url) ? `[${label}](${href2(node.url)})` : label;
+    }
+    case "image": {
+      const alt = node.alt ?? "";
+      const label = esc3(alt !== "" ? alt : node.url);
+      return isSafeUrl(node.url) ? `[${label}](${href2(node.url)})` : label;
+    }
+    case "break":
+      return "\n";
+    case "html":
+      return esc3(node.value);
+    case "footnoteReference":
+      return esc3(`[^${node.identifier}]`);
+    case "linkReference":
+    case "imageReference":
+      return "children" in node ? inline3(node.children) : esc3(node.label ?? node.identifier);
+    default:
+      return "";
+  }
+}
+function plainText3(nodes) {
+  return nodes.map((node) => {
+    if (node.type === "text" || node.type === "inlineCode" || node.type === "html") {
+      return node.value;
+    }
+    if (node.type === "break") return " ";
+    if (node.type === "image") return node.alt ?? "";
+    return "children" in node ? plainText3(node.children) : "";
+  }).join("");
+}
+function renderTable2(node) {
+  return escLines(
+    node.children.map((row) => `| ${row.children.map((cell) => plainText3(cell.children)).join(" | ")} |`).join("\n")
+  );
+}
+function itemMarker3(list, index) {
+  return list.ordered === true ? `${(list.start ?? 1) + index}. ` : "- ";
+}
+function itemCheckbox3(item) {
+  if (item.checked === true) return "\u2611 ";
+  if (item.checked === false) return "\u2610 ";
+  return "";
+}
+function renderList3(list, indent) {
+  return list.children.map((item, i) => {
+    const head = `${indent}${itemMarker3(list, i)}${itemCheckbox3(item)}`;
+    const parts = [];
+    for (const [j, child] of item.children.entries()) {
+      if (j === 0 && child.type === "paragraph") {
+        parts.push(head + inline3(child.children));
+        continue;
+      }
+      if (child.type === "list") {
+        parts.push(renderList3(child, indent + LIST_INDENT2));
+        continue;
+      }
+      const rendered = block3(child, indent + LIST_INDENT2);
+      if (rendered !== "") {
+        parts.push(
+          rendered.split("\n").map((line) => indent + LIST_INDENT2 + line).join("\n")
+        );
+      }
+    }
+    return parts.filter((part) => part !== "").join("\n");
+  }).filter((line) => line !== "").join("\n");
+}
+function block3(node, indent) {
+  switch (node.type) {
+    case "paragraph":
+      return guardLineStarts2(inline3(node.children));
+    case "heading":
+      return `${"#".repeat(Math.min(node.depth, 6))} ${inline3(node.children)}`;
+    case "code":
+      return escLines(node.value);
+    case "blockquote":
+      return node.children.map((child) => block3(child, indent)).filter((rendered) => rendered !== "").join("\n\n").split("\n").map((line) => `> ${line}`).join("\n");
+    case "list":
+      return renderList3(node, indent);
+    case "table":
+      return renderTable2(node);
+    case "thematicBreak":
+      return RULE2;
+    case "html":
+      return escLines(node.value);
+    case "footnoteDefinition":
+      return `**${esc3(`[^${node.identifier}]`)}** ${node.children.map((child) => block3(child, indent)).join("\n\n")}`;
+    case "definition":
+      return "";
+    default:
+      return "";
+  }
 }
-function closeCodeIsFatal(code) {
-  return code === 4914 || code === 4915;
+function qqMarkdownOf(markdown) {
+  const root = parseMarkdown(markdown);
+  return root.children.map((node) => block3(node, "")).filter((rendered) => rendered !== "").join("\n\n").trim();
 }
-var QQ_HANDSHAKE_TIMEOUT_MS = 3e4;
-function defaultGatewayRetryMs(failures) {
-  return Math.min(1e3 * 2 ** (failures - 1), 6e4);
+
+// src/runtime/messaging/qq-connector.ts
+var QQ_REPLY_BUDGET = { c2c: 4, group: 5 };
+var QQ_MIN_REPLY_BUDGET = Math.min(...Object.values(QQ_REPLY_BUDGET));
+var QQ_PASSIVE_WINDOW_MS = 5 * 6e4;
+var QQ_TAIL_FLUSH_MS = 1500;
+var QQ_TAIL_MAX_CHARS = 2e4;
+var QQ_TAIL_ELIDED = "\u2026(earlier part omitted \u524D\u7565)\u2026";
+function refuseMedia(file) {
+  return Promise.reject(
+    new MessagingUnsupportedError(
+      `QQ cannot receive "${file.fileName}": sending a file to QQ requires a publicly reachable URL for it, which this server has no way to provide`
+    )
+  );
 }
-function fetchErrorText2(err) {
-  if (err instanceof Error) {
-    if (err.name === "TimeoutError" || err.name === "AbortError") return "request timed out";
-    const cause = err.cause;
-    if (cause instanceof Error && cause.message !== "") return cause.message;
-    return err.message;
+function qqConfigOf(config) {
+  const { appId, appSecret } = config;
+  if (typeof appId !== "string" || appId === "" || typeof appSecret !== "string" || appSecret === "") {
+    throw new Error("malformed qq binding config (appId/appSecret)");
   }
-  return String(err);
+  return { appId, appSecret };
 }
-var QQ_BODY_INDEPENDENT_SEND_CODES = /* @__PURE__ */ new Set([
-  40034128,
-  40034005,
-  304103,
-  40034024,
-  40034105,
-  40054013
-]);
-function qqSendErrorText(errCode, message) {
-  if (errCode === 40034128) {
-    return `${message} \u2014 QQ allows only a few replies to one message, within minutes of it`;
-  }
-  if (errCode === 40034005 || errCode === 304103 || errCode === 40034024) {
-    return `${message} \u2014 the QQ message being replied to has expired`;
-  }
-  if (errCode === 40034105 || errCode === 40054013) {
-    return `${message} \u2014 this QQ user has turned off messages from bots`;
-  }
-  return message;
+function qqChatIdOf(kind, openid) {
+  return `${kind}:${openid}`;
 }
-var QQApiError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "QQApiError";
+function parseQQChatId(chatId) {
+  const i = chatId.indexOf(":");
+  const kind = i > 0 ? chatId.slice(0, i) : "";
+  const openid = i > 0 ? chatId.slice(i + 1) : "";
+  if (kind !== "c2c" && kind !== "group" || openid === "") {
+    throw new Error(`malformed qq chat id "${chatId}"`);
   }
-  code;
-};
-function tokenCacheOf(creds) {
-  let token = "";
-  let expiresAtMs = 0;
-  let inFlight = null;
-  const exchange = async () => {
-    let res;
-    try {
-      res = await fetch(`${QQ_API_BASE}/app/getAppAccessToken`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ appId: creds.appId, clientSecret: creds.appSecret }),
-        signal: AbortSignal.timeout(CALL_TIMEOUT_MS2)
-      });
-    } catch (err) {
-      throw new Error(`Token exchange failed: ${fetchErrorText2(err)}`);
-    }
-    const body = await res.json().catch(() => null);
-    if (body === null || typeof body.access_token !== "string" || body.access_token === "") {
-      const detail = body?.message ?? `HTTP ${res.status}`;
-      const code = body?.code ?? body?.err_code;
-      throw new Error(
-        `Token exchange failed: ${detail}${code !== void 0 ? ` (code ${code})` : ""}`
-      );
-    }
-    const ttl = Number(body.expires_in);
-    const seconds = Number.isFinite(ttl) && ttl > 0 ? Math.min(ttl, 7200) : 7200;
-    token = body.access_token;
-    expiresAtMs = Date.now() + Math.max(seconds - TOKEN_REFRESH_MARGIN_SEC, 1) * 1e3;
-    return token;
-  };
-  return {
-    async get() {
-      if (token !== "" && Date.now() < expiresAtMs) return token;
-      inFlight ??= exchange().finally(() => {
-        inFlight = null;
-      });
-      return inFlight;
-    },
-    invalidate() {
-      expiresAtMs = 0;
-    }
-  };
+  return { kind, openid };
 }
-function createProductionClient(creds) {
-  const tokens = tokenCacheOf(creds);
-  const post = async (path32, payload, retry = true) => {
-    const token = await tokens.get();
-    let res;
-    try {
-      res = await fetch(`${QQ_API_BASE}${path32}`, {
-        method: "POST",
-        headers: { "content-type": "application/json", authorization: `QQBot ${token}` },
-        body: JSON.stringify(payload),
-        signal: AbortSignal.timeout(CALL_TIMEOUT_MS2)
-      });
-    } catch (err) {
-      throw new Error(`Message send failed: ${fetchErrorText2(err)}`);
-    }
-    if (res.status >= 200 && res.status < 300) return;
-    const body = await res.json().catch(() => null);
-    if (res.status === 401) {
-      tokens.invalidate();
-      if (retry) return post(path32, payload, false);
-    }
-    const errCode = body?.err_code ?? body?.code;
-    const detail = qqSendErrorText(errCode, body?.message ?? `HTTP ${res.status}`);
-    throw new QQApiError(
-      `Message send failed: ${detail}${errCode !== void 0 ? ` (code ${errCode})` : ""}`,
-      errCode
-    );
-  };
-  return {
-    tokens,
-    async checkCredentials() {
-      await tokens.get();
-    },
-    sendMessage(args) {
-      const path32 = args.kind === "group" ? `/v2/groups/${encodeURIComponent(args.openid)}/messages` : `/v2/users/${encodeURIComponent(args.openid)}/messages`;
-      const markdown = args.markdown;
-      return post(path32, {
-        // "传了 markdown 后此字段必须为空" — the platform rejects a payload carrying both.
-        content: markdown === void 0 ? args.content : "",
-        // 0 = plain text, 2 = markdown. Rich media (7) needs a publicly reachable URL for the
-        // bytes, which is why this channel refuses outbound files (see qq-connector).
-        msg_type: markdown === void 0 ? 0 : 2,
-        ...markdown !== void 0 ? { markdown: { content: markdown } } : {},
-        msg_id: args.msgId,
-        msg_seq: args.msgSeq
-      });
-    }
-  };
+function qqReplyRefOf(kind, openid, messageId) {
+  return `${qqChatIdOf(kind, openid)}:${messageId}`;
 }
-function createQQTransport(opts = {}) {
-  const retryMs = opts.gatewayRetryMs ?? defaultGatewayRetryMs;
-  const createSocket = opts.createSocket ?? ((url) => new WebSocket(url));
-  const handshakeMs = opts.handshakeTimeoutMs ?? QQ_HANDSHAKE_TIMEOUT_MS;
-  return {
-    createClient: (creds) => createProductionClient(creds),
-    async openGateway(creds, handlers) {
-      const session = new GatewaySession(createProductionClient(creds), handlers, {
-        retryMs,
-        createSocket,
-        handshakeMs
-      });
-      session.start();
-      return { close: () => session.close() };
-    }
-  };
+function chatOfReplyRef(ref) {
+  const cut = ref.lastIndexOf(":");
+  if (cut <= 0) throw new Error(`malformed qq reply ref "${ref}"`);
+  return parseQQChatId(ref.slice(0, cut));
 }
-var GatewaySession = class {
-  constructor(client, handlers, opts) {
-    this.client = client;
-    this.handlers = handlers;
-    this.opts = opts;
+var QQConnector = class {
+  constructor(transport, opts = {}) {
+    this.transport = transport;
+    this.tailFlushMs = opts.tailFlushMs ?? QQ_TAIL_FLUSH_MS;
+    this.now = opts.now ?? (() => Date.now());
+  }
+  transport;
+  channel = "qq";
+  /**
+   * The budget channel-neutral callers clamp to — the bridge uses it to cap the
+   * one-message-per-line split, whose own ceiling of 20 is meaningless against 4.
+   */
+  replyBudget = QQ_MIN_REPLY_BUDGET;
+  /**
+   * Passive-reply state per `(appId, chat)`. It lives on the connector rather than on a
+   * client, because the two halves that need it arrive separately: inbound events come
+   * through `connect`, and sends through the client `createClient` hands the bridge. The
+   * account is part of the key so two bindings on different bots can never spend each
+   * other's budget.
+   */
+  ledgers = /* @__PURE__ */ new Map();
+  tailFlushMs;
+  now;
+  async createClient(config) {
+    const creds = qqConfigOf(config);
+    const bot = this.transport.createClient(creds);
+    const deliver = (chatId, text, opts) => {
+      const { kind, openid } = parseQQChatId(chatId);
+      return this.enqueue(creds, bot, kind, openid, text, opts?.markdown === true);
+    };
+    const client = {
+      async checkCredentials() {
+        await bot.checkCredentials();
+        return null;
+      },
+      sendText: (chatId, text, opts) => deliver(chatId, text, opts),
+      // Same operation as sendText: `msg_id` is an authorization anchor on QQ, not a
+      // visible quote, so there is no threading to honour (see the module doc).
+      replyText: (ref, text, opts) => {
+        const { kind, openid } = chatOfReplyRef(ref);
+        return this.enqueue(creds, bot, kind, openid, text, opts?.markdown === true);
+      },
+      sendImage: (_chatId, file) => refuseMedia(file),
+      sendFile: (_chatId, file) => refuseMedia(file)
+    };
+    return client;
+  }
+  async connect(config, handlers) {
+    const creds = qqConfigOf(config);
+    const connection = await this.transport.openGateway(creds, {
+      onMessage: async (evt) => {
+        this.noteInbound(creds, evt);
+        await handlers.onMessage({
+          chatId: qqChatIdOf(evt.kind, evt.openid),
+          chatKind: evt.kind === "c2c" ? "direct" : "group",
+          messageId: qqReplyRefOf(evt.kind, evt.openid, evt.messageId),
+          // Only text is read today; an empty content is every non-text message type
+          // (image, voice, card, forwarded record), which the bridge answers with the
+          // text-only notice. Inbound media is a follow-up, not a gap.
+          text: evt.content !== "" ? evt.content : null,
+          ...evt.senderOpenid !== void 0 ? { senderName: evt.senderOpenid } : {}
+        });
+      },
+      ...handlers.onReady ? { onReady: handlers.onReady } : {},
+      ...handlers.onError ? { onError: handlers.onError } : {}
+    });
+    return {
+      close: () => {
+        connection.close();
+        this.dropLedgers(creds.appId);
+      }
+    };
   }
-  client;
-  handlers;
-  opts;
-  ws = null;
-  closed = false;
-  failures = 0;
-  /** The resume handle from READY; null until the first successful identify. */
-  sessionId = null;
-  /** Latest dispatch sequence (the heartbeat's `d`, and the resume's). */
-  seq = null;
-  /** Cached `GET /gateway` URL (see the class doc: 2 QPM). */
-  gatewayUrl = null;
-  heartbeat = null;
-  retryTimer = null;
-  /** Armed with the socket, disarmed by the handshake: see QQ_HANDSHAKE_TIMEOUT_MS. */
-  handshakeTimer = null;
-  /** When the last HEARTBEAT_ACK arrived, against which the heartbeat tick measures silence. */
-  lastAckAt = 0;
-  /** This outage already reported; the retries stay quiet until a handshake succeeds. */
-  reported = false;
-  start() {
-    void this.connect();
+  // —— The passive-reply budget ————————————————————————————————————————————
+  ledgerKey(appId, kind, openid) {
+    return `${appId}:${kind}:${openid}`;
   }
-  close() {
-    this.closed = true;
-    this.stopHeartbeat();
-    this.disarmHandshake();
-    if (this.retryTimer !== null) clearTimeout(this.retryTimer);
-    this.retryTimer = null;
-    const ws = this.ws;
-    this.ws = null;
-    try {
-      ws?.close();
-    } catch {
+  ledgerFor(appId, kind, openid) {
+    const key = this.ledgerKey(appId, kind, openid);
+    let ledger = this.ledgers.get(key);
+    if (ledger === void 0) {
+      this.evictExpired();
+      ledger = {
+        appId,
+        kind,
+        openid,
+        msgId: null,
+        receivedAt: 0,
+        spent: 0,
+        tail: [],
+        markdown: false,
+        bot: null,
+        timer: null,
+        chain: Promise.resolve()
+      };
+      this.ledgers.set(key, ledger);
     }
+    return ledger;
   }
-  async connect() {
-    if (this.closed) return;
-    try {
-      const token = await this.client.tokens.get();
-      if (this.closed) return;
-      this.gatewayUrl ??= await this.fetchGatewayUrl(token);
-      if (this.closed) return;
-      this.openSocket(this.gatewayUrl, token);
-    } catch (err) {
-      this.fail(err);
-    }
+  /** Clears a ledger's pending flush and forgets it. */
+  dropLedger(key, ledger) {
+    if (ledger.timer !== null) clearTimeout(ledger.timer);
+    this.ledgers.delete(key);
   }
-  async fetchGatewayUrl(token) {
-    let res;
-    try {
-      res = await fetch(`${QQ_API_BASE}/gateway`, {
-        headers: { authorization: `QQBot ${token}` },
-        signal: AbortSignal.timeout(CALL_TIMEOUT_MS2)
-      });
-    } catch (err) {
-      throw new Error(`Gateway lookup failed: ${fetchErrorText2(err)}`);
-    }
-    const body = await res.json().catch(() => null);
-    if (body === null || typeof body.url !== "string" || body.url === "") {
-      throw new Error(`Gateway lookup failed: ${body?.message ?? `HTTP ${res.status}`}`);
+  /** Forgets every ledger of one credential set — the connection's close (see connect). */
+  dropLedgers(appId) {
+    for (const [key, ledger] of this.ledgers) {
+      if (ledger.appId === appId) this.dropLedger(key, ledger);
     }
-    return body.url;
-  }
-  openSocket(url, token) {
-    const ws = this.opts.createSocket(url);
-    this.ws = ws;
-    this.handshakeTimer = setTimeout(() => {
-      this.handshakeTimer = null;
-      this.dropSocket(ws, new Error("gateway handshake did not complete"));
-    }, this.opts.handshakeMs);
-    this.handshakeTimer.unref?.();
-    ws.addEventListener("message", (evt) => {
-      if (this.ws !== ws) return;
-      this.onFrame(String(evt.data), token);
-    });
-    ws.addEventListener("error", () => {
-    });
-    ws.addEventListener("close", (evt) => {
-      if (this.ws !== ws) return;
-      this.stopHeartbeat();
-      this.disarmHandshake();
-      this.ws = null;
-      if (closeCodeInvalidatesSession(evt.code)) {
-        this.sessionId = null;
-        this.seq = null;
-      }
-      if (closeCodeIsFatal(evt.code)) {
-        this.closed = true;
-        this.handlers.onError?.(
-          new Error(
-            `gateway refused this bot (close code ${evt.code}) \u2014 it is delisted or banned on the QQ open platform`
-          )
-        );
-        return;
-      }
-      this.fail(new Error(`gateway connection closed (code ${evt.code})`));
-    });
   }
-  onFrame(raw, token) {
-    let frame;
-    try {
-      frame = JSON.parse(raw);
-    } catch {
-      return;
+  /**
+   * Forgets every ledger whose anchor message is past the reply window. An unanchored one
+   * is left alone: it holds no budget to lose, and the client that just created it is
+   * holding the object.
+   */
+  evictExpired() {
+    for (const [key, ledger] of this.ledgers) {
+      if (ledger.msgId === null) continue;
+      if (this.now() - ledger.receivedAt <= QQ_PASSIVE_WINDOW_MS) continue;
+      this.dropLedger(key, ledger);
     }
-    if (typeof frame.s === "number") this.seq = frame.s;
-    switch (frame.op) {
-      case OP.HELLO: {
-        const interval = frame.d?.heartbeat_interval;
-        this.startHeartbeat(typeof interval === "number" && interval > 0 ? interval : 45e3);
-        this.send(
-          this.sessionId !== null ? {
-            op: OP.RESUME,
-            d: { token: `QQBot ${token}`, session_id: this.sessionId, seq: this.seq ?? 0 }
-          } : {
-            op: OP.IDENTIFY,
-            d: {
-              token: `QQBot ${token}`,
-              intents: QQ_INTENT_GROUP_AND_C2C,
-              // Unsharded: this product runs one connection per bot.
-              shard: [0, 1],
-              // Documented as having no effect today; sent empty rather than inventing values.
-              properties: {}
-            }
-          }
-        );
-        return;
-      }
-      case OP.DISPATCH:
-        this.onDispatch(frame);
-        return;
-      case OP.INVALID_SESSION:
-        this.sessionId = null;
-        this.seq = null;
-        this.ws?.close();
-        return;
-      case OP.RECONNECT:
-        this.ws?.close();
-        return;
-      case OP.HEARTBEAT_ACK:
-        this.lastAckAt = Date.now();
-        return;
-      default:
-        return;
+  }
+  /**
+   * A new inbound message: fresh budget, and the moment a withheld tail can finally go out.
+   *
+   * A tail is carried onto the new budget only while the message it was written for is
+   * still inside its own window. Past that it is dropped — the one place anything is — and
+   * deliberately: text withheld longer than the platform's whole reply window is no longer
+   * an answer to anything the user still has in view, and delivering it as the first thing
+   * they see after saying "hi" would read as the bot malfunctioning. The loss is bounded by
+   * the same window everything else on this channel is.
+   */
+  noteInbound(creds, evt) {
+    const ledger = this.ledgerFor(creds.appId, evt.kind, evt.openid);
+    if (ledger.msgId === evt.messageId) return;
+    if (ledger.timer !== null) {
+      clearTimeout(ledger.timer);
+      ledger.timer = null;
     }
+    const carry = ledger.tail.length > 0 && this.repliable(ledger);
+    if (!carry) ledger.tail = [];
+    ledger.msgId = evt.messageId;
+    ledger.receivedAt = this.now();
+    ledger.spent = 0;
+    if (carry) this.scheduleFlush(ledger, 0);
   }
-  onDispatch(frame) {
-    if (frame.t === "READY") {
-      const d = frame.d;
-      if (typeof d?.session_id === "string") this.sessionId = d.session_id;
-      this.onHandshake();
-      return;
+  /** True while `ledger.msgId` can still be replied to at all. */
+  repliable(ledger) {
+    return ledger.msgId !== null && this.now() - ledger.receivedAt <= QQ_PASSIVE_WINDOW_MS;
+  }
+  /**
+   * One outbound body. Sends immediately while an ordinary slot is free, otherwise
+   * withholds it for the reserved final slot; throws when the chat has no repliable
+   * message at all, which is the one thing QQ gives no way around (see the module doc).
+   */
+  async enqueue(creds, bot, kind, openid, text, markdown) {
+    const ledger = this.ledgerFor(creds.appId, kind, openid);
+    ledger.bot = bot;
+    ledger.markdown = markdown;
+    if (!this.repliable(ledger)) {
+      throw new Error(
+        "QQ only accepts replies to a message sent from QQ, within a few minutes of it \u2014 send the bot a message in QQ and it will answer"
+      );
     }
-    if (frame.t === "RESUMED") {
-      this.onHandshake();
+    const budget = QQ_REPLY_BUDGET[kind];
+    if (ledger.spent < budget - 1) {
+      await this.chain(ledger, () => this.sendNow(ledger, text, markdown));
       return;
     }
-    const evt = normalizeDispatch(frame);
-    if (evt !== null) void this.handlers.onMessage(evt);
+    this.withhold(ledger, text);
+    if (ledger.spent < budget) this.scheduleFlush(ledger, this.tailFlushMs);
   }
-  /** A handshake completed: the outage (if any) is over and the backoff resets. */
-  onHandshake() {
-    this.disarmHandshake();
-    this.failures = 0;
-    this.reported = false;
-    this.handlers.onReady?.();
+  /** Appends to the withheld tail, dropping from the FRONT if the ceiling is reached. */
+  withhold(ledger, text) {
+    ledger.tail.push(text);
+    let total = ledger.tail.reduce((n, part) => n + part.length + 2, 0);
+    while (total > QQ_TAIL_MAX_CHARS && ledger.tail.length > 1) {
+      const dropped = ledger.tail.shift();
+      total -= (dropped?.length ?? 0) + 2;
+      if (ledger.tail[0] !== QQ_TAIL_ELIDED) ledger.tail.unshift(QQ_TAIL_ELIDED);
+    }
   }
-  disarmHandshake() {
-    if (this.handshakeTimer !== null) clearTimeout(this.handshakeTimer);
-    this.handshakeTimer = null;
+  scheduleFlush(ledger, delayMs) {
+    if (ledger.timer !== null) clearTimeout(ledger.timer);
+    ledger.timer = setTimeout(() => {
+      ledger.timer = null;
+      void this.chain(ledger, () => this.flush(ledger)).catch(() => {
+      });
+    }, delayMs);
+    ledger.timer.unref?.();
   }
   /**
-   * Abandons a socket the session has given up on and starts the backoff itself.
-   *
-   * The `close` handler is not enough on its own here: the failure both watchdogs cover is
-   * a socket that never fires `close`, and asking a half-open one to close is a request the
-   * far end may never answer. Detaching first makes the `close` that may eventually arrive
-   * a no-op (every listener is gated on `this.ws === ws`).
+   * Spends the reserved final slot on everything withheld, as one message. A combined tail
+   * over the channel's size cap is chunked as usual and only its FIRST chunk is sent — the
+   * rest returns to the tail, to ride the next inbound message's budget rather than a
+   * rejection.
    */
-  dropSocket(ws, err) {
-    if (this.ws !== ws) return;
-    this.stopHeartbeat();
-    this.disarmHandshake();
-    this.ws = null;
-    try {
-      ws.close();
-    } catch {
+  async flush(ledger) {
+    if (ledger.tail.length === 0) return;
+    if (!this.repliable(ledger) || ledger.spent >= QQ_REPLY_BUDGET[ledger.kind]) return;
+    const combined = ledger.tail.join("\n\n");
+    const chunks = ledger.markdown ? chunkMarkdown(combined, MESSAGING_TEXT_CHUNK_CHARS) : chunkMessagingText(combined);
+    const head = chunks[0];
+    if (head === void 0) {
+      ledger.tail = [];
+      return;
     }
-    this.fail(err);
-  }
-  startHeartbeat(intervalMs) {
-    this.stopHeartbeat();
-    const ws = this.ws;
-    if (ws === null) return;
-    this.lastAckAt = Date.now();
-    this.heartbeat = setInterval(() => {
-      if (Date.now() - this.lastAckAt > intervalMs * 2) {
-        this.dropSocket(ws, new Error("gateway stopped acknowledging heartbeats"));
-        return;
-      }
-      this.send({ op: OP.HEARTBEAT, d: this.seq });
-    }, intervalMs);
-    this.heartbeat.unref?.();
-  }
-  stopHeartbeat() {
-    if (this.heartbeat !== null) clearInterval(this.heartbeat);
-    this.heartbeat = null;
-  }
-  send(frame) {
+    ledger.tail = chunks.slice(1);
     try {
-      if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(JSON.stringify(frame));
-    } catch {
-    }
-  }
-  /** One report per outage, then retry with backoff — the Telegram poll loop's contract. */
-  fail(err) {
-    if (this.closed) return;
-    this.failures += 1;
-    if (!this.reported) {
-      this.reported = true;
-      this.handlers.onError?.(err);
+      await this.sendNow(ledger, head, ledger.markdown);
+    } catch (err) {
+      ledger.tail.unshift(head);
+      throw err;
     }
-    this.retryTimer = setTimeout(() => {
-      this.retryTimer = null;
-      void this.connect();
-    }, this.opts.retryMs(this.failures));
-    this.retryTimer.unref?.();
-  }
-};
-function normalizeDispatch(frame) {
-  const d = frame.d;
-  if (d === void 0 || typeof d.id !== "string" || d.id === "") return null;
-  const content = typeof d.content === "string" ? d.content.trim() : "";
-  if (frame.t === "C2C_MESSAGE_CREATE") {
-    const openid = d.author?.user_openid;
-    if (typeof openid !== "string" || openid === "") return null;
-    return { kind: "c2c", openid, messageId: d.id, content, senderOpenid: openid };
   }
-  if (frame.t === "GROUP_AT_MESSAGE_CREATE") {
-    const openid = d.group_openid;
-    if (typeof openid !== "string" || openid === "") return null;
-    const sender = d.author?.member_openid;
-    return {
-      kind: "group",
-      openid,
-      messageId: d.id,
-      content,
-      ...typeof sender === "string" && sender !== "" ? { senderOpenid: sender } : {}
+  /**
+   * One real send: the next `msg_seq` against the ledger's anchor message, as Markdown when
+   * the binding asked for it and as plain text if the platform refuses that.
+   *
+   * The fallback costs a SLOT here, which it does on no other channel: a repeated
+   * `(msg_id, msg_seq)` pair is refused rather than deduplicated, so the retry must carry a
+   * fresh sequence number and that number is one of the four an inbound message funds. It is
+   * still the right trade — a reply the reader never sees is worse than a reply that spent
+   * an extra slot — but it is only taken while a slot remains, and never for a refusal that
+   * was not about the body in the first place (see QQ_BODY_INDEPENDENT_SEND_CODES): those
+   * would fail identically as text and burn the slot reserved for the withheld tail.
+   */
+  async sendNow(ledger, text, markdown) {
+    const msgId = ledger.msgId;
+    const bot = ledger.bot;
+    if (msgId === null || bot === null) return;
+    const send = (body) => {
+      ledger.spent += 1;
+      return bot.sendMessage({
+        kind: ledger.kind,
+        openid: ledger.openid,
+        content: text,
+        ...body,
+        msgId,
+        msgSeq: ledger.spent
+      });
     };
-  }
-  return null;
-}
-
-// src/runtime/messaging/qq-markdown.ts
-var LIST_INDENT2 = "    ";
-var RULE2 = "***";
-var INLINE_SPECIALS = /[\\`*_~[\]<]/g;
-function esc3(text) {
-  return text.replace(INLINE_SPECIALS, (ch) => `\\${ch}`);
-}
-function guardLineStarts2(text) {
-  return text.split("\n").map((line) => line.replace(/^(\s*)([#>\-+=])/, "$1\\$2").replace(/^(\s*\d+)([.)])/, "$1\\$2")).join("\n");
-}
-function escLines(value) {
-  return guardLineStarts2(esc3(value));
-}
-function href2(url) {
-  return url.replaceAll("(", "%28").replaceAll(")", "%29");
-}
-function inline3(nodes) {
-  return nodes.map(phrasing3).join("");
-}
-function phrasing3(node) {
-  switch (node.type) {
-    case "text":
-      return esc3(node.value);
-    case "strong":
-      return `**${inline3(node.children)}**`;
-    case "emphasis":
-      return `*${inline3(node.children)}*`;
-    case "delete":
-      return `~~${inline3(node.children)}~~`;
-    case "inlineCode":
-      return esc3(node.value);
-    case "link": {
-      const label = inline3(node.children);
-      return isSafeUrl(node.url) ? `[${label}](${href2(node.url)})` : label;
-    }
-    case "image": {
-      const alt = node.alt ?? "";
-      const label = esc3(alt !== "" ? alt : node.url);
-      return isSafeUrl(node.url) ? `[${label}](${href2(node.url)})` : label;
+    if (!markdown) return send({});
+    try {
+      await send({ markdown: qqMarkdownOf(text) });
+      return;
+    } catch (err) {
+      if (!(err instanceof QQApiError)) throw err;
+      if (err.code !== void 0 && QQ_BODY_INDEPENDENT_SEND_CODES.has(err.code)) throw err;
+      if (ledger.spent >= QQ_REPLY_BUDGET[ledger.kind]) throw err;
     }
-    case "break":
-      return "\n";
-    case "html":
-      return esc3(node.value);
-    case "footnoteReference":
-      return esc3(`[^${node.identifier}]`);
-    case "linkReference":
-    case "imageReference":
-      return "children" in node ? inline3(node.children) : esc3(node.label ?? node.identifier);
-    default:
-      return "";
+    await send({});
   }
-}
-function plainText3(nodes) {
-  return nodes.map((node) => {
-    if (node.type === "text" || node.type === "inlineCode" || node.type === "html") {
-      return node.value;
-    }
-    if (node.type === "break") return " ";
-    if (node.type === "image") return node.alt ?? "";
-    return "children" in node ? plainText3(node.children) : "";
-  }).join("");
-}
-function renderTable2(node) {
-  return escLines(
-    node.children.map((row) => `| ${row.children.map((cell) => plainText3(cell.children)).join(" | ")} |`).join("\n")
-  );
-}
-function itemMarker3(list, index) {
-  return list.ordered === true ? `${(list.start ?? 1) + index}. ` : "- ";
-}
-function itemCheckbox3(item) {
-  if (item.checked === true) return "\u2611 ";
-  if (item.checked === false) return "\u2610 ";
-  return "";
-}
-function renderList3(list, indent) {
-  return list.children.map((item, i) => {
-    const head = `${indent}${itemMarker3(list, i)}${itemCheckbox3(item)}`;
-    const parts = [];
-    for (const [j, child] of item.children.entries()) {
-      if (j === 0 && child.type === "paragraph") {
-        parts.push(head + inline3(child.children));
-        continue;
-      }
-      if (child.type === "list") {
-        parts.push(renderList3(child, indent + LIST_INDENT2));
-        continue;
-      }
-      const rendered = block3(child, indent + LIST_INDENT2);
-      if (rendered !== "") {
-        parts.push(
-          rendered.split("\n").map((line) => indent + LIST_INDENT2 + line).join("\n")
-        );
-      }
-    }
-    return parts.filter((part) => part !== "").join("\n");
-  }).filter((line) => line !== "").join("\n");
-}
-function block3(node, indent) {
-  switch (node.type) {
-    case "paragraph":
-      return guardLineStarts2(inline3(node.children));
-    case "heading":
-      return `${"#".repeat(Math.min(node.depth, 6))} ${inline3(node.children)}`;
-    case "code":
-      return escLines(node.value);
-    case "blockquote":
-      return node.children.map((child) => block3(child, indent)).filter((rendered) => rendered !== "").join("\n\n").split("\n").map((line) => `> ${line}`).join("\n");
-    case "list":
-      return renderList3(node, indent);
-    case "table":
-      return renderTable2(node);
-    case "thematicBreak":
-      return RULE2;
-    case "html":
-      return escLines(node.value);
-    case "footnoteDefinition":
-      return `**${esc3(`[^${node.identifier}]`)}** ${node.children.map((child) => block3(child, indent)).join("\n\n")}`;
-    case "definition":
-      return "";
-    default:
-      return "";
+  /**
+   * Appends to the chat's send chain. Two sends against one `msg_id` must reach the
+   * platform in `msg_seq` order, and the chain never rejects — the caller's promise carries
+   * the failure, and one failed send must not poison the chat's later ones.
+   */
+  chain(ledger, run2) {
+    const result = ledger.chain.then(run2);
+    ledger.chain = result.catch(() => {
+    });
+    return result;
   }
-}
-function qqMarkdownOf(markdown) {
-  const root = parseMarkdown(markdown);
-  return root.children.map((node) => block3(node, "")).filter((rendered) => rendered !== "").join("\n\n").trim();
-}
+};
 
-// src/runtime/messaging/qq-connector.ts
-var QQ_REPLY_BUDGET = { c2c: 4, group: 5 };
-var QQ_MIN_REPLY_BUDGET = Math.min(...Object.values(QQ_REPLY_BUDGET));
-var QQ_PASSIVE_WINDOW_MS = 5 * 6e4;
-var QQ_TAIL_FLUSH_MS = 1500;
-var QQ_TAIL_MAX_CHARS = 2e4;
-var QQ_TAIL_ELIDED = "\u2026(earlier part omitted \u524D\u7565)\u2026";
-function refuseMedia(file) {
-  return Promise.reject(
-    new MessagingUnsupportedError(
-      `QQ cannot receive "${file.fileName}": sending a file to QQ requires a publicly reachable URL for it, which this server has no way to provide`
-    )
-  );
-}
-function qqConfigOf(config) {
-  const { appId, appSecret } = config;
-  if (typeof appId !== "string" || appId === "" || typeof appSecret !== "string" || appSecret === "") {
-    throw new Error("malformed qq binding config (appId/appSecret)");
+// src/runtime/messaging/qq-scan.ts
+import { createDecipheriv, randomBytes as randomBytes2 } from "crypto";
+var QQ_SCAN_BASE = "https://q.qq.com";
+var QQ_SCAN_QR_PAGE = "https://q.qq.com/qqbot/openclaw/connect.html";
+var CALL_TIMEOUT_MS3 = 15e3;
+var QQ_SCAN_POLL_MS = 2e3;
+var QQ_SCAN_KEY_BYTES = 32;
+var GCM_IV_BYTES = 12;
+var GCM_TAG_BYTES = 16;
+function fetchErrorText3(err) {
+  if (err instanceof Error) {
+    if (err.name === "TimeoutError" || err.name === "AbortError") return "request timed out";
+    const cause = err.cause;
+    if (cause instanceof Error && cause.message !== "") return cause.message;
+    return err.message;
   }
-  return { appId, appSecret };
+  return String(err);
 }
-function qqChatIdOf(kind, openid) {
-  return `${kind}:${openid}`;
+function statusOf(raw) {
+  switch (Number(raw)) {
+    case 0:
+      return "none";
+    case 2:
+      return "completed";
+    case 3:
+      return "expired";
+    default:
+      return "pending";
+  }
 }
-function parseQQChatId(chatId) {
-  const i = chatId.indexOf(":");
-  const kind = i > 0 ? chatId.slice(0, i) : "";
-  const openid = i > 0 ? chatId.slice(i + 1) : "";
-  if (kind !== "c2c" && kind !== "group" || openid === "") {
-    throw new Error(`malformed qq chat id "${chatId}"`);
+function botsOf(data) {
+  const entries = data === void 0 ? [] : Array.isArray(data) ? data : [data];
+  const bots = [];
+  for (const entry of entries) {
+    const appId = entry.bot_appid;
+    const secret = entry.bot_encrypt_secret;
+    if (appId === void 0 || appId === "" || typeof secret !== "string" || secret === "") {
+      continue;
+    }
+    bots.push({
+      appId: String(appId),
+      encryptedSecret: secret,
+      ...typeof entry.user_openid === "string" ? { userOpenid: entry.user_openid } : {}
+    });
   }
-  return { kind, openid };
+  return bots;
 }
-function qqReplyRefOf(kind, openid, messageId) {
-  return `${qqChatIdOf(kind, openid)}:${messageId}`;
+function createQQScanTransport(base = QQ_SCAN_BASE) {
+  const post = async (path32, payload) => {
+    let res;
+    try {
+      res = await fetch(`${base}${path32}`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(CALL_TIMEOUT_MS3)
+      });
+    } catch (err) {
+      throw new Error(`QQ scan request failed: ${fetchErrorText3(err)}`);
+    }
+    const body = await res.json().catch(() => null);
+    if (body === null || body.retcode !== void 0 && body.retcode !== 0) {
+      const detail = body?.msg ?? `HTTP ${res.status}`;
+      const code = body?.retcode !== void 0 ? ` (retcode ${body.retcode})` : "";
+      throw new Error(`QQ scan request failed: ${detail}${code}`);
+    }
+    return body.data;
+  };
+  return {
+    async createBindTask(key) {
+      const data = await post("/lite/create_bind_task", { key });
+      const taskId = data?.task_id;
+      if (typeof taskId !== "string" || taskId === "") {
+        throw new Error("QQ scan request failed: no task id was returned");
+      }
+      return taskId;
+    },
+    async pollBindResult(taskId) {
+      const data = await post("/lite/poll_bind_result", {
+        task_id: taskId
+      });
+      const first = Array.isArray(data) ? data[0] : data;
+      return { status: statusOf(first?.status), bots: botsOf(data) };
+    }
+  };
 }
-function chatOfReplyRef(ref) {
-  const cut = ref.lastIndexOf(":");
-  if (cut <= 0) throw new Error(`malformed qq reply ref "${ref}"`);
-  return parseQQChatId(ref.slice(0, cut));
+function newQQScanKey() {
+  return randomBytes2(QQ_SCAN_KEY_BYTES).toString("base64");
 }
-var QQConnector = class {
+function qqScanQrUrl(taskId, source = "") {
+  return `${QQ_SCAN_QR_PAGE}?task_id=${encodeURIComponent(taskId)}&source=${encodeURIComponent(source)}&_wv=2`;
+}
+function decryptQQBotSecret(keyBase64, encryptedBase64) {
+  const key = Buffer.from(keyBase64, "base64");
+  const payload = Buffer.from(encryptedBase64, "base64");
+  if (key.length !== QQ_SCAN_KEY_BYTES) {
+    throw new Error("QQ scan key is not a 32-byte AES key");
+  }
+  if (payload.length <= GCM_IV_BYTES + GCM_TAG_BYTES) {
+    throw new Error("QQ scan payload is too short to contain an encrypted secret");
+  }
+  const iv = payload.subarray(0, GCM_IV_BYTES);
+  const tag = payload.subarray(payload.length - GCM_TAG_BYTES);
+  const ciphertext = payload.subarray(GCM_IV_BYTES, payload.length - GCM_TAG_BYTES);
+  const decipher = createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(tag);
+  let plaintext;
+  try {
+    plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+  } catch {
+    throw new Error("QQ scan result could not be decrypted");
+  }
+  const secret = plaintext.toString("utf8");
+  if (secret === "") throw new Error("QQ scan result decrypted to an empty secret");
+  return secret;
+}
+var QQ_SCAN_TASK_TTL_MS = 10 * 6e4;
+var QQ_SCAN_MAX_TASKS_PER_SESSION = 4;
+var QQ_SCAN_MAX_TASKS = 4096;
+var QQScanService = class {
   constructor(transport, opts = {}) {
     this.transport = transport;
-    this.tailFlushMs = opts.tailFlushMs ?? QQ_TAIL_FLUSH_MS;
     this.now = opts.now ?? (() => Date.now());
   }
   transport;
-  channel = "qq";
-  /**
-   * The budget channel-neutral callers clamp to — the bridge uses it to cap the
-   * one-message-per-line split, whose own ceiling of 20 is meaningless against 4.
-   */
-  replyBudget = QQ_MIN_REPLY_BUDGET;
-  /**
-   * Passive-reply state per `(appId, chat)`. It lives on the connector rather than on a
-   * client, because the two halves that need it arrive separately: inbound events come
-   * through `connect`, and sends through the client `createClient` hands the bridge. The
-   * account is part of the key so two bindings on different bots can never spend each
-   * other's budget.
-   */
-  ledgers = /* @__PURE__ */ new Map();
-  tailFlushMs;
+  tasks = /* @__PURE__ */ new Map();
   now;
-  async createClient(config) {
-    const creds = qqConfigOf(config);
-    const bot = this.transport.createClient(creds);
-    const deliver = (chatId, text, opts) => {
-      const { kind, openid } = parseQQChatId(chatId);
-      return this.enqueue(creds, bot, kind, openid, text, opts?.markdown === true);
-    };
-    const client = {
-      async checkCredentials() {
-        await bot.checkCredentials();
-        return null;
-      },
-      sendText: (chatId, text, opts) => deliver(chatId, text, opts),
-      // Same operation as sendText: `msg_id` is an authorization anchor on QQ, not a
-      // visible quote, so there is no threading to honour (see the module doc).
-      replyText: (ref, text, opts) => {
-        const { kind, openid } = chatOfReplyRef(ref);
-        return this.enqueue(creds, bot, kind, openid, text, opts?.markdown === true);
-      },
-      sendImage: (_chatId, file) => refuseMedia(file),
-      sendFile: (_chatId, file) => refuseMedia(file)
-    };
-    return client;
-  }
-  async connect(config, handlers) {
-    const creds = qqConfigOf(config);
-    const connection = await this.transport.openGateway(creds, {
-      onMessage: async (evt) => {
-        this.noteInbound(creds, evt);
-        await handlers.onMessage({
-          chatId: qqChatIdOf(evt.kind, evt.openid),
-          chatKind: evt.kind === "c2c" ? "direct" : "group",
-          messageId: qqReplyRefOf(evt.kind, evt.openid, evt.messageId),
-          // Only text is read today; an empty content is every non-text message type
-          // (image, voice, card, forwarded record), which the bridge answers with the
-          // text-only notice. Inbound media is a follow-up, not a gap.
-          text: evt.content !== "" ? evt.content : null,
-          ...evt.senderOpenid !== void 0 ? { senderName: evt.senderOpenid } : {}
-        });
-      },
-      ...handlers.onReady ? { onReady: handlers.onReady } : {},
-      ...handlers.onError ? { onError: handlers.onError } : {}
-    });
-    return {
-      close: () => {
-        connection.close();
-        this.dropLedgers(creds.appId);
-      }
-    };
-  }
-  // —— The passive-reply budget ————————————————————————————————————————————
-  ledgerKey(appId, kind, openid) {
-    return `${appId}:${kind}:${openid}`;
+  /** The self-re-arming sweep, alive only while a task is remembered (see `armSweep`). */
+  sweepTimer = null;
+  /** Starts a scan: a fresh key, a task registered under it, and the URL for the QR. */
+  async start(sessionId) {
+    this.sweep();
+    const key = newQQScanKey();
+    const taskId = await this.transport.createBindTask(key);
+    this.evictOwn(sessionId);
+    this.tasks.set(taskId, { key, sessionId, createdAt: this.now(), claimed: false });
+    this.armSweep();
+    return { taskId, qrUrl: qqScanQrUrl(taskId), pollMs: QQ_SCAN_POLL_MS };
   }
-  ledgerFor(appId, kind, openid) {
-    const key = this.ledgerKey(appId, kind, openid);
-    let ledger = this.ledgers.get(key);
-    if (ledger === void 0) {
-      this.evictExpired();
-      ledger = {
-        appId,
-        kind,
-        openid,
-        msgId: null,
-        receivedAt: 0,
-        spent: 0,
-        tail: [],
-        markdown: false,
-        bot: null,
-        timer: null,
-        chain: Promise.resolve()
-      };
-      this.ledgers.set(key, ledger);
+  /**
+   * Polls one task. Returns null when the task id is not one this Session started (an
+   * unknown id, another Session's, one already consumed, or one another poll is resolving
+   * right now) — the caller answers 404, which is also what a replay gets.
+   */
+  async poll(sessionId, taskId) {
+    const task = this.tasks.get(taskId);
+    if (task === void 0 || task.sessionId !== sessionId || task.claimed) return null;
+    task.claimed = true;
+    if (this.now() - task.createdAt > QQ_SCAN_TASK_TTL_MS) {
+      this.tasks.delete(taskId);
+      return { status: "expired" };
     }
-    return ledger;
+    let result;
+    try {
+      result = await this.transport.pollBindResult(taskId);
+    } catch (err) {
+      task.claimed = false;
+      throw err;
+    }
+    if (result.status === "expired") {
+      this.tasks.delete(taskId);
+      return { status: "expired" };
+    }
+    if (result.status !== "completed") {
+      task.claimed = false;
+      return { status: result.status };
+    }
+    this.tasks.delete(taskId);
+    const bot = result.bots[0];
+    if (bot === void 0) {
+      throw new Error("QQ reported the scan complete but returned no bot");
+    }
+    const appSecret = decryptQQBotSecret(task.key, bot.encryptedSecret);
+    return { status: "completed", bot: { appId: bot.appId, appSecret } };
   }
-  /** Clears a ledger's pending flush and forgets it. */
-  dropLedger(key, ledger) {
-    if (ledger.timer !== null) clearTimeout(ledger.timer);
-    this.ledgers.delete(key);
+  /** Drops a task the user walked away from (the editor's cancel, and its unmount). */
+  cancel(sessionId, taskId) {
+    if (this.tasks.get(taskId)?.sessionId === sessionId) this.tasks.delete(taskId);
   }
-  /** Forgets every ledger of one credential set — the connection's close (see connect). */
-  dropLedgers(appId) {
-    for (const [key, ledger] of this.ledgers) {
-      if (ledger.appId === appId) this.dropLedger(key, ledger);
+  /** Session-delete cascade and bind removal: forget anything this Session had in flight. */
+  cancelSession(sessionId) {
+    for (const [taskId, task] of this.tasks) {
+      if (task.sessionId === sessionId) this.tasks.delete(taskId);
     }
   }
   /**
-   * Forgets every ledger whose anchor message is past the reply window. An unanchored one
-   * is left alone: it holds no budget to lose, and the client that just created it is
-   * holding the object.
+   * Drops this Session's oldest tasks until one more fits under its own ceiling. Scoped to
+   * the caller: the whole point of the per-Session ceiling is that filling it takes a code
+   * away from nobody else.
    */
-  evictExpired() {
-    for (const [key, ledger] of this.ledgers) {
-      if (ledger.msgId === null) continue;
-      if (this.now() - ledger.receivedAt <= QQ_PASSIVE_WINDOW_MS) continue;
-      this.dropLedger(key, ledger);
+  evictOwn(sessionId) {
+    const own = [...this.tasks].filter(([, task]) => task.sessionId === sessionId);
+    if (own.length < QQ_SCAN_MAX_TASKS_PER_SESSION) return;
+    own.sort((a, b) => a[1].createdAt - b[1].createdAt);
+    for (const [taskId] of own.slice(0, own.length - QQ_SCAN_MAX_TASKS_PER_SESSION + 1)) {
+      this.tasks.delete(taskId);
     }
   }
-  /**
-   * A new inbound message: fresh budget, and the moment a withheld tail can finally go out.
-   *
-   * A tail is carried onto the new budget only while the message it was written for is
-   * still inside its own window. Past that it is dropped — the one place anything is — and
-   * deliberately: text withheld longer than the platform's whole reply window is no longer
-   * an answer to anything the user still has in view, and delivering it as the first thing
-   * they see after saying "hi" would read as the bot malfunctioning. The loss is bounded by
-   * the same window everything else on this channel is.
-   */
-  noteInbound(creds, evt) {
-    const ledger = this.ledgerFor(creds.appId, evt.kind, evt.openid);
-    if (ledger.msgId === evt.messageId) return;
-    if (ledger.timer !== null) {
-      clearTimeout(ledger.timer);
-      ledger.timer = null;
+  /** Drops expired tasks, then the oldest ones if the table is still over its backstop. */
+  sweep() {
+    const cutoff = this.now() - QQ_SCAN_TASK_TTL_MS;
+    for (const [taskId, task] of this.tasks) {
+      if (task.createdAt <= cutoff) this.tasks.delete(taskId);
+    }
+    if (this.tasks.size < QQ_SCAN_MAX_TASKS) return;
+    const byAge = [...this.tasks].sort((a, b) => a[1].createdAt - b[1].createdAt);
+    for (const [taskId] of byAge.slice(0, this.tasks.size - QQ_SCAN_MAX_TASKS + 1)) {
+      this.tasks.delete(taskId);
     }
-    const carry = ledger.tail.length > 0 && this.repliable(ledger);
-    if (!carry) ledger.tail = [];
-    ledger.msgId = evt.messageId;
-    ledger.receivedAt = this.now();
-    ledger.spent = 0;
-    if (carry) this.scheduleFlush(ledger, 0);
-  }
-  /** True while `ledger.msgId` can still be replied to at all. */
-  repliable(ledger) {
-    return ledger.msgId !== null && this.now() - ledger.receivedAt <= QQ_PASSIVE_WINDOW_MS;
   }
   /**
-   * One outbound body. Sends immediately while an ordinary slot is free, otherwise
-   * withholds it for the reserved final slot; throws when the chat has no repliable
-   * message at all, which is the one thing QQ gives no way around (see the module doc).
+   * Keeps one unref'd timer alive while any task is remembered, so a scan the user walked
+   * away from stops holding its key roughly at the TTL instead of at whenever somebody
+   * happens to start the next scan — which may be never, and a key at rest is the one
+   * outcome this module is shaped to avoid. It re-arms only while the table is non-empty,
+   * and unref'd it is never the reason a process stays alive.
    */
-  async enqueue(creds, bot, kind, openid, text, markdown) {
-    const ledger = this.ledgerFor(creds.appId, kind, openid);
-    ledger.bot = bot;
-    ledger.markdown = markdown;
-    if (!this.repliable(ledger)) {
-      throw new Error(
-        "QQ only accepts replies to a message sent from QQ, within a few minutes of it \u2014 send the bot a message in QQ and it will answer"
-      );
+  armSweep() {
+    if (this.sweepTimer !== null || this.tasks.size === 0) return;
+    const timer = setTimeout(() => {
+      this.sweepTimer = null;
+      this.sweep();
+      this.armSweep();
+    }, QQ_SCAN_TASK_TTL_MS);
+    timer.unref();
+    this.sweepTimer = timer;
+  }
+};
+
+// src/runtime/messaging/wechat-markdown.ts
+var LIST_INDENT3 = "    ";
+var MAX_HEADING_DEPTH = 4;
+var INLINE_SPECIALS2 = /[\\`*_~[\]]/g;
+var CJK = /[⺀-〿぀-ヿ㐀-䶿一-鿿가-힯豈-﫿＀-￯]/;
+function esc4(text) {
+  return text.replace(INLINE_SPECIALS2, (ch) => `\\${ch}`);
+}
+function guardLineStarts3(text) {
+  return text.split("\n").map((line) => line.replace(/^(\s*)([#>\-+])/, "$1\\$2").replace(/^(\s*\d+)([.)])/, "$1\\$2")).join("\n");
+}
+function href3(url) {
+  return url.replaceAll("(", "%28").replaceAll(")", "%29");
+}
+function inline4(nodes) {
+  return nodes.map(phrasing4).join("");
+}
+function emphasis(node) {
+  const body = inline4(node.children);
+  return CJK.test(body) ? body : `*${body}*`;
+}
+function longestBacktickRun2(value) {
+  let longest = 0;
+  for (const run2 of value.matchAll(/`+/g)) longest = Math.max(longest, run2[0].length);
+  return longest;
+}
+function phrasing4(node) {
+  switch (node.type) {
+    case "text":
+      return esc4(node.value);
+    case "strong":
+      return `**${inline4(node.children)}**`;
+    case "emphasis":
+      return emphasis(node);
+    case "delete":
+      return `~~${inline4(node.children)}~~`;
+    case "inlineCode": {
+      const fence = "`".repeat(longestBacktickRun2(node.value) + 1);
+      const pad = node.value.startsWith("`") || node.value.endsWith("`") ? " " : "";
+      return `${fence}${pad}${node.value}${pad}${fence}`;
     }
-    const budget = QQ_REPLY_BUDGET[kind];
-    if (ledger.spent < budget - 1) {
-      await this.chain(ledger, () => this.sendNow(ledger, text, markdown));
-      return;
+    case "link": {
+      const label = inline4(node.children);
+      return isSafeUrl(node.url) ? `[${label}](${href3(node.url)})` : label;
     }
-    this.withhold(ledger, text);
-    if (ledger.spent < budget) this.scheduleFlush(ledger, this.tailFlushMs);
-  }
-  /** Appends to the withheld tail, dropping from the FRONT if the ceiling is reached. */
-  withhold(ledger, text) {
-    ledger.tail.push(text);
-    let total = ledger.tail.reduce((n, part) => n + part.length + 2, 0);
-    while (total > QQ_TAIL_MAX_CHARS && ledger.tail.length > 1) {
-      const dropped = ledger.tail.shift();
-      total -= (dropped?.length ?? 0) + 2;
-      if (ledger.tail[0] !== QQ_TAIL_ELIDED) ledger.tail.unshift(QQ_TAIL_ELIDED);
+    case "image": {
+      const alt = node.alt ?? "";
+      const label = esc4(alt !== "" ? alt : node.url);
+      return isSafeUrl(node.url) ? `[${label}](${href3(node.url)})` : label;
     }
+    case "break":
+      return "\n";
+    case "html":
+      return esc4(node.value);
+    case "footnoteReference":
+      return esc4(`[^${node.identifier}]`);
+    case "linkReference":
+    case "imageReference":
+      return "children" in node ? inline4(node.children) : esc4(node.label ?? node.identifier);
+    default:
+      return "";
   }
-  scheduleFlush(ledger, delayMs) {
-    if (ledger.timer !== null) clearTimeout(ledger.timer);
-    ledger.timer = setTimeout(() => {
-      ledger.timer = null;
-      void this.chain(ledger, () => this.flush(ledger)).catch(() => {
-      });
-    }, delayMs);
-    ledger.timer.unref?.();
-  }
-  /**
-   * Spends the reserved final slot on everything withheld, as one message. A combined tail
-   * over the channel's size cap is chunked as usual and only its FIRST chunk is sent — the
-   * rest returns to the tail, to ride the next inbound message's budget rather than a
-   * rejection.
-   */
-  async flush(ledger) {
-    if (ledger.tail.length === 0) return;
-    if (!this.repliable(ledger) || ledger.spent >= QQ_REPLY_BUDGET[ledger.kind]) return;
-    const combined = ledger.tail.join("\n\n");
-    const chunks = ledger.markdown ? chunkMarkdown(combined, MESSAGING_TEXT_CHUNK_CHARS) : chunkMessagingText(combined);
-    const head = chunks[0];
-    if (head === void 0) {
-      ledger.tail = [];
-      return;
+}
+function plainText4(nodes) {
+  return nodes.map((node) => {
+    if (node.type === "text" || node.type === "inlineCode" || node.type === "html") {
+      return esc4(node.value);
     }
-    ledger.tail = chunks.slice(1);
-    try {
-      await this.sendNow(ledger, head, ledger.markdown);
-    } catch (err) {
-      ledger.tail.unshift(head);
-      throw err;
+    if (node.type === "break") return " ";
+    if (node.type === "image") return node.alt ?? "";
+    return "children" in node ? plainText4(node.children) : "";
+  }).join("");
+}
+function renderTable3(node) {
+  const rows = node.children.map(
+    (row) => `| ${row.children.map((cell) => plainText4(cell.children).replaceAll("|", "\\|")).join(" | ")} |`
+  );
+  const header = rows[0];
+  if (header === void 0) return "";
+  const columns = node.children[0]?.children.length ?? 0;
+  return [header, `|${" --- |".repeat(columns)}`, ...rows.slice(1)].join("\n");
+}
+function itemMarker4(list, index) {
+  return list.ordered === true ? `${(list.start ?? 1) + index}. ` : "- ";
+}
+function itemCheckbox4(item) {
+  if (item.checked === true) return "\u2611 ";
+  if (item.checked === false) return "\u2610 ";
+  return "";
+}
+function renderList4(list, indent) {
+  return list.children.map((item, i) => {
+    const head = `${indent}${itemMarker4(list, i)}${itemCheckbox4(item)}`;
+    const parts = [];
+    for (const [j, child] of item.children.entries()) {
+      if (j === 0 && child.type === "paragraph") {
+        parts.push(head + inline4(child.children));
+        continue;
+      }
+      if (child.type === "list") {
+        parts.push(renderList4(child, indent + LIST_INDENT3));
+        continue;
+      }
+      const rendered = block4(child, indent + LIST_INDENT3);
+      if (rendered !== "") {
+        parts.push(
+          rendered.split("\n").map((line) => indent + LIST_INDENT3 + line).join("\n")
+        );
+      }
+    }
+    return parts.filter((part) => part !== "").join("\n");
+  }).filter((line) => line !== "").join("\n");
+}
+function codeFence(value) {
+  return "`".repeat(Math.max(3, longestBacktickRun2(value) + 1));
+}
+function block4(node, indent) {
+  switch (node.type) {
+    case "paragraph":
+      return guardLineStarts3(inline4(node.children));
+    case "heading": {
+      const text = inline4(node.children);
+      return node.depth > MAX_HEADING_DEPTH ? guardLineStarts3(text) : `${"#".repeat(node.depth)} ${text}`;
+    }
+    case "code": {
+      const fence = codeFence(node.value);
+      return `${fence}${node.lang ?? ""}
+${node.value}
+${fence}`;
     }
+    case "blockquote":
+      return node.children.map((child) => block4(child, indent)).filter((rendered) => rendered !== "").join("\n\n").split("\n").map((line) => `> ${line}`).join("\n");
+    case "list":
+      return renderList4(node, indent);
+    case "table":
+      return renderTable3(node);
+    case "thematicBreak":
+      return "---";
+    case "html":
+      return guardLineStarts3(esc4(node.value));
+    case "footnoteDefinition":
+      return `**${esc4(`[^${node.identifier}]`)}** ${node.children.map((child) => block4(child, indent)).join("\n\n")}`;
+    case "definition":
+      return "";
+    default:
+      return "";
+  }
+}
+function wechatMarkdownOf(markdown) {
+  const root = parseMarkdown(markdown);
+  return root.children.map((node) => block4(node, "")).filter((rendered) => rendered !== "").join("\n\n").trim();
+}
+
+// src/runtime/messaging/wechat-api.ts
+import { createCipheriv, createDecipheriv as createDecipheriv2, createHash as createHash2, randomBytes as randomBytes3 } from "crypto";
+var WECHAT_API_BASE = "https://ilinkai.weixin.qq.com";
+var ILINK_APP_ID = "bot";
+var ILINK_CLIENT_VERSION = 1 << 16 | 0 << 8 | 0;
+var BOT_AGENT = "PenguinHarness/1.0";
+var CALL_TIMEOUT_MS4 = 15e3;
+var LONG_POLL_TIMEOUT_MS = 3e4;
+var TRANSFER_TIMEOUT_MS2 = 6e4;
+var DRAIN_TIMEOUT_MS = 5e3;
+var WECHAT_BOT_TYPE = "3";
+var ITEM_TEXT = 1;
+var ITEM_IMAGE = 2;
+var ITEM_VOICE = 3;
+var ITEM_FILE = 4;
+var ITEM_VIDEO = 5;
+var MESSAGE_TYPE_BOT = 2;
+var MESSAGE_STATE_FINISH = 2;
+var UPLOAD_MEDIA_IMAGE = 1;
+var UPLOAD_MEDIA_FILE = 3;
+var AES_KEY_BYTES = 16;
+var WECHAT_VIDEO_FILE_NAME = "video.mp4";
+var WECHAT_STALE_TOKEN_CODE = -14;
+var WeChatApiError = class extends Error {
+  constructor(ret, message, flags = {}) {
+    super(message);
+    this.ret = ret;
+    this.name = "WeChatApiError";
+    this.authenticated = flags.authenticated ?? false;
+    this.timedOut = flags.timedOut ?? false;
   }
+  ret;
   /**
-   * One real send: the next `msg_seq` against the ledger's anchor message, as Markdown when
-   * the binding asked for it and as plain text if the platform refuses that.
+   * The request was ACCEPTED — it authenticated, and the failure came from the call behind
+   * the credential rather than from the credential.
    *
-   * The fallback costs a SLOT here, which it does on no other channel: a repeated
-   * `(msg_id, msg_seq)` pair is refused rather than deduplicated, so the retry must carry a
-   * fresh sequence number and that number is one of the four an inbound message funds. It is
-   * still the right trade — a reply the reader never sees is worse than a reply that spent
-   * an extra slot — but it is only taken while a slot remains, and never for a refusal that
-   * was not about the body in the first place (see QQ_BODY_INDEPENDENT_SEND_CODES): those
-   * would fail identically as text and burn the slot reserved for the withheld tail.
+   * This distinction is the whole of the credential probe: every authenticated endpoint on
+   * this platform shares one auth layer and then does something that needs state a
+   * freshly-bound bot does not have, so the only thing a probe can honestly read is which of
+   * the two layers refused it (see checkCredentials).
    */
-  async sendNow(ledger, text, markdown) {
-    const msgId = ledger.msgId;
-    const bot = ledger.bot;
-    if (msgId === null || bot === null) return;
-    const send = (body) => {
-      ledger.spent += 1;
-      return bot.sendMessage({
-        kind: ledger.kind,
-        openid: ledger.openid,
-        content: text,
-        ...body,
-        msgId,
-        msgSeq: ledger.spent
-      });
-    };
-    if (!markdown) return send({});
-    try {
-      await send({ markdown: qqMarkdownOf(text) });
-      return;
-    } catch (err) {
-      if (!(err instanceof QQApiError)) throw err;
-      if (err.code !== void 0 && QQ_BODY_INDEPENDENT_SEND_CODES.has(err.code)) throw err;
-      if (ledger.spent >= QQ_REPLY_BUDGET[ledger.kind]) throw err;
-    }
-    await send({});
-  }
+  authenticated;
   /**
-   * Appends to the chat's send chain. Two sends against one `msg_id` must reach the
-   * platform in `msg_seq` order, and the chain never rejects — the caller's promise carries
-   * the failure, and one failed send must not poison the chat's later ones.
+   * The request was given up on at a deadline rather than answered or refused. On a long poll
+   * that is the ordinary quiet case and not a failure at all, which is what `getUpdates` reads
+   * it for; nothing else here distinguishes it from a network fault.
    */
-  chain(ledger, run2) {
-    const result = ledger.chain.then(run2);
-    ledger.chain = result.catch(() => {
-    });
-    return result;
-  }
+  timedOut;
 };
-
-// src/runtime/messaging/qq-scan.ts
-import { createDecipheriv, randomBytes as randomBytes2 } from "crypto";
-var QQ_SCAN_BASE = "https://q.qq.com";
-var QQ_SCAN_QR_PAGE = "https://q.qq.com/qqbot/openclaw/connect.html";
-var CALL_TIMEOUT_MS3 = 15e3;
-var QQ_SCAN_POLL_MS = 2e3;
-var QQ_SCAN_KEY_BYTES = 32;
-var GCM_IV_BYTES = 12;
-var GCM_TAG_BYTES = 16;
-function fetchErrorText3(err) {
+function isAbortLike(err) {
+  return err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError");
+}
+function wechatFetchErrorText(err) {
   if (err instanceof Error) {
     if (err.name === "TimeoutError" || err.name === "AbortError") return "request timed out";
     const cause = err.cause;
@@ -7922,108 +8408,623 @@ function fetchErrorText3(err) {
   }
   return String(err);
 }
-function statusOf(raw) {
-  switch (Number(raw)) {
-    case 0:
-      return "none";
-    case 2:
-      return "completed";
-    case 3:
-      return "expired";
-    default:
-      return "pending";
+function randomUin() {
+  return Buffer.from(String(randomBytes3(4).readUInt32BE(0)), "utf8").toString("base64");
+}
+function headersFor(token) {
+  return {
+    "content-type": "application/json",
+    AuthorizationType: "ilink_bot_token",
+    Authorization: `Bearer ${token}`,
+    "X-WECHAT-UIN": randomUin(),
+    "iLink-App-Id": ILINK_APP_ID,
+    "iLink-App-ClientVersion": String(ILINK_CLIENT_VERSION)
+  };
+}
+function baseInfo() {
+  return { channel_version: "1.0.0", bot_agent: BOT_AGENT };
+}
+function endpointUrl(baseUrl, path32) {
+  return `${baseUrl.replace(/\/+$/, "")}/${path32}`;
+}
+function checkEnvelope(label, status, raw) {
+  let body;
+  try {
+    body = JSON.parse(raw);
+  } catch {
+    throw new WeChatApiError(void 0, `${label} failed: HTTP ${status} (unparseable response)`);
+  }
+  const env = body;
+  const code = env.ret !== void 0 && env.ret !== 0 ? env.ret : env.errcode;
+  if (code !== void 0 && code !== 0) {
+    throw new WeChatApiError(code, `${label} failed: ${env.errmsg ?? `code ${code}`}`, {
+      authenticated: code !== WECHAT_STALE_TOKEN_CODE
+    });
   }
+  return body;
 }
-function botsOf(data) {
-  const entries = data === void 0 ? [] : Array.isArray(data) ? data : [data];
-  const bots = [];
-  for (const entry of entries) {
-    const appId = entry.bot_appid;
-    const secret = entry.bot_encrypt_secret;
-    if (appId === void 0 || appId === "" || typeof secret !== "string" || secret === "") {
+function paddedSize(plaintextSize) {
+  return Math.ceil((plaintextSize + 1) / 16) * 16;
+}
+function encryptEcb(plaintext, key) {
+  const cipher = createCipheriv("aes-128-ecb", key, null);
+  return Buffer.concat([cipher.update(plaintext), cipher.final()]);
+}
+function decryptEcb(ciphertext, key) {
+  const decipher = createDecipheriv2("aes-128-ecb", key, null);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+function parseWeChatAesKey(aesKey) {
+  const decoded = Buffer.from(aesKey, "base64");
+  if (decoded.length === AES_KEY_BYTES) return decoded;
+  const ascii = decoded.toString("ascii");
+  if (decoded.length === 32 && /^[0-9a-fA-F]{32}$/.test(ascii)) return Buffer.from(ascii, "hex");
+  throw new Error("wechat media key is neither 16 raw bytes nor 32 hex characters");
+}
+function mediaRefOf(media, aesKeyOverride) {
+  const url = media?.full_url;
+  if (typeof url !== "string" || url === "") return null;
+  const aesKey = typeof aesKeyOverride === "string" && aesKeyOverride !== "" ? Buffer.from(aesKeyOverride, "hex").toString("base64") : media?.aes_key;
+  return { url, ...typeof aesKey === "string" && aesKey !== "" ? { aesKey } : {} };
+}
+function textOf(items) {
+  const parts = [];
+  for (const item of items) {
+    if (item.type === ITEM_TEXT && typeof item.text_item?.text === "string") {
+      const quoted = item.ref_msg;
+      const quotedText = quoted === void 0 ? "" : [quoted.title, quoted.message_item ? textOf([quoted.message_item]) : ""].filter((part) => typeof part === "string" && part !== "").join(" | ");
+      parts.push(
+        quotedText === "" ? item.text_item.text : `[quote: ${quotedText}]
+${item.text_item.text}`
+      );
       continue;
     }
-    bots.push({
-      appId: String(appId),
-      encryptedSecret: secret,
-      ...typeof entry.user_openid === "string" ? { userOpenid: entry.user_openid } : {}
+    if (item.type === ITEM_VOICE && typeof item.voice_item?.text === "string") {
+      parts.push(item.voice_item.text);
+    }
+  }
+  return parts.join("\n").trim();
+}
+function normalizeWeChatMessage(msg) {
+  const userId = msg.from_user_id;
+  if (typeof userId !== "string" || userId === "") return null;
+  if (msg.message_type === MESSAGE_TYPE_BOT) return null;
+  const items = Array.isArray(msg.item_list) ? msg.item_list : [];
+  const images = [];
+  const files = [];
+  for (const item of items) {
+    if (item.type === ITEM_IMAGE) {
+      const ref = mediaRefOf(item.image_item?.media, item.image_item?.aeskey);
+      if (ref !== null) images.push(ref);
+    } else if (item.type === ITEM_FILE) {
+      const ref = mediaRefOf(item.file_item?.media);
+      const name = item.file_item?.file_name;
+      if (ref !== null)
+        files.push({ fileName: name !== void 0 && name !== "" ? name : "file", media: ref });
+    } else if (item.type === ITEM_VIDEO) {
+      const ref = mediaRefOf(item.video_item?.media);
+      if (ref !== null) files.push({ fileName: WECHAT_VIDEO_FILE_NAME, media: ref });
+    }
+  }
+  const messageId = msg.message_id;
+  return {
+    userId,
+    messageId: messageId === void 0 ? "" : String(messageId),
+    text: textOf(items),
+    ...typeof msg.context_token === "string" && msg.context_token !== "" ? { contextToken: msg.context_token } : {},
+    images,
+    files
+  };
+}
+function createWeChatTransport() {
+  return {
+    createClient(creds) {
+      const post = async (path32, payload, opts) => {
+        const url = endpointUrl(creds.baseUrl, path32);
+        let res;
+        try {
+          res = await fetch(url, {
+            method: "POST",
+            headers: headersFor(creds.botToken),
+            body: JSON.stringify({ ...payload, base_info: baseInfo() }),
+            signal: opts.signal ?? AbortSignal.timeout(opts.timeoutMs)
+          });
+        } catch (err) {
+          throw new WeChatApiError(
+            void 0,
+            `${opts.label} failed: ${wechatFetchErrorText(err)}`,
+            {
+              timedOut: isAbortLike(err)
+            }
+          );
+        }
+        const raw = await res.text().catch(() => "");
+        if (!res.ok) {
+          throw new WeChatApiError(
+            void 0,
+            `${opts.label} failed: HTTP ${res.status}${raw === "" ? "" : ` ${raw.slice(0, 300)}`}`
+          );
+        }
+        return checkEnvelope(opts.label, res.status, raw);
+      };
+      const sendItem = async (args, item, label) => {
+        await post(
+          "ilink/bot/sendmessage",
+          {
+            msg: {
+              from_user_id: "",
+              to_user_id: args.userId,
+              client_id: randomBytes3(16).toString("hex"),
+              message_type: MESSAGE_TYPE_BOT,
+              message_state: MESSAGE_STATE_FINISH,
+              item_list: [item],
+              ...args.contextToken !== void 0 ? { context_token: args.contextToken } : {}
+            }
+          },
+          { timeoutMs: CALL_TIMEOUT_MS4, label }
+        );
+      };
+      const upload = async (userId, file, mediaType, label) => {
+        const aesKey = randomBytes3(AES_KEY_BYTES);
+        const rawSize = file.data.length;
+        const cipherSize = paddedSize(rawSize);
+        const filekey = randomBytes3(AES_KEY_BYTES).toString("hex");
+        const handle = await post(
+          "ilink/bot/getuploadurl",
+          {
+            filekey,
+            media_type: mediaType,
+            to_user_id: userId,
+            rawsize: rawSize,
+            rawfilemd5: createHash2("md5").update(file.data).digest("hex"),
+            filesize: cipherSize,
+            no_need_thumb: true,
+            aeskey: aesKey.toString("hex")
+          },
+          { timeoutMs: CALL_TIMEOUT_MS4, label: `${label} upload handle` }
+        );
+        const uploadUrl = handle.upload_full_url;
+        if (typeof uploadUrl !== "string" || uploadUrl.trim() === "") {
+          throw new WeChatApiError(void 0, `${label} failed: the upload URL was not returned`);
+        }
+        let res;
+        try {
+          res = await fetch(uploadUrl.trim(), {
+            method: "POST",
+            headers: { "content-type": "application/octet-stream" },
+            body: new Uint8Array(encryptEcb(file.data, aesKey)),
+            signal: AbortSignal.timeout(TRANSFER_TIMEOUT_MS2)
+          });
+        } catch (err) {
+          throw new WeChatApiError(void 0, `${label} failed: ${wechatFetchErrorText(err)}`);
+        }
+        if (!res.ok) {
+          const detail = res.headers.get("x-error-message") ?? `HTTP ${res.status}`;
+          throw new WeChatApiError(void 0, `${label} failed: ${detail}`);
+        }
+        const param = res.headers.get("x-encrypted-param");
+        if (param === null || param === "") {
+          throw new WeChatApiError(
+            void 0,
+            `${label} failed: the CDN returned no download handle`
+          );
+        }
+        return { param, aesKey, rawSize, cipherSize };
+      };
+      return {
+        async checkCredentials() {
+          try {
+            await post(
+              "ilink/bot/getconfig",
+              { ilink_user_id: creds.userId },
+              { timeoutMs: CALL_TIMEOUT_MS4, label: "wechat credential check" }
+            );
+          } catch (err) {
+            if (err instanceof WeChatApiError && err.authenticated) return;
+            throw err;
+          }
+        },
+        async getUpdates({ cursor, signal, drain = false }) {
+          const windowMs = drain ? DRAIN_TIMEOUT_MS : LONG_POLL_TIMEOUT_MS;
+          let body;
+          try {
+            body = await post(
+              "ilink/bot/getupdates",
+              { get_updates_buf: cursor },
+              {
+                timeoutMs: windowMs,
+                signal: AbortSignal.any([signal, AbortSignal.timeout(windowMs)]),
+                label: "wechat getUpdates"
+              }
+            );
+          } catch (err) {
+            if (signal.aborted) throw err;
+            if (err instanceof WeChatApiError && err.timedOut) {
+              return { messages: [], cursor, timedOut: true };
+            }
+            throw err;
+          }
+          const raw = Array.isArray(body.msgs) ? body.msgs : [];
+          const messages = [];
+          for (const msg of raw) {
+            const evt = normalizeWeChatMessage(msg);
+            if (evt !== null) messages.push(evt);
+          }
+          const next = body.get_updates_buf;
+          return {
+            messages,
+            cursor: typeof next === "string" && next !== "" ? next : cursor,
+            timedOut: false
+          };
+        },
+        sendText(args) {
+          return sendItem(args, { type: ITEM_TEXT, text_item: { text: args.text } }, "wechat send");
+        },
+        async sendImage(args) {
+          const { param, aesKey, cipherSize } = await upload(
+            args.userId,
+            args.file,
+            UPLOAD_MEDIA_IMAGE,
+            "wechat image send"
+          );
+          if (args.text !== "") await this.sendText(args);
+          await sendItem(
+            args,
+            {
+              type: ITEM_IMAGE,
+              image_item: {
+                media: {
+                  encrypt_query_param: param,
+                  aes_key: aesKey.toString("base64"),
+                  encrypt_type: 1
+                },
+                mid_size: cipherSize
+              }
+            },
+            "wechat image send"
+          );
+        },
+        async sendFile(args) {
+          const { param, aesKey, rawSize } = await upload(
+            args.userId,
+            args.file,
+            UPLOAD_MEDIA_FILE,
+            "wechat file send"
+          );
+          if (args.text !== "") await this.sendText(args);
+          await sendItem(
+            args,
+            {
+              type: ITEM_FILE,
+              file_item: {
+                media: {
+                  encrypt_query_param: param,
+                  aes_key: aesKey.toString("base64"),
+                  encrypt_type: 1
+                },
+                file_name: args.file.fileName,
+                // Plaintext length: the receiving client shows it, and the ciphertext is
+                // one padding block longer than what the user actually gets.
+                len: String(rawSize)
+              }
+            },
+            "wechat file send"
+          );
+        },
+        async fetchMedia(ref, maxBytes, what) {
+          let res;
+          try {
+            res = await fetch(ref.url, { signal: AbortSignal.timeout(TRANSFER_TIMEOUT_MS2) });
+          } catch (err) {
+            throw new Error(`${what} could not be downloaded: ${wechatFetchErrorText(err)}`);
+          }
+          if (!res.ok) throw new Error(`${what} could not be downloaded: HTTP ${res.status}`);
+          if (res.body === null) throw new Error(`${what} could not be downloaded: empty response`);
+          const bytes = await collectUnderCap(
+            res.body,
+            maxBytes,
+            what
+          );
+          if (ref.aesKey === void 0) return bytes;
+          try {
+            return decryptEcb(bytes, parseWeChatAesKey(ref.aesKey));
+          } catch (err) {
+            if (err instanceof MessagingMediaTooLargeError) throw err;
+            throw new Error(`${what} arrived but could not be decrypted`);
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/runtime/messaging/wechat-connector.ts
+var DRAIN_ATTEMPTS = 2;
+function wechatRetryDelayMs(failures) {
+  return Math.min(2e3 * 2 ** Math.max(0, failures - 1), 6e4);
+}
+function wechatConfigOf(config) {
+  const { botId, botToken, baseUrl, userId } = config;
+  if (typeof botId !== "string" || botId === "" || typeof botToken !== "string" || botToken === "") {
+    throw new Error("malformed wechat binding config (botId/botToken)");
+  }
+  return {
+    botId,
+    botToken,
+    // A document written before the platform named a host, or by a scan whose answer carried
+    // none, polls the default entry host — which is where a bot without an IDC assignment
+    // lives anyway.
+    baseUrl: typeof baseUrl === "string" && baseUrl !== "" ? baseUrl : WECHAT_API_BASE,
+    userId: typeof userId === "string" ? userId : ""
+  };
+}
+function credsOf(config) {
+  const { botId, botToken, baseUrl, userId } = wechatConfigOf(config);
+  return { botId, botToken, baseUrl, userId };
+}
+function inboundOf(bot, evt) {
+  const images = evt.images.map((ref) => ({
+    fetch: async (maxBytes) => {
+      const data = await bot.fetchMedia(ref, maxBytes, "The image");
+      return { data, mimeType: sniffImageMime(data) ?? "image/png" };
+    }
+  }));
+  const files = evt.files.map((file) => ({
+    fileName: file.fileName,
+    fetch: (maxBytes) => bot.fetchMedia(file.media, maxBytes, "The file")
+  }));
+  return {
+    // The sender IS the chat on this channel: a bot conversation is one-to-one, and the id
+    // that arrives is the one a send is addressed to.
+    chatId: evt.userId,
+    chatKind: "direct",
+    // The reply anchor carries the chat, as it does on every channel whose message ids are
+    // not globally unique — and the id must identify the MESSAGE rather than the delivery,
+    // because it is also the bridge's dedupe key.
+    messageId: evt.messageId === "" ? "" : `${evt.userId}:${evt.messageId}`,
+    text: evt.text !== "" ? evt.text : null,
+    ...images.length > 0 ? { images } : {},
+    ...files.length > 0 ? { files } : {}
+  };
+}
+function chatOfWeChatReplyRef(ref) {
+  const cut = ref.lastIndexOf(":");
+  if (cut <= 0) throw new Error(`malformed wechat reply ref "${ref}"`);
+  return ref.slice(0, cut);
+}
+var WeChatConnector = class {
+  constructor(transport, opts = {}) {
+    this.transport = transport;
+    this.retryDelayMs = opts.retryDelayMs ?? wechatRetryDelayMs;
+  }
+  transport;
+  channel = "wechat";
+  /**
+   * The most recent context token per `(botId, userId)`.
+   *
+   * On the connector rather than on a client because the two halves that need it arrive
+   * separately: tokens come in through `connect`, and sends go out through the client
+   * `createClient` hands the bridge. The bot is part of the key so two bindings on different
+   * bots can never spend each other's conversation handles.
+   */
+  contextTokens = /* @__PURE__ */ new Map();
+  retryDelayMs;
+  async createClient(config) {
+    const creds = credsOf(config);
+    const bot = this.transport.createClient(creds);
+    const args = (userId, text, opts) => {
+      const contextToken = this.contextTokens.get(this.tokenKey(creds.botId, userId));
+      return {
+        userId,
+        text: opts?.markdown === true ? wechatMarkdownOf(text) : text,
+        ...contextToken !== void 0 ? { contextToken } : {}
+      };
+    };
+    return {
+      async checkCredentials() {
+        await bot.checkCredentials();
+        return null;
+      },
+      sendText: (chatId, text, opts) => bot.sendText(args(chatId, text, opts)),
+      // The same operation as sendText: this channel has no quote relation to thread onto
+      // (see the module doc), so the anchor is read only for the chat it names.
+      replyText: (ref, text, opts) => bot.sendText(args(chatOfWeChatReplyRef(ref), text, opts)),
+      sendImage: (chatId, file) => (
+        // The caption is empty because the bridge sends a reply's text as its own message:
+        // a picture here is the picture, and pairing it would duplicate what already went.
+        bot.sendImage({ ...args(chatId, ""), file })
+      ),
+      sendFile: (chatId, file) => bot.sendFile({ ...args(chatId, ""), file })
+    };
+  }
+  async connect(config, handlers) {
+    const creds = credsOf(config);
+    const bot = this.transport.createClient(creds);
+    const abort = new AbortController();
+    let closed = false;
+    void this.poll(creds, bot, handlers, abort.signal, () => closed);
+    return {
+      close: () => {
+        closed = true;
+        abort.abort();
+        this.dropTokens(creds.botId);
+      }
+    };
+  }
+  tokenKey(botId, userId) {
+    return `${botId}:${userId}`;
+  }
+  /** Forgets every conversation handle of one bot — the connection's close (see connect). */
+  dropTokens(botId) {
+    const prefix = `${botId}:`;
+    for (const key of this.contextTokens.keys()) {
+      if (key.startsWith(prefix)) this.contextTokens.delete(key);
+    }
+  }
+  async poll(creds, bot, handlers, signal, isClosed) {
+    let ready = false;
+    let drained = false;
+    let drainAttempts = 0;
+    let failures = 0;
+    let cursor = "";
+    while (!isClosed()) {
+      try {
+        if (!ready) {
+          await bot.checkCredentials();
+          if (isClosed()) return;
+          ready = true;
+          handlers.onReady?.();
+        }
+        const {
+          messages,
+          cursor: next,
+          timedOut
+        } = await bot.getUpdates({
+          cursor,
+          signal,
+          ...drained ? {} : { drain: true }
+        });
+        if (isClosed()) return;
+        cursor = next;
+        if (!drained) {
+          if (!timedOut || ++drainAttempts >= DRAIN_ATTEMPTS) drained = true;
+          continue;
+        }
+        failures = 0;
+        for (const evt of messages) {
+          if (isClosed()) return;
+          if (evt.contextToken !== void 0) {
+            this.contextTokens.set(this.tokenKey(creds.botId, evt.userId), evt.contextToken);
+          }
+          await handlers.onMessage(inboundOf(bot, evt));
+        }
+      } catch (err) {
+        if (isClosed()) return;
+        ready = false;
+        failures += 1;
+        if (failures === 1) handlers.onError?.(err);
+        await this.sleep(this.retryDelayMs(failures), signal);
+      }
+    }
+  }
+  /** A backoff that a close ends immediately rather than after its full delay. */
+  sleep(ms, signal) {
+    if (ms <= 0 || signal.aborted) return Promise.resolve();
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      const onAbort = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
     });
   }
-  return bots;
+};
+
+// src/runtime/messaging/wechat-scan.ts
+import { randomBytes as randomBytes4 } from "crypto";
+var CREATE_TIMEOUT_MS = 15e3;
+var POLL_TIMEOUT_MS = 8e3;
+var WECHAT_SCAN_POLL_MS = 2e3;
+function statusOf2(raw) {
+  switch (raw) {
+    case "confirmed":
+      return "completed";
+    case "scaned":
+    // A redirect is a scan that must continue against another host: the person has scanned,
+    // which is what they need told, and the host switch is the caller's business.
+    case "scaned_but_redirect":
+      return "scanned";
+    case "need_verifycode":
+      return "need_verify_code";
+    case "verify_code_blocked":
+      return "blocked";
+    case "expired":
+      return "expired";
+    case "binded_redirect":
+      return "already_bound";
+    default:
+      return "pending";
+  }
 }
-function createQQScanTransport(base = QQ_SCAN_BASE) {
-  const post = async (path32, payload) => {
-    let res;
-    try {
-      res = await fetch(`${base}${path32}`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify(payload),
-        signal: AbortSignal.timeout(CALL_TIMEOUT_MS3)
-      });
-    } catch (err) {
-      throw new Error(`QQ scan request failed: ${fetchErrorText3(err)}`);
-    }
-    const body = await res.json().catch(() => null);
-    if (body === null || body.retcode !== void 0 && body.retcode !== 0) {
-      const detail = body?.msg ?? `HTTP ${res.status}`;
-      const code = body?.retcode !== void 0 ? ` (retcode ${body.retcode})` : "";
-      throw new Error(`QQ scan request failed: ${detail}${code}`);
-    }
-    return body.data;
-  };
+function createWeChatScanTransport(base = WECHAT_API_BASE) {
+  const headers = () => ({
+    "iLink-App-Id": "bot",
+    "iLink-App-ClientVersion": String(1 << 16 | 0)
+  });
   return {
-    async createBindTask(key) {
-      const data = await post("/lite/create_bind_task", { key });
-      const taskId = data?.task_id;
-      if (typeof taskId !== "string" || taskId === "") {
-        throw new Error("QQ scan request failed: no task id was returned");
+    async createQrCode() {
+      let res;
+      try {
+        res = await fetch(
+          `${base}/ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(WECHAT_BOT_TYPE)}`,
+          {
+            method: "POST",
+            headers: { ...headers(), "content-type": "application/json" },
+            // The platform takes the tokens this client already holds so it can recognize a
+            // rebind of a bot it has already issued one for. Nothing here offers them: a
+            // stored token is another Session's credential, and the `already_bound` answer
+            // this would enable is not worth handing one binding's secret to another's flow.
+            body: JSON.stringify({ local_token_list: [] }),
+            signal: AbortSignal.timeout(CREATE_TIMEOUT_MS)
+          }
+        );
+      } catch (err) {
+        throw new Error(`WeChat scan request failed: ${wechatFetchErrorText(err)}`);
       }
-      return taskId;
+      if (!res.ok) throw new Error(`WeChat scan request failed: HTTP ${res.status}`);
+      const body = await res.json().catch(() => null);
+      const qrcode = body?.qrcode;
+      const qrUrl = body?.qrcode_img_content;
+      if (typeof qrcode !== "string" || qrcode === "" || typeof qrUrl !== "string" || qrUrl === "") {
+        throw new Error("WeChat scan request failed: no QR code was returned");
+      }
+      return { qrcode, qrUrl };
     },
-    async pollBindResult(taskId) {
-      const data = await post("/lite/poll_bind_result", {
-        task_id: taskId
-      });
-      const first = Array.isArray(data) ? data[0] : data;
-      return { status: statusOf(first?.status), bots: botsOf(data) };
+    async pollQrStatus({ baseUrl, qrcode, verifyCode }) {
+      const query = new URLSearchParams({ qrcode });
+      if (verifyCode !== void 0 && verifyCode !== "") query.set("verify_code", verifyCode);
+      let res;
+      try {
+        res = await fetch(`${baseUrl}/ilink/bot/get_qrcode_status?${query.toString()}`, {
+          headers: headers(),
+          signal: AbortSignal.timeout(POLL_TIMEOUT_MS)
+        });
+      } catch (err) {
+        if (err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError")) {
+          return { status: "pending" };
+        }
+        throw new Error(`WeChat scan request failed: ${wechatFetchErrorText(err)}`);
+      }
+      if (!res.ok) throw new Error(`WeChat scan request failed: HTTP ${res.status}`);
+      const body = await res.json().catch(() => null);
+      const status = statusOf2(body?.status);
+      const redirect = typeof body?.redirect_host === "string" && body.redirect_host !== "" ? { redirectHost: body.redirect_host } : {};
+      if (status !== "completed") return { status, ...redirect };
+      const botId = body?.ilink_bot_id;
+      const botToken = body?.bot_token;
+      if (typeof botId !== "string" || botId === "" || typeof botToken !== "string" || botToken === "") {
+        throw new Error("WeChat reported the scan confirmed but returned no credentials");
+      }
+      return {
+        status: "completed",
+        bot: {
+          botId,
+          botToken,
+          baseUrl: typeof body?.baseurl === "string" && body.baseurl !== "" ? body.baseurl : WECHAT_API_BASE,
+          userId: typeof body?.ilink_user_id === "string" ? body.ilink_user_id : ""
+        }
+      };
     }
   };
 }
-function newQQScanKey() {
-  return randomBytes2(QQ_SCAN_KEY_BYTES).toString("base64");
-}
-function qqScanQrUrl(taskId, source = "") {
-  return `${QQ_SCAN_QR_PAGE}?task_id=${encodeURIComponent(taskId)}&source=${encodeURIComponent(source)}&_wv=2`;
-}
-function decryptQQBotSecret(keyBase64, encryptedBase64) {
-  const key = Buffer.from(keyBase64, "base64");
-  const payload = Buffer.from(encryptedBase64, "base64");
-  if (key.length !== QQ_SCAN_KEY_BYTES) {
-    throw new Error("QQ scan key is not a 32-byte AES key");
-  }
-  if (payload.length <= GCM_IV_BYTES + GCM_TAG_BYTES) {
-    throw new Error("QQ scan payload is too short to contain an encrypted secret");
-  }
-  const iv = payload.subarray(0, GCM_IV_BYTES);
-  const tag = payload.subarray(payload.length - GCM_TAG_BYTES);
-  const ciphertext = payload.subarray(GCM_IV_BYTES, payload.length - GCM_TAG_BYTES);
-  const decipher = createDecipheriv("aes-256-gcm", key, iv);
-  decipher.setAuthTag(tag);
-  let plaintext;
-  try {
-    plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-  } catch {
-    throw new Error("QQ scan result could not be decrypted");
-  }
-  const secret = plaintext.toString("utf8");
-  if (secret === "") throw new Error("QQ scan result decrypted to an empty secret");
-  return secret;
-}
-var QQ_SCAN_TASK_TTL_MS = 10 * 6e4;
-var QQ_SCAN_MAX_TASKS_PER_SESSION = 4;
-var QQ_SCAN_MAX_TASKS = 4096;
-var QQScanService = class {
+var WECHAT_SCAN_TASK_TTL_MS = 10 * 6e4;
+var WECHAT_SCAN_MAX_TASKS_PER_SESSION = 4;
+var WECHAT_SCAN_MAX_TASKS = 4096;
+var WeChatScanService = class {
   constructor(transport, opts = {}) {
     this.transport = transport;
     this.now = opts.now ?? (() => Date.now());
@@ -8033,51 +9034,77 @@ var QQScanService = class {
   now;
   /** The self-re-arming sweep, alive only while a task is remembered (see `armSweep`). */
   sweepTimer = null;
-  /** Starts a scan: a fresh key, a task registered under it, and the URL for the QR. */
+  /** Starts a scan: a fresh code, a task registered under a handle of this module's own. */
   async start(sessionId) {
     this.sweep();
-    const key = newQQScanKey();
-    const taskId = await this.transport.createBindTask(key);
+    const { qrcode, qrUrl } = await this.transport.createQrCode();
     this.evictOwn(sessionId);
-    this.tasks.set(taskId, { key, sessionId, createdAt: this.now(), claimed: false });
+    const taskId = randomBytes4(16).toString("hex");
+    this.tasks.set(taskId, {
+      qrcode,
+      sessionId,
+      createdAt: this.now(),
+      polling: false,
+      baseUrl: WECHAT_API_BASE
+    });
     this.armSweep();
-    return { taskId, qrUrl: qqScanQrUrl(taskId), pollMs: QQ_SCAN_POLL_MS };
+    return { taskId, qrUrl, pollMs: WECHAT_SCAN_POLL_MS };
   }
   /**
-   * Polls one task. Returns null when the task id is not one this Session started (an
-   * unknown id, another Session's, one already consumed, or one another poll is resolving
-   * right now) — the caller answers 404, which is also what a replay gets.
+   * Records the pairing code the person read off their phone. It rides the NEXT poll rather
+   * than a request of its own: the platform takes it as a parameter of the status call, and
+   * there is no separate submit.
+   *
+   * Returns false for a task this Session did not start, which the caller answers with the
+   * same 404 an unknown poll gets.
+   */
+  submitVerifyCode(sessionId, taskId, verifyCode) {
+    const task = this.tasks.get(taskId);
+    if (task === void 0 || task.sessionId !== sessionId) return false;
+    task.verifyCode = verifyCode;
+    return true;
+  }
+  /**
+   * Polls one task. Returns null when the task id is not one this Session started — an
+   * unknown id, another Session's, or one already resolved — which the caller answers 404,
+   * and which is also what a replay gets.
    */
   async poll(sessionId, taskId) {
     const task = this.tasks.get(taskId);
-    if (task === void 0 || task.sessionId !== sessionId || task.claimed) return null;
-    task.claimed = true;
-    if (this.now() - task.createdAt > QQ_SCAN_TASK_TTL_MS) {
+    if (task === void 0 || task.sessionId !== sessionId) return null;
+    if (this.now() - task.createdAt > WECHAT_SCAN_TASK_TTL_MS) {
       this.tasks.delete(taskId);
       return { status: "expired" };
     }
+    if (task.polling) return { status: "pending" };
+    task.polling = true;
     let result;
     try {
-      result = await this.transport.pollBindResult(taskId);
+      result = await this.transport.pollQrStatus({
+        baseUrl: task.baseUrl,
+        qrcode: task.qrcode,
+        ...task.verifyCode !== void 0 ? { verifyCode: task.verifyCode } : {}
+      });
     } catch (err) {
-      task.claimed = false;
+      task.polling = false;
       throw err;
+    } finally {
+      task.polling = false;
     }
-    if (result.status === "expired") {
-      this.tasks.delete(taskId);
-      return { status: "expired" };
+    if (result.redirectHost !== void 0) task.baseUrl = `https://${result.redirectHost}`;
+    if (result.status === "scanned" && task.verifyCode !== void 0) {
+      task.verifyCode = void 0;
     }
-    if (result.status !== "completed") {
-      task.claimed = false;
+    if (result.status === "expired" || result.status === "blocked" || result.status === "already_bound") {
+      this.tasks.delete(taskId);
       return { status: result.status };
     }
+    if (result.status !== "completed") return { status: result.status };
     this.tasks.delete(taskId);
-    const bot = result.bots[0];
-    if (bot === void 0) {
-      throw new Error("QQ reported the scan complete but returned no bot");
+    if (result.bot === void 0) {
+      throw new Error("WeChat reported the scan confirmed but returned no credentials");
     }
-    const appSecret = decryptQQBotSecret(task.key, bot.encryptedSecret);
-    return { status: "completed", bot: { appId: bot.appId, appSecret } };
+    return { status: "completed", bot: result.bot };
   }
   /** Drops a task the user walked away from (the editor's cancel, and its unmount). */
   cancel(sessionId, taskId) {
@@ -8089,37 +9116,31 @@ var QQScanService = class {
       if (task.sessionId === sessionId) this.tasks.delete(taskId);
     }
   }
-  /**
-   * Drops this Session's oldest tasks until one more fits under its own ceiling. Scoped to
-   * the caller: the whole point of the per-Session ceiling is that filling it takes a code
-   * away from nobody else.
-   */
+  /** Drops this Session's oldest tasks until one more fits under its own ceiling. */
   evictOwn(sessionId) {
     const own = [...this.tasks].filter(([, task]) => task.sessionId === sessionId);
-    if (own.length < QQ_SCAN_MAX_TASKS_PER_SESSION) return;
+    if (own.length < WECHAT_SCAN_MAX_TASKS_PER_SESSION) return;
     own.sort((a, b) => a[1].createdAt - b[1].createdAt);
-    for (const [taskId] of own.slice(0, own.length - QQ_SCAN_MAX_TASKS_PER_SESSION + 1)) {
+    for (const [taskId] of own.slice(0, own.length - WECHAT_SCAN_MAX_TASKS_PER_SESSION + 1)) {
       this.tasks.delete(taskId);
     }
   }
   /** Drops expired tasks, then the oldest ones if the table is still over its backstop. */
   sweep() {
-    const cutoff = this.now() - QQ_SCAN_TASK_TTL_MS;
+    const cutoff = this.now() - WECHAT_SCAN_TASK_TTL_MS;
     for (const [taskId, task] of this.tasks) {
       if (task.createdAt <= cutoff) this.tasks.delete(taskId);
     }
-    if (this.tasks.size < QQ_SCAN_MAX_TASKS) return;
+    if (this.tasks.size < WECHAT_SCAN_MAX_TASKS) return;
     const byAge = [...this.tasks].sort((a, b) => a[1].createdAt - b[1].createdAt);
-    for (const [taskId] of byAge.slice(0, this.tasks.size - QQ_SCAN_MAX_TASKS + 1)) {
+    for (const [taskId] of byAge.slice(0, this.tasks.size - WECHAT_SCAN_MAX_TASKS + 1)) {
       this.tasks.delete(taskId);
     }
   }
   /**
    * Keeps one unref'd timer alive while any task is remembered, so a scan the user walked
-   * away from stops holding its key roughly at the TTL instead of at whenever somebody
-   * happens to start the next scan — which may be never, and a key at rest is the one
-   * outcome this module is shaped to avoid. It re-arms only while the table is non-empty,
-   * and unref'd it is never the reason a process stays alive.
+   * away from stops holding its handle roughly at the TTL instead of at whenever somebody
+   * happens to start the next scan — which may be never.
    */
   armSweep() {
     if (this.sweepTimer !== null || this.tasks.size === 0) return;
@@ -8127,7 +9148,7 @@ var QQScanService = class {
       this.sweepTimer = null;
       this.sweep();
       this.armSweep();
-    }, QQ_SCAN_TASK_TTL_MS);
+    }, WECHAT_SCAN_TASK_TTL_MS);
     timer.unref();
     this.sweepTimer = timer;
   }
@@ -8267,7 +9288,7 @@ function isAttachmentLine(line) {
 }
 
 // src/services/ids.ts
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes5 } from "crypto";
 var SEMANTIC_ID_PATTERN = /^[a-z][a-z0-9_]{1,63}$/;
 var USERNAME_PATTERN = /^[a-z][a-z0-9_]{1,31}$/;
 var PROJECT_SUFFIX_PATTERN = /^[a-z0-9_]+$/;
@@ -8356,9 +9377,9 @@ var AdminService = class {
 };
 
 // src/services/desktop-service.ts
-import { createHash as createHash2, timingSafeEqual } from "crypto";
+import { createHash as createHash3, timingSafeEqual } from "crypto";
 function digest(value) {
-  return createHash2("sha256").update(value).digest();
+  return createHash3("sha256").update(value).digest();
 }
 var DesktopService = class {
   tokenDigest;
@@ -8744,6 +9765,24 @@ function asArray(v) {
 function optNum(v) {
   return typeof v === "number" && Number.isFinite(v) ? v : void 0;
 }
+function tieredRates(provider, modelId, rates) {
+  const entry = catalogEntryFor(provider, modelId);
+  const schedule = entry?.offPeakDiscount;
+  if (schedule === void 0 || entry?.pricing === void 0)
+    return { peak: rates, offPeak: rates };
+  const peak = entry.pricing;
+  const untouched = rates.cacheRead === peak.cache_read && rates.cacheWrite === peak.cache_write && rates.output === peak.output;
+  if (!untouched) return { peak: rates, offPeak: rates };
+  const off = (v) => Math.round(v * (1 - schedule.rate) * 1e6) / 1e6;
+  return {
+    peak: rates,
+    offPeak: {
+      cacheRead: off(rates.cacheRead),
+      cacheWrite: off(rates.cacheWrite),
+      output: off(rates.output)
+    }
+  };
+}
 function optStr(v) {
   return typeof v === "string" && v !== "" ? v : void 0;
 }
@@ -8971,14 +10010,14 @@ var ProjectConfigService = class {
    */
   async setChatDefaults(projectId, req) {
     const raw = await this.readRaw(projectId);
-    const block4 = {
+    const block5 = {
       ...req.agentId !== void 0 ? { agent_id: req.agentId } : {},
       ...req.workspace !== void 0 ? { workspace: req.workspace } : {},
       ...req.approvalMode !== void 0 ? { approval_mode: req.approvalMode } : {},
       ...req.thinkingLevel !== void 0 ? { thinking_level: req.thinkingLevel } : {}
     };
     const next = { ...raw };
-    if (Object.keys(block4).length > 0) next.default_chat = block4;
+    if (Object.keys(block5).length > 0) next.default_chat = block5;
     else delete next.default_chat;
     await this.writeRaw(projectId, next);
     return this.getChatDefaults(projectId);
@@ -9010,15 +10049,15 @@ var ProjectConfigService = class {
    */
   async setCommandPolicy(projectId, req) {
     const raw = await this.readRaw(projectId);
-    const block4 = {};
-    if (req.enabled === false) block4.enabled = false;
-    block4.rules = req.rules.map((r) => ({
+    const block5 = {};
+    if (req.enabled === false) block5.enabled = false;
+    block5.rules = req.rules.map((r) => ({
       name: r.name,
       pattern: r.pattern,
       ...r.description !== void 0 && r.description !== "" ? { description: r.description } : {},
       ...r.enabled === false ? { enabled: false } : {}
     }));
-    await this.writeRaw(projectId, { ...raw, command_policy: block4 });
+    await this.writeRaw(projectId, { ...raw, command_policy: block5 });
     return this.getCommandPolicy(projectId);
   }
   /** Pricing lookup for usage-recorder: the current pricing for this paired reference (undefined if none -> cost is NULL). */
@@ -9032,7 +10071,8 @@ var ProjectConfigService = class {
     if (cacheRead === void 0 && cacheWrite === void 0 && output === void 0) {
       return void 0;
     }
-    return { cacheRead: cacheRead ?? 0, cacheWrite: cacheWrite ?? 0, output: output ?? 0 };
+    const rates = { cacheRead: cacheRead ?? 0, cacheWrite: cacheWrite ?? 0, output: output ?? 0 };
+    return tieredRates(provider, modelId, rates);
   }
   /**
    * Model connectivity test: the model reference `(provider, modelId)` is submitted
@@ -9263,7 +10303,7 @@ var ProjectConfigService = class {
       const vision = typeof m.vision === "boolean" ? m.vision : cat?.supportsVision;
       const maxTokens = optNum(m.max_tokens);
       const fastMode = m.fast_mode === true ? true : void 0;
-      const displayName = optStr(m.display_name) ?? cat?.displayName;
+      const displayName = m.display_name === "" ? void 0 : optStr(m.display_name) ?? cat?.displayName;
       const apiKey = optStr(m.api_key);
       const credBaseUrl = optStr(m.base_url);
       const createdAt = optStr(m.created_at);
@@ -9348,6 +10388,8 @@ var ProjectConfigService = class {
       const catNew = catalogEntryFor(entry.provider, entry.modelId);
       if (entry.displayName && entry.displayName !== catNew?.displayName) {
         next2.display_name = entry.displayName;
+      } else if (!entry.displayName && catNew?.displayName !== void 0) {
+        next2.display_name = "";
       }
       if (entry.contextWindow !== void 0) next2.context_window = entry.contextWindow;
       if (entry.clientType) next2.client_type = canonicalClientType(entry.clientType);
@@ -11042,7 +12084,7 @@ var BenchmarkService = class {
 };
 
 // src/services/snapshot-service.ts
-import { randomBytes as randomBytes4 } from "crypto";
+import { randomBytes as randomBytes6 } from "crypto";
 import fs14 from "fs/promises";
 import path12 from "path";
 import * as tar from "tar";
@@ -11088,7 +12130,7 @@ var SnapshotService = class {
     } catch {
     }
     await fs14.mkdir(dir, { recursive: true });
-    const tmp = `${file}.tmp-${randomBytes4(4).toString("hex")}`;
+    const tmp = `${file}.tmp-${randomBytes6(4).toString("hex")}`;
     await tar.create(
       {
         gzip: true,
@@ -11121,7 +12163,7 @@ var SnapshotService = class {
   async importArchive(projectId, agentId, archive, opts) {
     const current2 = await this.currentVersion(projectId, agentId);
     const base = agentDir2(this.root, projectId, agentId);
-    const staging = path12.join(base, `.import-${randomBytes4(6).toString("hex")}`);
+    const staging = path12.join(base, `.import-${randomBytes6(6).toString("hex")}`);
     await fs14.mkdir(staging, { recursive: true });
     try {
       const archiveFile = path12.join(staging, "archive.tar.gz");
@@ -11188,7 +12230,7 @@ var SnapshotService = class {
 };
 
 // src/services/model-oauth-service.ts
-import { createHash as createHash3, randomBytes as randomBytes5, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash4, randomBytes as randomBytes7, randomUUID as randomUUID4 } from "crypto";
 import { APP_URL, providerInfo as providerInfo2 } from "@prismshadow/penguin-core/model-catalog";
 var FLOW_TTL_MS = 10 * 60 * 1e3;
 var MAX_FLOWS_PER_OWNER = 8;
@@ -11196,7 +12238,7 @@ function createVerifier() {
   return `${randomUUID4()}${randomUUID4()}`;
 }
 function codeChallenge(verifier) {
-  return createHash3("sha256").update(verifier, "utf8").digest("base64url");
+  return createHash4("sha256").update(verifier, "utf8").digest("base64url");
 }
 function buildAuthorizeUrl(input) {
   const params = new URLSearchParams();
@@ -11262,7 +12304,7 @@ var ModelOAuthService = class {
     }
     this.sweep();
     this.evictOldest(input.userId, input.projectId);
-    const flowId = randomBytes5(32).toString("base64url");
+    const flowId = randomBytes7(32).toString("base64url");
     const verifier = createVerifier();
     const createdAt = this.now();
     const callbackUrl = input.mode === "callback" ? `${input.callbackOrigin}/api/projects/${encodeURIComponent(input.projectId)}/model-oauth/callback?flow=${encodeURIComponent(flowId)}` : void 0;
@@ -13864,8 +14906,10 @@ var UpdateCheckService = class {
 };
 
 // src/services/usage-service.ts
+import { offPeakScheduledRefs } from "@prismshadow/penguin-core/model-catalog";
 var ERROR_RECENT_N = 10;
-function costOf(sums, rates) {
+function costOf(sums, tiered) {
+  const rates = sums.peak ? tiered.peak : tiered.offPeak;
   return (sums.cacheRead * rates.cacheRead + sums.cacheWrite * rates.cacheWrite + sums.output * rates.output) / 1e6;
 }
 function refKey2(provider, modelId) {
@@ -13882,6 +14926,22 @@ var UsageService = class {
   errors;
   lookupPricing;
   now;
+  /**
+   * The catalog's time-based schedules, as the aggregations want them.
+   *
+   * Split by the SCHEDULE, not by whether this Project is on the catalog's price: a Project
+   * that edited the price gets one rate for both halves from {@link lookupPricing}, so the extra
+   * dimension costs a row and changes no number. Doing it the other way round would need the
+   * config read before the query that discovers which references occur.
+   */
+  tiers() {
+    return offPeakScheduledRefs().map(({ schedule, refs }) => ({
+      refs,
+      utcOffsetMinutes: schedule.utcOffsetMinutes,
+      peakDays: schedule.peakDays,
+      peakHours: schedule.peakHours
+    }));
+  }
   async query(projectId, q) {
     const today = formatLocalDate(this.now());
     const base = {};
@@ -13897,13 +14957,20 @@ var UsageService = class {
       ...q.fromTs !== void 0 ? { fromTs: q.fromTs } : {},
       ...q.toTs !== void 0 ? { toTs: q.toTs } : {}
     };
-    const todayRows = this.usage.bucketByModel(projectId, win(today, today));
-    const last7dRows = this.usage.bucketByModel(projectId, win(localDateMinusDays(this.now(), 6)));
-    const totalRows = this.usage.bucketByModel(projectId, { ...win(q.from, q.to), ...ts });
-    const groupRows = this.usage.groupsByModel(projectId, q.groupBy, {
-      ...win(q.from, q.to),
-      ...ts
-    });
+    const tiers = this.tiers();
+    const todayRows = this.usage.bucketByModel(projectId, win(today, today), tiers);
+    const last7dRows = this.usage.bucketByModel(
+      projectId,
+      win(localDateMinusDays(this.now(), 6)),
+      tiers
+    );
+    const totalRows = this.usage.bucketByModel(projectId, { ...win(q.from, q.to), ...ts }, tiers);
+    const groupRows = this.usage.groupsByModel(
+      projectId,
+      q.groupBy,
+      { ...win(q.from, q.to), ...ts },
+      tiers
+    );
     const granularity = q.granularity ?? "day";
     const seriesFrom = q.from ?? localDateMinusDays(this.now(), 29);
     const seriesTo = q.to ?? today;
@@ -13923,10 +14990,12 @@ var UsageService = class {
         "Date range too wide for this granularity; narrow the range or coarsen the granularity."
       );
     }
-    const seriesRows = this.usage.seriesByModel(projectId, granularity, {
-      ...win(seriesFrom, seriesTo),
-      ...ts
-    });
+    const seriesRows = this.usage.seriesByModel(
+      projectId,
+      granularity,
+      { ...win(seriesFrom, seriesTo), ...ts },
+      tiers
+    );
     const agentFree = {
       ...q.provider !== void 0 ? { provider: q.provider } : {},
       ...q.modelId !== void 0 ? { modelId: q.modelId } : {},
@@ -14006,16 +15075,55 @@ var UsageService = class {
       total: this.errors.summary(projectId, f).total
     };
   }
+  /**
+   * Empties the error table for the filter the panel is showing, and answers how many rows went.
+   *
+   * The filter is the same date range and Agent the dashboard and the paged route take, so a
+   * clear removes exactly the set the caller was looking at and never a row outside it: a
+   * reader who has narrowed to one Agent and one week does not lose the rest of the year to a
+   * button that said "clear".
+   *
+   * Unattributed rows are outside every clear (see ErrorsRepo.deleteFiltered): they carry no
+   * Project, so they are not this Project's to remove, and the delete's scope is therefore
+   * strictly narrower than what any caller — admin included — is allowed to read.
+   */
+  clearErrors(projectId, q) {
+    return this.errors.deleteFiltered(projectId, {
+      ...q.agentId !== void 0 ? { agentId: q.agentId } : {},
+      ...q.from !== void 0 ? { from: q.from } : {},
+      ...q.to !== void 0 ? { to: q.to } : {}
+    });
+  }
   /** Error statistics: summary info (total / unexpected / most common error code) + the last N entries, all filtered by the selected range. */
   foldErrors(projectId, f) {
     const { total, unexpected } = this.errors.summary(projectId, f);
     return {
       total,
+      // Counted the way deleteFiltered selects — without the unattributed rows an admin's read
+      // includes — so the clear confirmation states what will really go rather than what is on
+      // screen. Identical to `total` for everyone whose read did not include them.
+      clearable: f.includeGlobal === true ? this.errors.summary(projectId, { ...f, includeGlobal: false }).total : total,
       unexpected,
       topCode: this.errors.topCode(projectId, f),
       recent: this.errors.recent(projectId, f, ERROR_RECENT_N)
     };
   }
+  /**
+   * Lifetime Token totals per Model — one grouped scan of `usage_records`, no filters. The
+   * models page shows each configured model what it has actually spent, and that figure is not
+   * scoped to a range the way the cost center's is; a model with no records is simply absent,
+   * so the caller renders nothing rather than a zero.
+   */
+  modelTotals(projectId) {
+    return {
+      totals: this.usage.bucketByModel(projectId).map((r) => ({
+        provider: r.provider,
+        modelId: r.modelId,
+        tokens: r.total,
+        requests: r.requests
+      }))
+    };
+  }
   foldBucket(rows, rates) {
     let total = 0;
     let requests = 0;
@@ -16009,20 +17117,6 @@ var HmrHost = class {
     return this.webMem !== null ? { kind: "mem", files: this.webMem } : null;
   }
   // -- Persistence ----------------------------------------------------------
-  /**
-   * Content-addresses the cli bundle (never imported — just stored, for packages/cli's
-   * own loader to pick up) and the web gzip artifact next to the platform bundle the
-   * boot already stored (its CODE only — see the module doc: state is never
-   * persisted), then flips harness.json ONCE — `platform`, `cli`, and `web` all land in the SAME atomic
-   * rename, never three separate commits that could leave one pointer ahead of the
-   * others. `platform.bundle` and `cli.bundle` are genuinely independent files
-   * (distinct content, distinct sha) rather than the same physical bundle under two
-   * manifest keys.
-   *
-   * Returns whether the commit succeeded — the caller surfaces this to clients
-   * (`persisted` in UpgradeOutcome) so a live swap that could not be written to disk
-   * is visibly at risk of reverting on the next restart, rather than silently ok.
-   */
   /**
    * Unpacks a push's assets under store/assets/<sha>/, content-addressed like every other
    * artifact so an unchanged set reuses its directory. Modes are restored from the push's
@@ -16066,6 +17160,20 @@ var HmrHost = class {
   assetsDir() {
     return this.assets;
   }
+  /**
+   * Content-addresses the cli bundle (never imported — just stored, for packages/cli's
+   * own loader to pick up) and the web gzip artifact next to the platform bundle the
+   * boot already stored (its CODE only — see the module doc: state is never
+   * persisted), then flips harness.json ONCE — `platform`, `cli`, and `web` all land in the SAME atomic
+   * rename, never three separate commits that could leave one pointer ahead of the
+   * others. `platform.bundle` and `cli.bundle` are genuinely independent files
+   * (distinct content, distinct sha) rather than the same physical bundle under two
+   * manifest keys.
+   *
+   * Returns whether the commit succeeded — the caller surfaces this to clients
+   * (`persisted` in UpgradeOutcome) so a live swap that could not be written to disk
+   * is visibly at risk of reverting on the next restart, rather than silently ok.
+   */
   async persistVersion(platformSha, cliContent, webGz, webSha, assetsDir, source) {
     try {
       const cliSha = sha1(cliContent).slice(0, 16);
@@ -16102,11 +17210,11 @@ var HmrHost = class {
     await this.pruneStore(manifest);
   }
   /**
-   * Store GC: keep at most STORE_KEEP versions — the committed one is always
-   * kept, the rest by recency. Best-effort; ordered after the manifest flip so
-   * nothing referenced can be pruned. `platform`, `cli`, and `web` are three
-   * independent subtrees now (no shared file to piggyback a sweep on), so each
-   * gets its own pass.
+   * Store GC: keep the STORE_KEEP most recently written of each artifact, plus the one
+   * harness.json references, which is kept whether or not recency would have. Best-effort;
+   * ordered after the manifest flip so nothing referenced can be pruned. `platform`, `cli`,
+   * `web` and the assets directories are independent subtrees (no shared file to piggyback a
+   * sweep on), so each gets its own pass.
    */
   async pruneStore(manifest) {
     const keepNewest = async (dir, keys, referenced, remove) => {
@@ -16364,12 +17472,12 @@ function platformHttpSeam(hmr) {
 }
 
 // src/services/preview-token.ts
-import { createHmac, randomBytes as randomBytes6, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { createHmac, randomBytes as randomBytes8, timingSafeEqual as timingSafeEqual2 } from "crypto";
 var PREVIEW_TOKEN_TTL_MS = 10 * 60 * 1e3;
 function b64url(buf) {
   return buf.toString("base64url");
 }
-function createPreviewTokenSigner(secret = randomBytes6(32)) {
+function createPreviewTokenSigner(secret = randomBytes8(32)) {
   const mac = (body) => createHmac("sha256", secret).update(body).digest();
   return {
     sign(payload) {
@@ -16717,6 +17825,30 @@ var GROUP_COLUMNS = {
   model: "model_id",
   session: "session_id"
 };
+function peakExpr(tiers) {
+  if (tiers.length === 0) return { sql: "1", params: {} };
+  const params = {};
+  const branches = [];
+  tiers.forEach((tier, ti) => {
+    if (tier.refs.length === 0 || tier.peakDays.length === 0) return;
+    const shift = `'${tier.utcOffsetMinutes >= 0 ? "+" : "-"}${Math.abs(tier.utcOffsetMinutes)} minutes'`;
+    const refs = tier.refs.map((ref, ri) => {
+      const p = `t${ti}p${ri}`;
+      const m = `t${ti}m${ri}`;
+      params[p] = ref.provider;
+      params[m] = ref.modelId;
+      return `(provider = :${p} AND model_id = :${m})`;
+    });
+    const day = `CASE CAST(strftime('%w', ts, ${shift}) AS INTEGER) WHEN 0 THEN 7 ELSE CAST(strftime('%w', ts, ${shift}) AS INTEGER) END`;
+    const hour = `CAST(strftime('%H', ts, ${shift}) AS INTEGER)`;
+    const windows = tier.peakHours.map(([from, to]) => `(${hour} >= ${from} AND ${hour} < ${to})`);
+    branches.push(
+      `WHEN (${refs.join(" OR ")}) THEN (CASE WHEN ${day} IN (${tier.peakDays.join(", ")}) AND (${windows.join(" OR ")}) THEN 1 ELSE 0 END)`
+    );
+  });
+  if (branches.length === 0) return { sql: "1", params: {} };
+  return { sql: `CASE ${branches.join(" ")} ELSE 1 END`, params };
+}
 var SUM_COLUMNS = `COALESCE(SUM(cache_read), 0) AS cache_read,
                 COALESCE(SUM(cache_write), 0) AS cache_write,
                 COALESCE(SUM(output), 0) AS output,
@@ -16726,6 +17858,7 @@ function toSums(r) {
   return {
     provider: r.provider,
     modelId: r.model_id,
+    peak: r.peak !== 0,
     cacheRead: r.cache_read,
     cacheWrite: r.cache_write,
     output: r.output,
@@ -16794,25 +17927,30 @@ var UsageRepo = class {
     }
     return { where: conds.join(" AND "), params };
   }
-  /** Sums (broken down by paired reference): date range + optional agent/model filter. */
-  bucketByModel(projectId, f = {}) {
+  /**
+   * Sums (broken down by paired reference, and by price tier where one applies): date range +
+   * optional agent/model filter.
+   */
+  bucketByModel(projectId, f = {}, tiers = []) {
     const { where, params } = this.conds(projectId, f);
+    const peak = peakExpr(tiers);
     const rows = this.db.prepare(
-      `SELECT provider, model_id, ${SUM_COLUMNS}
+      `SELECT provider, model_id, ${peak.sql} AS peak, ${SUM_COLUMNS}
          FROM usage_records WHERE ${where}
-         GROUP BY provider, model_id`
-    ).all(params);
+         GROUP BY provider, model_id, peak`
+    ).all({ ...params, ...peak.params });
     return rows.map(toSums);
   }
   /** Grouped aggregation (group key x paired reference breakdown): date range + optional agent/model filter. */
-  groupsByModel(projectId, groupBy, f = {}) {
+  groupsByModel(projectId, groupBy, f = {}, tiers = []) {
     const col = GROUP_COLUMNS[groupBy];
     const { where, params } = this.conds(projectId, f);
+    const peak = peakExpr(tiers);
     const rows = this.db.prepare(
-      `SELECT ${col} AS key, provider, model_id, ${SUM_COLUMNS}
+      `SELECT ${col} AS key, provider, model_id, ${peak.sql} AS peak, ${SUM_COLUMNS}
          FROM usage_records WHERE ${where}
-         GROUP BY ${col}, provider, model_id`
-    ).all(params);
+         GROUP BY ${col}, provider, model_id, peak`
+    ).all({ ...params, ...peak.params });
     return rows.map((r) => ({ key: r.key, ...toSums(r) }));
   }
   /**
@@ -16821,16 +17959,17 @@ var UsageRepo = class {
    * (requests / success rate / Token / cost) at the requested precision. The
    * denominator excludes aborted.
    */
-  seriesByModel(projectId, granularity, f = {}) {
+  seriesByModel(projectId, granularity, f = {}, tiers = []) {
     const expr = BUCKET_EXPRS[granularity];
     const { where, params } = this.conds(projectId, f);
+    const peak = peakExpr(tiers);
     const rows = this.db.prepare(
-      `SELECT ${expr} AS key, provider, model_id, ${SUM_COLUMNS},
+      `SELECT ${expr} AS key, provider, model_id, ${peak.sql} AS peak, ${SUM_COLUMNS},
                 COALESCE(SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END), 0) AS completed,
                 COALESCE(SUM(CASE WHEN status <> 'aborted' THEN 1 ELSE 0 END), 0) AS denominator
          FROM usage_records WHERE ${where}
-         GROUP BY key, provider, model_id`
-    ).all(params);
+         GROUP BY key, provider, model_id, peak`
+    ).all({ ...params, ...peak.params });
     return rows.map((r) => ({
       key: r.key,
       ...toSums(r),
@@ -17524,13 +18663,13 @@ function parseMode(value) {
   return value;
 }
 function resultPage(title, body) {
-  const esc4 = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  const esc5 = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
   return `<!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>${esc4(title)}</title>
+<title>${esc5(title)}</title>
 <style>
 :root { color-scheme: light dark; }
 body {
@@ -17547,7 +18686,7 @@ p { margin: 0; color: #4b5563; }
 }
 </style>
 </head>
-<body><main><h1>${esc4(title)}</h1><p>${esc4(body)}</p></main></body>
+<body><main><h1>${esc5(title)}</h1><p>${esc5(body)}</p></main></body>
 </html>
 `;
 }
@@ -17652,6 +18791,7 @@ function modelOAuthRoutes(deps) {
     return c.json({
       status: state.status,
       provider: state.provider,
+      ...state.applied !== void 0 ? { applied: state.applied } : {},
       ...state.error !== void 0 ? { error: state.error } : {}
     });
   });
@@ -18823,7 +19963,7 @@ function memoryRoutes(deps) {
 }
 
 // src/http/routes/schedules.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { Hono as Hono19 } from "hono";
 import { isValidId as isValidId4 } from "@prismshadow/penguin-core";
 function parseUpsertBody(body) {
@@ -18858,7 +19998,7 @@ function nextFireAt(def, state, nowMs) {
   const next = nextSlotAfter(def, nowMs);
   return next !== null ? new Date(next).toISOString() : void 0;
 }
-function statusOf2(def, state, nowMs) {
+function statusOf3(def, state, nowMs) {
   if (state.invalidReason !== null) return "invalid";
   if (def.periodMs === void 0 && state.firedOnce) return "done";
   if (def.periodMs === void 0 && state.missed) return "missed";
@@ -18878,7 +20018,7 @@ function toItem(def, state, queued, nowMs) {
     ...def.workspace !== void 0 ? { workspace: def.workspace } : {},
     ...def.modelId !== void 0 ? { modelId: def.modelId } : {},
     ...def.provider !== void 0 ? { provider: def.provider } : {},
-    status: statusOf2(def, state, nowMs),
+    status: statusOf3(def, state, nowMs),
     ...state.invalidReason !== null ? { invalidReason: state.invalidReason } : {},
     ...next !== void 0 ? { nextFireAt: next } : {},
     ...state.lastFiredAt !== null ? { lastFiredAt: state.lastFiredAt } : {},
@@ -18975,7 +20115,7 @@ async function upsert(deps, userId, projectId, agentId, name, body) {
     agentId,
     name,
     startAtMs: parsed.def.startAtMs,
-    defHash: createHash4("sha1").update(raw).digest("hex"),
+    defHash: createHash5("sha1").update(raw).digest("hex"),
     creatorUserId: userId
   });
   await deps.scheduler.reconcileAgent(projectId, agentId);
@@ -19179,9 +20319,9 @@ async function collectSkillArchive(dir, name) {
   return out;
 }
 function explicitSkillVersion(skillMd) {
-  const block4 = /^---\r?\n([\s\S]*?)\r?\n---/.exec(skillMd.replace(/^\uFEFF/, ""))?.[1];
-  if (block4 === void 0) return null;
-  for (const line of block4.split(/\r?\n/)) {
+  const block5 = /^---\r?\n([\s\S]*?)\r?\n---/.exec(skillMd.replace(/^\uFEFF/, ""))?.[1];
+  if (block5 === void 0) return null;
+  for (const line of block5.split(/\r?\n/)) {
     const idx = line.indexOf(":");
     if (idx <= 0 || line.slice(0, idx).trim() !== "version") continue;
     const version = Number.parseInt(line.slice(idx + 1).trim(), 10);
@@ -19758,6 +20898,11 @@ function usageRoutes(deps) {
       })
     );
   });
+  app.get("/model-totals", (c) => {
+    const projectId = requireValidId(c, "projectId");
+    deps.projectService.requireProjectAccess(c.var.user.userId, projectId);
+    return c.json(deps.usageService.modelTotals(projectId));
+  });
   app.get("/errors", (c) => {
     const projectId = requireValidId(c, "projectId");
     deps.projectService.requireProjectAccess(c.var.user.userId, projectId);
@@ -19783,11 +20928,69 @@ function usageRoutes(deps) {
       })
     );
   });
+  app.delete("/errors", (c) => {
+    const projectId = requireValidId(c, "projectId");
+    deps.projectService.requireProjectOwner(c.var.user.userId, projectId);
+    const from = optionalDateParam(c.req.query("from"), "from");
+    const to = optionalDateParam(c.req.query("to"), "to");
+    const agentId = c.req.query("agentId");
+    const deleted = deps.usageService.clearErrors(projectId, {
+      ...from !== void 0 ? { from } : {},
+      ...to !== void 0 ? { to } : {},
+      ...agentId !== void 0 && agentId !== "" ? { agentId } : {}
+    });
+    return c.json({ deleted });
+  });
   return app;
 }
 
 // src/http/routes/messaging.ts
-import { Hono as Hono29 } from "hono";
+import { Hono as Hono29 } from "hono";
+
+// src/http/routes/messaging-channels.ts
+function commonBindingFields(row) {
+  return {
+    sessionId: row.sessionId,
+    enabled: row.enabled,
+    linePerMessage: row.linePerMessage,
+    finalReplyOnly: row.finalReplyOnly,
+    renderMarkdown: row.renderMarkdown,
+    lastChatKnown: row.lastChatId !== null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function maskedSecretField(key, secret) {
+  return secret === "" ? {} : { [key]: maskApiKey(secret) };
+}
+function deliveryPatchOf(body) {
+  const linePerMessage = optionalBoolean(body, "linePerMessage");
+  const finalReplyOnly = optionalBoolean(body, "finalReplyOnly");
+  const renderMarkdown = optionalBoolean(body, "renderMarkdown");
+  return {
+    ...linePerMessage !== void 0 ? { linePerMessage } : {},
+    ...finalReplyOnly !== void 0 ? { finalReplyOnly } : {},
+    ...renderMarkdown !== void 0 ? { renderMarkdown } : {}
+  };
+}
+function resolveSecret(args) {
+  const typed = args.typed !== void 0 && args.typed !== "" ? args.typed : void 0;
+  if (typed !== void 0) return { secret: typed, fromRequest: true };
+  if (args.clear && args.existing !== null) {
+    if (args.existing.enabled) {
+      throw new HttpError(
+        409,
+        "messaging_disable_before_clear",
+        "Disable the connection before clearing its credential."
+      );
+    }
+    return { secret: "", fromRequest: false };
+  }
+  if (args.stored === "") throw new HttpError(400, args.requiredCode, args.requiredMessage);
+  return { secret: args.stored, fromRequest: false };
+}
+
+// src/http/routes/messaging.ts
 function feishuFieldsOf(row) {
   const { appId, appSecret, baseDomain } = row.config;
   return {
@@ -19807,62 +21010,82 @@ function qqFieldsOf(row) {
     appSecret: typeof appSecret === "string" ? appSecret : ""
   };
 }
-function toFeishuInfo(row) {
-  const fields = feishuFieldsOf(row);
+function wechatFieldsOf(row) {
+  const { botId, botToken } = row.config;
   return {
-    channel: "feishu",
-    sessionId: row.sessionId,
-    appId: fields.appId,
-    // A cleared/never-entered secret has no mask: the field's absence is what tells the
-    // editor to render "not configured" instead of a masked placeholder.
-    ...fields.appSecret !== "" ? { appSecretMasked: maskApiKey(fields.appSecret) } : {},
-    baseDomain: fields.baseDomain,
-    enabled: row.enabled,
-    linePerMessage: row.linePerMessage,
-    finalReplyOnly: row.finalReplyOnly,
-    renderMarkdown: row.renderMarkdown,
-    lastChatKnown: row.lastChatId !== null,
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt
+    botId: typeof botId === "string" ? botId : row.accountId,
+    botToken: typeof botToken === "string" ? botToken : ""
   };
 }
-function toTelegramInfo(row) {
-  const { botToken } = telegramFieldsOf(row);
-  return {
+var CHANNEL_SPECS = {
+  feishu: {
+    channel: "feishu",
+    label: "Feishu",
+    storedSecret: (row) => feishuFieldsOf(row).appSecret,
+    secretRequiredCode: "feishu_secret_required",
+    toInfo: (row) => {
+      const fields = feishuFieldsOf(row);
+      return {
+        channel: "feishu",
+        ...commonBindingFields(row),
+        appId: fields.appId,
+        ...maskedSecretField("appSecretMasked", fields.appSecret),
+        baseDomain: fields.baseDomain
+      };
+    }
+  },
+  telegram: {
     channel: "telegram",
-    sessionId: row.sessionId,
-    botId: row.accountId,
-    ...botToken !== "" ? { botTokenMasked: maskApiKey(botToken) } : {},
-    enabled: row.enabled,
-    linePerMessage: row.linePerMessage,
-    finalReplyOnly: row.finalReplyOnly,
-    renderMarkdown: row.renderMarkdown,
-    lastChatKnown: row.lastChatId !== null,
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt
-  };
-}
-function toQQInfo(row) {
-  const fields = qqFieldsOf(row);
-  return {
+    label: "Telegram",
+    storedSecret: (row) => telegramFieldsOf(row).botToken,
+    secretRequiredCode: "telegram_token_required",
+    toInfo: (row) => ({
+      channel: "telegram",
+      ...commonBindingFields(row),
+      // The bot id is the row's account identity rather than a config field: it survives a
+      // cleared token, because the half in front of a token's colon never changes for a bot.
+      botId: row.accountId,
+      ...maskedSecretField("botTokenMasked", telegramFieldsOf(row).botToken)
+    })
+  },
+  qq: {
     channel: "qq",
-    sessionId: row.sessionId,
-    appId: fields.appId,
-    ...fields.appSecret !== "" ? { appSecretMasked: maskApiKey(fields.appSecret) } : {},
-    enabled: row.enabled,
-    linePerMessage: row.linePerMessage,
-    finalReplyOnly: row.finalReplyOnly,
-    renderMarkdown: row.renderMarkdown,
-    lastChatKnown: row.lastChatId !== null,
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt
-  };
+    label: "QQ",
+    storedSecret: (row) => qqFieldsOf(row).appSecret,
+    secretRequiredCode: "qq_secret_required",
+    toInfo: (row) => {
+      const fields = qqFieldsOf(row);
+      return {
+        channel: "qq",
+        ...commonBindingFields(row),
+        appId: fields.appId,
+        ...maskedSecretField("appSecretMasked", fields.appSecret)
+      };
+    }
+  },
+  wechat: {
+    channel: "wechat",
+    label: "WeChat",
+    storedSecret: (row) => wechatFieldsOf(row).botToken,
+    secretRequiredCode: "wechat_token_required",
+    toInfo: (row) => {
+      const fields = wechatFieldsOf(row);
+      return {
+        channel: "wechat",
+        ...commonBindingFields(row),
+        // The bot id is the row's account identity as well as a config field: a cleared
+        // token leaves the row still knowing which bot it was bound to.
+        botId: fields.botId,
+        ...maskedSecretField("botTokenMasked", fields.botToken)
+      };
+    }
+  }
+};
+function specOf(channel) {
+  return CHANNEL_SPECS[channel] ?? null;
 }
 function toBindingInfo(row) {
-  if (row.channel === "feishu") return toFeishuInfo(row);
-  if (row.channel === "telegram") return toTelegramInfo(row);
-  if (row.channel === "qq") return toQQInfo(row);
-  return null;
+  return specOf(row.channel)?.toInfo(row) ?? null;
 }
 function parseBaseDomain(raw) {
   const trimmed = raw?.trim() ?? "";
@@ -19901,27 +21124,17 @@ function sessionMessagingRoutes(deps) {
     }
     return row;
   };
-  const feishuResponse = (sessionId) => {
-    const row = deps.messagingRepo.find(sessionId, "feishu");
-    return {
-      binding: row ? toFeishuInfo(row) : null,
-      status: deps.messaging.statusOf(sessionId, "feishu")
-    };
-  };
-  const telegramResponse = (sessionId) => {
-    const row = deps.messagingRepo.find(sessionId, "telegram");
+  const bindingResponse = (sessionId, spec) => {
+    const row = deps.messagingRepo.find(sessionId, spec.channel);
     return {
-      binding: row ? toTelegramInfo(row) : null,
-      status: deps.messaging.statusOf(sessionId, "telegram")
-    };
-  };
-  const qqResponse = (sessionId) => {
-    const row = deps.messagingRepo.find(sessionId, "qq");
-    return {
-      binding: row ? toQQInfo(row) : null,
-      status: deps.messaging.statusOf(sessionId, "qq")
+      binding: row ? spec.toInfo(row) : null,
+      status: deps.messaging.statusOf(sessionId, spec.channel)
     };
   };
+  const feishuResponse = (sessionId) => bindingResponse(sessionId, CHANNEL_SPECS.feishu);
+  const telegramResponse = (sessionId) => bindingResponse(sessionId, CHANNEL_SPECS.telegram);
+  const qqResponse = (sessionId) => bindingResponse(sessionId, CHANNEL_SPECS.qq);
+  const wechatResponse = (sessionId) => bindingResponse(sessionId, CHANNEL_SPECS.wechat);
   const guardAccountFree = (sessionId, channel, accountId) => {
     const holder = deps.messagingRepo.findEnabledByAccount(channel, accountId);
     if (holder === null || holder.sessionId === sessionId) return;
@@ -19945,12 +21158,31 @@ function sessionMessagingRoutes(deps) {
       );
     }
     guardAccountFree(sessionId, channel, row.accountId);
-    const secret = channel === "feishu" ? feishuFieldsOf(row).appSecret : channel === "qq" ? qqFieldsOf(row).appSecret : telegramFieldsOf(row).botToken;
-    if (secret === "") {
-      const code = channel === "feishu" ? "feishu_secret_required" : channel === "qq" ? "qq_secret_required" : "telegram_token_required";
-      throw new HttpError(400, code, "The stored config has no credential: save one first.");
+    const spec = specOf(channel);
+    if (spec === null || spec.storedSecret(row) === "") {
+      throw new HttpError(
+        400,
+        spec?.secretRequiredCode ?? "messaging_channel_unknown",
+        "The stored config has no credential: save one first."
+      );
+    }
+  };
+  const guardScanStart = (sessionId, channel) => {
+    if (deps.messagingRepo.find(sessionId, channel)?.enabled === true) {
+      throw new HttpError(
+        409,
+        "messaging_disable_before_scan",
+        "Disable the connection before rebinding it by scan."
+      );
     }
   };
+  const saveScanResult = async (sessionId, channel, accountId, config) => {
+    const bound = deps.messagingRepo.find(sessionId, channel);
+    if (bound !== null && bound.enabled) guardAccountFree(sessionId, channel, accountId);
+    const saved = deps.messagingRepo.upsert({ sessionId, channel, accountId, config });
+    if (saved.enabled) await deps.messaging.sync(sessionId);
+    return saved;
+  };
   app.get("/:sessionId/messaging", (c) => {
     const row = resolveSession(c);
     const bindings = [];
@@ -19961,74 +21193,83 @@ function sessionMessagingRoutes(deps) {
     }
     return c.json({ bindings });
   });
-  app.get("/:sessionId/messaging/feishu", (c) => {
-    const row = resolveSession(c);
-    return c.json(feishuResponse(row.sessionId));
-  });
+  const registerChannelRoutes = (spec) => {
+    const base = `/:sessionId/messaging/${spec.channel}`;
+    const notBound = () => {
+      throw new HttpError(
+        404,
+        `${spec.channel}_not_bound`,
+        `This Session has no ${spec.label} binding.`
+      );
+    };
+    const boundOr404 = (sessionId) => deps.messagingRepo.find(sessionId, spec.channel) ?? notBound();
+    app.get(base, (c) => c.json(bindingResponse(resolveSession(c).sessionId, spec)));
+    app.post(`${base}/state`, async (c) => {
+      const row = resolveSession(c);
+      deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
+      const enabled = await readStateBody(c);
+      const binding = boundOr404(row.sessionId);
+      if (enabled) guardEnable(row.sessionId, spec.channel, binding);
+      deps.messagingRepo.setEnabled(row.sessionId, spec.channel, enabled);
+      await deps.messaging.sync(row.sessionId);
+      return c.json(bindingResponse(row.sessionId, spec));
+    });
+    app.delete(base, (c) => {
+      const row = resolveSession(c);
+      deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
+      deps.messaging.unbind(row.sessionId, spec.channel);
+      return c.body(null, 204);
+    });
+    app.post(`${base}/test-message`, async (c) => {
+      const row = resolveSession(c);
+      const binding = boundOr404(row.sessionId);
+      if (binding.lastChatId === null) {
+        throw new HttpError(
+          409,
+          `${spec.channel}_no_chat`,
+          `No ${spec.label} chat is known yet: message the bot once in ${spec.label} first.`
+        );
+      }
+      try {
+        await deps.messaging.sendTestMessage(binding);
+      } catch (err) {
+        throw new HttpError(
+          502,
+          `${spec.channel}_send_failed`,
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+      return c.json({ ok: true });
+    });
+  };
+  for (const spec of Object.values(CHANNEL_SPECS)) registerChannelRoutes(spec);
   app.put("/:sessionId/messaging/feishu", async (c) => {
     const row = resolveSession(c);
     deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
     const body = await readJson(c);
     const appId = requireString(body, "appId", { minLen: 1, maxLen: 200 }).trim();
     if (appId === "") throw badRequest("appId must not be blank.");
-    const secretInput = optionalString(body, "appSecret", { maxLen: 500 })?.trim();
-    const clearSecret = body.clearAppSecret === true;
     const baseDomain = parseBaseDomain(optionalString(body, "baseDomain", { maxLen: 500 }));
-    const linePerMessage = optionalBoolean(body, "linePerMessage");
-    const finalReplyOnly = optionalBoolean(body, "finalReplyOnly");
-    const renderMarkdown = optionalBoolean(body, "renderMarkdown");
     const existing = deps.messagingRepo.find(row.sessionId, "feishu");
-    const typed = secretInput !== void 0 && secretInput !== "" ? secretInput : void 0;
-    let appSecret;
-    if (typed !== void 0) appSecret = typed;
-    else if (clearSecret && existing !== null) {
-      if (existing.enabled) {
-        throw new HttpError(
-          409,
-          "messaging_disable_before_clear",
-          "Disable the connection before clearing its credential."
-        );
-      }
-      appSecret = "";
-    } else {
-      const stored = existing !== null ? feishuFieldsOf(existing).appSecret : "";
-      if (stored === "") {
-        throw new HttpError(400, "feishu_secret_required", "appSecret is required to bind.");
-      }
-      appSecret = stored;
-    }
+    const { secret: appSecret } = resolveSecret({
+      typed: optionalString(body, "appSecret", { maxLen: 500 })?.trim(),
+      clear: body.clearAppSecret === true,
+      existing,
+      stored: existing !== null ? feishuFieldsOf(existing).appSecret : "",
+      requiredCode: "feishu_secret_required",
+      requiredMessage: "appSecret is required to bind."
+    });
     if (existing !== null && existing.enabled) guardAccountFree(row.sessionId, "feishu", appId);
     const saved = deps.messagingRepo.upsert({
       sessionId: row.sessionId,
       channel: "feishu",
       accountId: appId,
       config: { appId, appSecret, baseDomain },
-      ...linePerMessage !== void 0 ? { linePerMessage } : {},
-      ...finalReplyOnly !== void 0 ? { finalReplyOnly } : {},
-      ...renderMarkdown !== void 0 ? { renderMarkdown } : {}
+      ...deliveryPatchOf(body)
     });
     if (saved.enabled) await deps.messaging.sync(row.sessionId);
     return c.json(feishuResponse(row.sessionId));
   });
-  app.post("/:sessionId/messaging/feishu/state", async (c) => {
-    const row = resolveSession(c);
-    deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
-    const enabled = await readStateBody(c);
-    const binding = deps.messagingRepo.find(row.sessionId, "feishu");
-    if (binding === null) {
-      throw new HttpError(404, "feishu_not_bound", "This Session has no Feishu binding.");
-    }
-    if (enabled) guardEnable(row.sessionId, "feishu", binding);
-    deps.messagingRepo.setEnabled(row.sessionId, "feishu", enabled);
-    await deps.messaging.sync(row.sessionId);
-    return c.json(feishuResponse(row.sessionId));
-  });
-  app.delete("/:sessionId/messaging/feishu", (c) => {
-    const row = resolveSession(c);
-    deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
-    deps.messaging.unbind(row.sessionId, "feishu");
-    return c.body(null, 204);
-  });
   app.post("/:sessionId/messaging/feishu/test", async (c) => {
     const row = resolveSession(c);
     const body = await readJson(c);
@@ -20053,49 +21294,22 @@ function sessionMessagingRoutes(deps) {
       ...result.error !== void 0 ? { error: result.error } : {}
     });
   });
-  app.post("/:sessionId/messaging/feishu/test-message", async (c) => {
-    const row = resolveSession(c);
-    const binding = deps.messagingRepo.find(row.sessionId, "feishu");
-    if (!binding) {
-      throw new HttpError(404, "feishu_not_bound", "This Session has no Feishu binding.");
-    }
-    if (binding.lastChatId === null) {
-      throw new HttpError(
-        409,
-        "feishu_no_chat",
-        "No Feishu chat is known yet: message the bot once in Feishu first."
-      );
-    }
-    try {
-      await deps.messaging.sendTestMessage(binding);
-    } catch (err) {
-      throw new HttpError(
-        502,
-        "feishu_send_failed",
-        err instanceof Error ? err.message : String(err)
-      );
-    }
-    return c.json({ ok: true });
-  });
-  app.get("/:sessionId/messaging/telegram", (c) => {
-    const row = resolveSession(c);
-    return c.json(telegramResponse(row.sessionId));
-  });
   app.put("/:sessionId/messaging/telegram", async (c) => {
     const row = resolveSession(c);
     deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
     const body = await readJson(c);
-    const tokenInput = optionalString(body, "botToken", { maxLen: 200 })?.trim();
-    const clearToken = body.clearBotToken === true;
-    const linePerMessage = optionalBoolean(body, "linePerMessage");
-    const finalReplyOnly = optionalBoolean(body, "finalReplyOnly");
-    const renderMarkdown = optionalBoolean(body, "renderMarkdown");
     const existing = deps.messagingRepo.find(row.sessionId, "telegram");
-    const typed = tokenInput !== void 0 && tokenInput !== "" ? tokenInput : void 0;
-    let botToken;
+    const { secret: botToken, fromRequest } = resolveSecret({
+      typed: optionalString(body, "botToken", { maxLen: 200 })?.trim(),
+      clear: body.clearBotToken === true,
+      existing,
+      stored: existing !== null ? telegramFieldsOf(existing).botToken : "",
+      requiredCode: "telegram_token_required",
+      requiredMessage: "botToken is required to bind."
+    });
     let botId;
-    if (typed !== void 0) {
-      const id = telegramBotIdOf(typed);
+    if (fromRequest) {
+      const id = telegramBotIdOf(botToken);
       if (id === null) {
         throw new HttpError(
           400,
@@ -20103,24 +21317,8 @@ function sessionMessagingRoutes(deps) {
           "botToken must look like <numeric bot id>:<secret> (as issued by @BotFather)."
         );
       }
-      botToken = typed;
       botId = id;
-    } else if (clearToken && existing !== null) {
-      if (existing.enabled) {
-        throw new HttpError(
-          409,
-          "messaging_disable_before_clear",
-          "Disable the connection before clearing its credential."
-        );
-      }
-      botToken = "";
-      botId = existing.accountId;
     } else {
-      const stored = existing !== null ? telegramFieldsOf(existing).botToken : "";
-      if (stored === "" || existing === null) {
-        throw new HttpError(400, "telegram_token_required", "botToken is required to bind.");
-      }
-      botToken = stored;
       botId = existing.accountId;
     }
     if (existing !== null && existing.enabled) guardAccountFree(row.sessionId, "telegram", botId);
@@ -20129,32 +21327,11 @@ function sessionMessagingRoutes(deps) {
       channel: "telegram",
       accountId: botId,
       config: { botToken },
-      ...linePerMessage !== void 0 ? { linePerMessage } : {},
-      ...finalReplyOnly !== void 0 ? { finalReplyOnly } : {},
-      ...renderMarkdown !== void 0 ? { renderMarkdown } : {}
+      ...deliveryPatchOf(body)
     });
     if (saved.enabled) await deps.messaging.sync(row.sessionId);
     return c.json(telegramResponse(row.sessionId));
   });
-  app.post("/:sessionId/messaging/telegram/state", async (c) => {
-    const row = resolveSession(c);
-    deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
-    const enabled = await readStateBody(c);
-    const binding = deps.messagingRepo.find(row.sessionId, "telegram");
-    if (binding === null) {
-      throw new HttpError(404, "telegram_not_bound", "This Session has no Telegram binding.");
-    }
-    if (enabled) guardEnable(row.sessionId, "telegram", binding);
-    deps.messagingRepo.setEnabled(row.sessionId, "telegram", enabled);
-    await deps.messaging.sync(row.sessionId);
-    return c.json(telegramResponse(row.sessionId));
-  });
-  app.delete("/:sessionId/messaging/telegram", (c) => {
-    const row = resolveSession(c);
-    deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
-    deps.messaging.unbind(row.sessionId, "telegram");
-    return c.body(null, 204);
-  });
   app.post("/:sessionId/messaging/telegram/test", async (c) => {
     const row = resolveSession(c);
     const body = await readJson(c);
@@ -20174,108 +21351,36 @@ function sessionMessagingRoutes(deps) {
       ...result.error !== void 0 ? { error: result.error } : {}
     });
   });
-  app.post("/:sessionId/messaging/telegram/test-message", async (c) => {
-    const row = resolveSession(c);
-    const binding = deps.messagingRepo.find(row.sessionId, "telegram");
-    if (!binding) {
-      throw new HttpError(404, "telegram_not_bound", "This Session has no Telegram binding.");
-    }
-    if (binding.lastChatId === null) {
-      throw new HttpError(
-        409,
-        "telegram_no_chat",
-        "No Telegram chat is known yet: message the bot once in Telegram first."
-      );
-    }
-    try {
-      await deps.messaging.sendTestMessage(binding);
-    } catch (err) {
-      throw new HttpError(
-        502,
-        "telegram_send_failed",
-        err instanceof Error ? err.message : String(err)
-      );
-    }
-    return c.json({ ok: true });
-  });
-  app.get("/:sessionId/messaging/qq", (c) => {
-    const row = resolveSession(c);
-    return c.json(qqResponse(row.sessionId));
-  });
   app.put("/:sessionId/messaging/qq", async (c) => {
     const row = resolveSession(c);
     deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
     const body = await readJson(c);
     const appId = requireString(body, "appId", { minLen: 1, maxLen: 200 }).trim();
     if (appId === "") throw badRequest("appId must not be blank.");
-    const secretInput = optionalString(body, "appSecret", { maxLen: 500 })?.trim();
-    const clearSecret = body.clearAppSecret === true;
-    const linePerMessage = optionalBoolean(body, "linePerMessage");
-    const finalReplyOnly = optionalBoolean(body, "finalReplyOnly");
-    const renderMarkdown = optionalBoolean(body, "renderMarkdown");
     const existing = deps.messagingRepo.find(row.sessionId, "qq");
-    const typed = secretInput !== void 0 && secretInput !== "" ? secretInput : void 0;
-    let appSecret;
-    if (typed !== void 0) appSecret = typed;
-    else if (clearSecret && existing !== null) {
-      if (existing.enabled) {
-        throw new HttpError(
-          409,
-          "messaging_disable_before_clear",
-          "Disable the connection before clearing its credential."
-        );
-      }
-      appSecret = "";
-    } else {
-      const stored = existing !== null ? qqFieldsOf(existing).appSecret : "";
-      if (stored === "") {
-        throw new HttpError(400, "qq_secret_required", "appSecret is required to bind.");
-      }
-      appSecret = stored;
-    }
+    const { secret: appSecret } = resolveSecret({
+      typed: optionalString(body, "appSecret", { maxLen: 500 })?.trim(),
+      clear: body.clearAppSecret === true,
+      existing,
+      stored: existing !== null ? qqFieldsOf(existing).appSecret : "",
+      requiredCode: "qq_secret_required",
+      requiredMessage: "appSecret is required to bind."
+    });
     if (existing !== null && existing.enabled) guardAccountFree(row.sessionId, "qq", appId);
     const saved = deps.messagingRepo.upsert({
       sessionId: row.sessionId,
       channel: "qq",
       accountId: appId,
       config: { appId, appSecret },
-      ...linePerMessage !== void 0 ? { linePerMessage } : {},
-      ...finalReplyOnly !== void 0 ? { finalReplyOnly } : {},
-      ...renderMarkdown !== void 0 ? { renderMarkdown } : {}
+      ...deliveryPatchOf(body)
     });
     if (saved.enabled) await deps.messaging.sync(row.sessionId);
     return c.json(qqResponse(row.sessionId));
   });
-  app.post("/:sessionId/messaging/qq/state", async (c) => {
-    const row = resolveSession(c);
-    deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
-    const enabled = await readStateBody(c);
-    const binding = deps.messagingRepo.find(row.sessionId, "qq");
-    if (binding === null) {
-      throw new HttpError(404, "qq_not_bound", "This Session has no QQ binding.");
-    }
-    if (enabled) guardEnable(row.sessionId, "qq", binding);
-    deps.messagingRepo.setEnabled(row.sessionId, "qq", enabled);
-    await deps.messaging.sync(row.sessionId);
-    return c.json(qqResponse(row.sessionId));
-  });
-  app.delete("/:sessionId/messaging/qq", (c) => {
-    const row = resolveSession(c);
-    deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
-    deps.messaging.unbind(row.sessionId, "qq");
-    deps.qqScan.cancelSession(row.sessionId);
-    return c.body(null, 204);
-  });
   app.post("/:sessionId/messaging/qq/scan", async (c) => {
     const row = resolveSession(c);
     deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
-    if (deps.messagingRepo.find(row.sessionId, "qq")?.enabled === true) {
-      throw new HttpError(
-        409,
-        "messaging_disable_before_scan",
-        "Disable the connection before rebinding it by scan."
-      );
-    }
+    guardScanStart(row.sessionId, "qq");
     let started;
     try {
       started = await deps.qqScan.start(row.sessionId);
@@ -20305,19 +21410,14 @@ function sessionMessagingRoutes(deps) {
     if (result.status !== "completed" || result.bot === void 0) {
       return c.json({ status: result.status });
     }
-    const bound = deps.messagingRepo.find(row.sessionId, "qq");
-    if (bound !== null && bound.enabled) guardAccountFree(row.sessionId, "qq", result.bot.appId);
-    const saved = deps.messagingRepo.upsert({
-      sessionId: row.sessionId,
-      channel: "qq",
-      accountId: result.bot.appId,
-      config: { appId: result.bot.appId, appSecret: result.bot.appSecret }
+    const saved = await saveScanResult(row.sessionId, "qq", result.bot.appId, {
+      appId: result.bot.appId,
+      appSecret: result.bot.appSecret
     });
-    if (saved.enabled) await deps.messaging.sync(row.sessionId);
     return c.json({
       status: "completed",
       appId: result.bot.appId,
-      binding: toQQInfo(saved)
+      binding: CHANNEL_SPECS.qq.toInfo(saved)
     });
   });
   app.post("/:sessionId/messaging/qq/scan/cancel", async (c) => {
@@ -20347,25 +21447,135 @@ function sessionMessagingRoutes(deps) {
       ...result.error !== void 0 ? { error: result.error } : {}
     });
   });
-  app.post("/:sessionId/messaging/qq/test-message", async (c) => {
+  app.put("/:sessionId/messaging/wechat", async (c) => {
     const row = resolveSession(c);
-    const binding = deps.messagingRepo.find(row.sessionId, "qq");
-    if (!binding) {
-      throw new HttpError(404, "qq_not_bound", "This Session has no QQ binding.");
+    deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
+    const body = await readJson(c);
+    const existing = deps.messagingRepo.find(row.sessionId, "wechat");
+    if (existing === null) {
+      throw new HttpError(
+        400,
+        "wechat_token_required",
+        "Bind by scanning a QR code first: there is no saved WeChat config to update."
+      );
     }
-    if (binding.lastChatId === null) {
+    const { secret: botToken } = resolveSecret({
+      typed: void 0,
+      clear: body.clearBotToken === true,
+      existing,
+      stored: wechatFieldsOf(existing).botToken,
+      requiredCode: "wechat_token_required",
+      requiredMessage: "Bind by scanning a QR code first."
+    });
+    const saved = deps.messagingRepo.upsert({
+      sessionId: row.sessionId,
+      channel: "wechat",
+      accountId: existing.accountId,
+      // The stored document carried forward with only the token replaced: it also holds the
+      // API host the scan assigned and the id of the person who scanned, neither of which
+      // this request knows and both of which the connector needs.
+      config: { ...existing.config, botToken },
+      ...deliveryPatchOf(body)
+    });
+    if (saved.enabled) await deps.messaging.sync(row.sessionId);
+    return c.json(wechatResponse(row.sessionId));
+  });
+  app.post("/:sessionId/messaging/wechat/scan", async (c) => {
+    const row = resolveSession(c);
+    deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
+    guardScanStart(row.sessionId, "wechat");
+    let started;
+    try {
+      started = await deps.wechatScan.start(row.sessionId);
+    } catch (err) {
       throw new HttpError(
-        409,
-        "qq_no_chat",
-        "No QQ chat is known yet: message the bot once in QQ first."
+        502,
+        "wechat_scan_failed",
+        err instanceof Error ? err.message : String(err)
       );
     }
+    return c.json(started);
+  });
+  app.post("/:sessionId/messaging/wechat/scan/poll", async (c) => {
+    const row = resolveSession(c);
+    deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
+    const body = await readJson(c);
+    const taskId = requireString(body, "taskId", { minLen: 1, maxLen: 500 });
+    let result;
     try {
-      await deps.messaging.sendTestMessage(binding);
+      result = await deps.wechatScan.poll(row.sessionId, taskId);
     } catch (err) {
-      throw new HttpError(502, "qq_send_failed", err instanceof Error ? err.message : String(err));
+      throw new HttpError(
+        502,
+        "wechat_scan_failed",
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+    if (result === null) {
+      throw new HttpError(
+        404,
+        "wechat_scan_task_unknown",
+        "This scan is no longer in progress: start a new one."
+      );
+    }
+    if (result.status !== "completed" || result.bot === void 0) {
+      return c.json({ status: result.status });
+    }
+    const { botId, botToken, baseUrl, userId } = result.bot;
+    const saved = await saveScanResult(row.sessionId, "wechat", botId, {
+      botId,
+      botToken,
+      baseUrl,
+      userId
+    });
+    return c.json({
+      status: "completed",
+      botId,
+      binding: CHANNEL_SPECS.wechat.toInfo(saved)
+    });
+  });
+  app.post("/:sessionId/messaging/wechat/scan/verify", async (c) => {
+    const row = resolveSession(c);
+    deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
+    const body = await readJson(c);
+    const taskId = requireString(body, "taskId", { minLen: 1, maxLen: 500 });
+    const verifyCode = requireString(body, "verifyCode", { minLen: 1, maxLen: 32 }).trim();
+    if (verifyCode === "") throw badRequest("verifyCode must not be blank.");
+    if (!deps.wechatScan.submitVerifyCode(row.sessionId, taskId, verifyCode)) {
+      throw new HttpError(
+        404,
+        "wechat_scan_task_unknown",
+        "This scan is no longer in progress: start a new one."
+      );
+    }
+    return c.body(null, 204);
+  });
+  app.post("/:sessionId/messaging/wechat/scan/cancel", async (c) => {
+    const row = resolveSession(c);
+    deps.projectService.requireProjectOwner(c.var.user.userId, row.projectId);
+    const body = await readJson(c);
+    deps.wechatScan.cancel(
+      row.sessionId,
+      requireString(body, "taskId", { minLen: 1, maxLen: 500 })
+    );
+    return c.body(null, 204);
+  });
+  app.post("/:sessionId/messaging/wechat/test", async (c) => {
+    const row = resolveSession(c);
+    const stored = deps.messagingRepo.find(row.sessionId, "wechat");
+    if (stored === null || wechatFieldsOf(stored).botToken === "") {
+      throw new HttpError(
+        400,
+        "wechat_token_required",
+        "Bind by scanning a QR code first: there is no credential to test."
+      );
     }
-    return c.json({ ok: true });
+    const result = await deps.messaging.testCredentials("wechat", stored.config);
+    return c.json({
+      ok: result.ok,
+      ...result.latencyMs !== void 0 ? { latencyMs: result.latencyMs } : {},
+      ...result.error !== void 0 ? { error: result.error } : {}
+    });
   });
   return app;
 }
@@ -20833,7 +22043,7 @@ async function resolveTarget(alias) {
 }
 
 // src/machines/install-server.ts
-import { randomBytes as randomBytes7 } from "crypto";
+import { randomBytes as randomBytes9 } from "crypto";
 import fs28 from "fs";
 import os4 from "os";
 import path26 from "path";
@@ -21062,7 +22272,7 @@ async function installOnRemote(opts) {
       say(`Installing release ${plan.baseVersion} (downloaded on the remote)\u2026`);
       let where;
       if (identity.platform === "win32") {
-        const name = `penguin-${randomBytes7(6).toString("hex")}.ps1`;
+        const name = `penguin-${randomBytes9(6).toString("hex")}.ps1`;
         const local = path26.join(os4.tmpdir(), name);
         fs28.writeFileSync(local, installer);
         windowsTmp = { local, remote: `%USERPROFILE%\\${name}` };
@@ -21398,7 +22608,7 @@ var memEtags = /* @__PURE__ */ new WeakMap();
 function etagOfBuffer(content) {
   let etag = memEtags.get(content);
   if (etag === void 0) {
-    etag = `"${createHash5("sha256").update(content).digest("base64url").slice(0, 16)}"`;
+    etag = `"${createHash6("sha256").update(content).digest("base64url").slice(0, 16)}"`;
     memEtags.set(content, etag);
   }
   return etag;
@@ -21535,6 +22745,8 @@ function buildAppDeps(caps, overrides = {}) {
   const usageService = new UsageService(
     usageRepo,
     errorsRepo,
+    // No clock here: a scheduled row's two rates come back together and each aggregation half
+    // is priced at the tier its own records ran in, which the query decides from their `ts`.
     (projectId, provider, modelId) => projectConfigService.getPricing(projectId, provider, modelId),
     overrides.now ?? (() => /* @__PURE__ */ new Date())
   );
@@ -21617,7 +22829,11 @@ function buildAppDeps(caps, overrides = {}) {
       new QQConnector(overrides.qqTransport ?? createQQTransport(), {
         ...overrides.qqTailFlushMs !== void 0 ? { tailFlushMs: overrides.qqTailFlushMs } : {},
         ...overrides.now ? { now: () => overrides.now().getTime() } : {}
-      })
+      }),
+      new WeChatConnector(
+        overrides.wechatTransport ?? createWeChatTransport(),
+        overrides.wechatRetryDelayMs ? { retryDelayMs: overrides.wechatRetryDelayMs } : {}
+      )
     ],
     errors,
     log,
@@ -21628,6 +22844,10 @@ function buildAppDeps(caps, overrides = {}) {
   const qqScan = new QQScanService(overrides.qqScanTransport ?? createQQScanTransport(), {
     ...overrides.now ? { now: () => overrides.now().getTime() } : {}
   });
+  const wechatScan = new WeChatScanService(
+    overrides.wechatScanTransport ?? createWeChatScanTransport(),
+    { ...overrides.now ? { now: () => overrides.now().getTime() } : {} }
+  );
   const sessionService = new SessionService({
     root: config.root,
     sessions: sessionsRepo,
@@ -21642,7 +22862,7 @@ function buildAppDeps(caps, overrides = {}) {
     // stored channel reads as none (same defensive skip as the bridge and the routes).
     messagingChannel: (sessionId) => {
       const enabled = messagingRepo.findEnabled(sessionId);
-      return enabled !== null && (enabled.channel === "feishu" || enabled.channel === "telegram" || enabled.channel === "qq") ? enabled.channel : null;
+      return enabled !== null && (enabled.channel === "feishu" || enabled.channel === "telegram" || enabled.channel === "qq" || enabled.channel === "wechat") ? enabled.channel : null;
     }
   });
   const scheduler = new Scheduler({
@@ -21687,6 +22907,7 @@ function buildAppDeps(caps, overrides = {}) {
     errorsRepo,
     messagingRepo,
     qqScan,
+    wechatScan,
     messaging,
     scheduler,
     channels,