@kyan-du/agent-wechat-cli 0.13.3 → 0.14.0

package/dist/cli.js

@@ -1199,8 +1199,8 @@ var require_command = __commonJS({
   "../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/command.js"(exports) {
     var EventEmitter = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
-    var path5 = __require("node:path");
-    var fs5 = __require("node:fs");
+    var path6 = __require("node:path");
+    var fs6 = __require("node:fs");
     var process2 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2194,7 +2194,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs5.existsSync(executableFile)) return;
+        if (fs6.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -2212,11 +2212,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path5.resolve(baseDir, baseName);
-          if (fs5.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path5.extname(baseName))) return void 0;
+          const localBin = path6.resolve(baseDir, baseName);
+          if (fs6.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path6.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs5.existsSync(`${localBin}${ext}`)
+            (ext) => fs6.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2228,21 +2228,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs5.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs6.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path5.resolve(
-            path5.dirname(resolvedScriptPath),
+          executableDir = path6.resolve(
+            path6.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path5.basename(
+            const legacyName = path6.basename(
               this._scriptPath,
-              path5.extname(this._scriptPath)
+              path6.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2253,7 +2253,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path5.extname(executableFile));
+        launchWithNode = sourceExt.includes(path6.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -3055,9 +3055,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string[]} [aliases]
        * @return {(string[]|Command)}
        */
-      aliases(aliases) {
-        if (aliases === void 0) return this._aliases;
-        aliases.forEach((alias) => this.alias(alias));
+      aliases(aliases2) {
+        if (aliases2 === void 0) return this._aliases;
+        aliases2.forEach((alias) => this.alias(alias));
         return this;
       }
       /**
@@ -3168,7 +3168,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path5.basename(filename, path5.extname(filename));
+        this._name = path6.basename(filename, path6.extname(filename));
         return this;
       }
       /**
@@ -3182,9 +3182,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path6) {
-        if (path6 === void 0) return this._executableDir;
-        this._executableDir = path6;
+      executableDir(path7) {
+        if (path7 === void 0) return this._executableDir;
+        this._executableDir = path7;
         return this;
       }
       /**
@@ -3482,9 +3482,9 @@ var {
 // src/cli.ts
 import { execFileSync as execFileSync3, spawn } from "node:child_process";
 import { createHash, randomBytes as randomBytes2 } from "node:crypto";
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import os2 from "node:os";
-import path4 from "node:path";
+import path5 from "node:path";
 import readline from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import qrTerminal from "qrcode-terminal";
@@ -3967,8 +3967,8 @@ function getErrorMap() {
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path5, errorMaps, issueData } = params;
-  const fullPath = [...path5, ...issueData.path || []];
+  const { data, path: path6, errorMaps, issueData } = params;
+  const fullPath = [...path6, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -4084,11 +4084,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path5, key) {
+  constructor(parent, value, path6, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path5;
+    this._path = path6;
     this._key = key;
   }
   get path() {
@@ -7585,6 +7585,23 @@ var chatSchema = external_exports.object({
   unreadCount: external_exports.number().int().nonnegative(),
   isGroup: external_exports.boolean()
 });
+var groupMemberSchema = external_exports.object({
+  memberId: external_exports.string().min(1),
+  displayName: external_exports.string().min(1),
+  groupAlias: external_exports.string().optional(),
+  nickName: external_exports.string().optional()
+});
+var groupMembersPageSchema = external_exports.object({
+  schemaVersion: external_exports.literal(1),
+  items: external_exports.array(groupMemberSchema),
+  nextCursor: external_exports.string().nullable().optional(),
+  errorCode: external_exports.string().optional()
+});
+var listGroupMembersParamsSchema = external_exports.object({
+  groupId: external_exports.string().endsWith("@chatroom"),
+  limit: external_exports.number().int().positive().max(100).optional().default(50),
+  cursor: external_exports.string().optional()
+});
 var listChatsParamsSchema = external_exports.object({
   limit: external_exports.number().int().positive().max(100).optional().default(50),
   offset: external_exports.number().int().nonnegative().optional().default(0)
@@ -7611,6 +7628,22 @@ var openChatResultSchema = external_exports.object({
   error: external_exports.string().optional()
 });
 var idempotencyKeySchema = external_exports.string().min(1).max(128).regex(/^[A-Za-z0-9._:-]+$/);
+var forwardedMessageNodeSchema = external_exports.lazy(() => external_exports.object({
+  sender: external_exports.string().optional(),
+  senderId: external_exports.string().optional(),
+  timestamp: external_exports.string().optional(),
+  text: external_exports.string().optional(),
+  messageType: external_exports.number().int().optional(),
+  media: external_exports.string().optional(),
+  children: external_exports.array(forwardedMessageNodeSchema),
+  truncated: external_exports.boolean()
+}));
+var forwardedMessageTreeSchema = external_exports.object({
+  schemaVersion: external_exports.number().int(),
+  title: external_exports.string().optional(),
+  nodes: external_exports.array(forwardedMessageNodeSchema),
+  truncated: external_exports.boolean()
+});
 var messageSchema = external_exports.object({
   localId: external_exports.number().int(),
   serverId: external_exports.number(),
@@ -7619,7 +7652,26 @@ var messageSchema = external_exports.object({
   senderName: external_exports.string().optional(),
   type: external_exports.number().int(),
   content: external_exports.string(),
-  timestamp: external_exports.string()
+  timestamp: external_exports.string(),
+  forwarded: forwardedMessageTreeSchema.optional()
+});
+var mediaReferenceSchema = external_exports.object({
+  localId: external_exports.number().int(),
+  url: external_exports.string().min(1)
+});
+var syncReadStateSchema = external_exports.object({
+  unreadCount: external_exports.number().int().nonnegative(),
+  observedAt: external_exports.string().min(1)
+});
+var chatSyncPageSchema = external_exports.object({
+  schemaVersion: external_exports.literal(1),
+  chat: chatSchema.optional(),
+  items: external_exports.array(messageSchema),
+  nextCursor: external_exports.string().optional().nullable(),
+  syncToken: external_exports.string(),
+  readState: syncReadStateSchema,
+  media: external_exports.array(mediaReferenceSchema),
+  errorCode: external_exports.string().optional()
 });
 var listMessagesParamsSchema = external_exports.object({
   chatId: external_exports.string().min(1),
@@ -7645,6 +7697,31 @@ var sendParamsSchema = external_exports.object({
   source: external_exports.string().min(1).max(64).regex(/^[A-Za-z0-9._:-]+$/).optional(),
   similarityConfirmed: external_exports.boolean().optional()
 });
+var deliveryStateSchema = external_exports.enum(["queued", "composing", "submitted", "observed_in_chat", "confirmed", "uncertain", "failed"]);
+var deliveryCauseSchema = external_exports.enum(["send_accepted", "target_sender_and_payload_match", "observation_confirmed", "target_mismatch", "sender_unverified", "payload_mismatch", "pre_commit_failure", "post_commit_uncertain"]);
+var deliveryTransitionSchema = external_exports.object({ from: deliveryStateSchema, to: deliveryStateSchema, at: external_exports.string().datetime(), reason: deliveryCauseSchema });
+var deliveryObservationSchema = external_exports.object({
+  chatId: external_exports.string().trim().min(1).max(512),
+  localId: external_exports.number().int().nonnegative().safe(),
+  serverId: external_exports.number().int().nonnegative().safe(),
+  timestamp: external_exports.string().datetime(),
+  type: external_exports.number().int().nonnegative().safe(),
+  sender: external_exports.string().trim().min(1).max(512),
+  content: external_exports.string().max(1e6)
+}).strict();
+var deliveryAttemptSchema = external_exports.object({
+  schemaVersion: external_exports.literal(1),
+  idempotencyKey: idempotencyKeySchema.optional(),
+  senderId: external_exports.string().trim().min(1).max(512),
+  targetChatId: external_exports.string().trim().min(1).max(512),
+  payloadDigest: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  state: deliveryStateSchema,
+  commitAttempted: external_exports.boolean(),
+  createdAt: external_exports.string().datetime(),
+  updatedAt: external_exports.string().datetime(),
+  observedLocalId: external_exports.number().int().nonnegative().optional(),
+  transitions: external_exports.array(deliveryTransitionSchema).max(32)
+});
 var sendResultSchema = external_exports.object({
   success: external_exports.boolean(),
   messageId: external_exports.string().optional(),
@@ -7657,11 +7734,13 @@ var getMediaParamsSchema = external_exports.object({
   localId: external_exports.number().int()
 });
 var mediaResultSchema = external_exports.object({
-  type: external_exports.enum(["image", "emoji", "voice", "video", "unsupported"]),
+  type: external_exports.enum(["image", "emoji", "file", "voice", "video", "pending", "unsupported"]),
   data: external_exports.string().optional(),
   url: external_exports.string().optional(),
   format: external_exports.string(),
-  filename: external_exports.string()
+  filename: external_exports.string(),
+  source: external_exports.enum(["original", "thumbnail"]).optional(),
+  errorCode: external_exports.string().optional()
 });
 var agentConfigSchema = external_exports.object({
   maxTurns: external_exports.number().int().positive().default(30),
@@ -7726,16 +7805,16 @@ var WeChatClient = class {
     return this.base;
   }
   // ---- internal helpers ----
-  async get(path5) {
-    const res = await fetch(`${this.base}${path5}`, {
+  async get(path6) {
+    const res = await fetch(`${this.base}${path6}`, {
       headers: this.headers
     });
     if (!res.ok)
       await throwHttpError(res);
     return res.json();
   }
-  async post(path5, body) {
-    const res = await fetch(`${this.base}${path5}`, {
+  async post(path6, body) {
+    const res = await fetch(`${this.base}${path6}`, {
       method: "POST",
       headers: this.headers,
       body: body != null ? JSON.stringify(body) : void 0
@@ -7786,6 +7865,12 @@ var WeChatClient = class {
   async openChat(chatId, clearUnreads) {
     return this.post(`/api/chats/${encodeURIComponent(chatId)}/open${qs({ clearUnreads })}`);
   }
+  async listGroupMembersPage(groupId, limit, cursor) {
+    const page = groupMembersPageSchema.parse(await this.get(`/api/groups/${encodeURIComponent(groupId)}/members${qs({ limit, cursor })}`));
+    if (page.errorCode)
+      throw new WeChatHttpError(400, "Bad Request", page.errorCode, page.errorCode);
+    return { ...page, nextCursor: page.nextCursor ?? void 0 };
+  }
   // ---- Contacts ----
   async listContactsPage(limit, cursor) {
     const page = await this.get(`/api/contacts${qs({ limit, cursor })}`);
@@ -7809,6 +7894,17 @@ var WeChatClient = class {
   async listMessages(chatId, limit) {
     return (await this.listMessagesPage(chatId, limit)).items;
   }
+  async syncChat(chatId, options = {}) {
+    const raw = await this.get(`/api/sync/${encodeURIComponent(chatId)}${qs({ limit: options.limit, cursor: options.cursor, since: options.since, from: options.from, to: options.to })}`);
+    if (raw && typeof raw === "object" && typeof raw.errorCode === "string") {
+      const errorCode = raw.errorCode;
+      throw new WeChatHttpError(400, "Bad Request", errorCode, errorCode);
+    }
+    const page = chatSyncPageSchema.parse(raw);
+    if (page.errorCode)
+      throw new WeChatHttpError(400, "Bad Request", page.errorCode, page.errorCode);
+    return { ...page, nextCursor: page.nextCursor ?? void 0 };
+  }
   async getMedia(chatId, localId) {
     return this.get(`/api/messages/${encodeURIComponent(chatId)}/media/${localId}`);
   }
@@ -8178,9 +8274,8 @@ function buildDockerRunArgs(identity, opts) {
     "-e",
     `AGENT_WECHAT_MAC=${identity.mac}`
   ];
-  if (opts.proxy) {
-    args.push("-e", `PROXY=${opts.proxy}`);
-  }
+  if (opts.proxy) args.push("-e", `PROXY=${opts.proxy}`);
+  for (const [key, value] of Object.entries(opts.outbound ?? {})) args.push("-e", `${key}=${value}`);
   args.push(opts.image);
   return args;
 }
@@ -8210,17 +8305,18 @@ function buildCliSendParams(options) {
 var FORK_IMAGE = "ghcr.io/kyan-du/agent-wechat";
 var VERSION_TAG = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?$/;
 var DIGEST = /^sha256:[0-9a-f]{64}$/;
+var COMMIT_TAG = /^[a-f0-9]{7}$/;
 function validatePublishedImageReference(reference) {
   const tagPrefix = `${FORK_IMAGE}:`;
   const digestPrefix = `${FORK_IMAGE}@`;
-  if (reference.startsWith(tagPrefix) && VERSION_TAG.test(reference.slice(tagPrefix.length))) {
+  if (reference.startsWith(tagPrefix) && (VERSION_TAG.test(reference.slice(tagPrefix.length)) || COMMIT_TAG.test(reference.slice(tagPrefix.length)))) {
     return reference;
   }
   if (reference.startsWith(digestPrefix) && DIGEST.test(reference.slice(digestPrefix.length))) {
     return reference;
   }
   throw new Error(
-    `Invalid image reference. Use ${FORK_IMAGE}:<semver> or ${FORK_IMAGE}@sha256:<64 lowercase hex characters>.`
+    `Invalid image reference. Use ${FORK_IMAGE}:<semver>, ${FORK_IMAGE}:<7-character commit SHA>, or ${FORK_IMAGE}@sha256:<64 lowercase hex characters>.`
   );
 }
 function localBuildImage(platform = process.platform, arch = process.arch) {
@@ -8326,8 +8422,8 @@ function assertSafePurgePath(target, root) {
 
 // src/lifecycle.ts
 import { execFileSync } from "node:child_process";
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs4 from "node:fs";
+import path4 from "node:path";
 
 // src/exit-contract.ts
 var EXIT = {
@@ -8369,47 +8465,910 @@ function failure(error) {
   };
 }
 
-// src/lifecycle-policy.ts
-var INSTANCE_LABEL = "dev.visionclaw.agent-wechat.instance";
-var IMAGE_LABEL = "dev.visionclaw.agent-wechat.image";
-var VOLUME_ROLE_LABEL = "dev.visionclaw.agent-wechat.volume-role";
-function exactEnv(env, key) {
-  const values = (env ?? []).filter((entry) => entry.startsWith(`${key}=`)).map((entry) => entry.slice(key.length + 1));
-  return values.length === 1 ? values[0] : void 0;
+// src/outbound-config.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+
+// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+var TomlError = class extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
+  }
+};
+
+// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/util.js
+function isEscaped(str, ptr) {
+  let i = 0;
+  while (str[ptr - ++i] === "\\")
+    ;
+  return --i && i % 2;
+}
+function indexOfNewline(str, start = 0, end = str.length) {
+  let idx = str.indexOf("\n", start);
+  if (str[idx - 1] === "\r")
+    idx--;
+  return idx <= end ? idx : -1;
+}
+function skipComment(str, ptr) {
+  for (let i = ptr; i < str.length; i++) {
+    let c = str[i];
+    if (c === "\n")
+      return i;
+    if (c === "\r" && str[i + 1] === "\n")
+      return i + 1;
+    if (c < " " && c !== "	" || c === "\x7F") {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: str,
+        ptr
+      });
+    }
+  }
+  return str.length;
+}
+function skipVoid(str, ptr, banNewLines, banComments) {
+  let c;
+  while ((c = str[ptr]) === " " || c === "	" || !banNewLines && (c === "\n" || c === "\r" && str[ptr + 1] === "\n"))
+    ptr++;
+  return banComments || c !== "#" ? ptr : skipVoid(str, skipComment(str, ptr), banNewLines);
+}
+function skipUntil(str, ptr, sep, end, banNewLines = false) {
+  if (!end) {
+    ptr = indexOfNewline(str, ptr);
+    return ptr < 0 ? str.length : ptr;
+  }
+  for (let i = ptr; i < str.length; i++) {
+    let c = str[i];
+    if (c === "#") {
+      i = indexOfNewline(str, i);
+    } else if (c === sep) {
+      return i + 1;
+    } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
+      return i;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: str,
+    ptr
+  });
+}
+function getStringEnd(str, seek) {
+  let first = str[seek];
+  let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2] ? str.slice(seek, seek + 3) : first;
+  seek += target.length - 1;
+  do
+    seek = str.indexOf(target, ++seek);
+  while (seek > -1 && first !== "'" && isEscaped(str, seek));
+  if (seek > -1) {
+    seek += target.length;
+    if (target.length > 1) {
+      if (str[seek] === first)
+        seek++;
+      if (str[seek] === first)
+        seek++;
+    }
+  }
+  return seek;
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    if (typeof date === "string") {
+      let match = date.match(DATE_TIME_RE);
+      if (match) {
+        if (!match[1]) {
+          hasDate = false;
+          date = `0000-01-01T${date}`;
+        }
+        hasTime = !!match[2];
+        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+        if (match[2] && +match[2] > 23) {
+          date = "";
+        } else {
+          offset = match[3] || null;
+          date = date.toUpperCase();
+          if (!offset && hasTime)
+            date += "Z";
+        }
+      } else {
+        date = "";
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
+
+// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/primitive.js
+var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+var LEADING_ZERO = /^[+-]?0[0-9_]/;
+var ESCAPE_REGEX = /^[0-9a-f]{2,8}$/i;
+var ESC_MAP = {
+  b: "\b",
+  t: "	",
+  n: "\n",
+  f: "\f",
+  r: "\r",
+  e: "\x1B",
+  '"': '"',
+  "\\": "\\"
+};
+function parseString(str, ptr = 0, endPtr = str.length) {
+  let isLiteral = str[ptr] === "'";
+  let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
+  if (isMultiline) {
+    endPtr -= 2;
+    if (str[ptr += 2] === "\r")
+      ptr++;
+    if (str[ptr] === "\n")
+      ptr++;
+  }
+  let tmp = 0;
+  let isEscape;
+  let parsed = "";
+  let sliceStart = ptr;
+  while (ptr < endPtr - 1) {
+    let c = str[ptr++];
+    if (c === "\n" || c === "\r" && str[ptr] === "\n") {
+      if (!isMultiline) {
+        throw new TomlError("newlines are not allowed in strings", {
+          toml: str,
+          ptr: ptr - 1
+        });
+      }
+    } else if (c < " " && c !== "	" || c === "\x7F") {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    }
+    if (isEscape) {
+      isEscape = false;
+      if (c === "x" || c === "u" || c === "U") {
+        let code = str.slice(ptr, ptr += c === "x" ? 2 : c === "u" ? 4 : 8);
+        if (!ESCAPE_REGEX.test(code)) {
+          throw new TomlError("invalid unicode escape", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+        try {
+          parsed += String.fromCodePoint(parseInt(code, 16));
+        } catch {
+          throw new TomlError("invalid unicode escape", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+      } else if (isMultiline && (c === "\n" || c === " " || c === "	" || c === "\r")) {
+        ptr = skipVoid(str, ptr - 1, true);
+        if (str[ptr] !== "\n" && str[ptr] !== "\r") {
+          throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+        ptr = skipVoid(str, ptr);
+      } else if (c in ESC_MAP) {
+        parsed += ESC_MAP[c];
+      } else {
+        throw new TomlError("unrecognized escape sequence", {
+          toml: str,
+          ptr: tmp
+        });
+      }
+      sliceStart = ptr;
+    } else if (!isLiteral && c === "\\") {
+      tmp = ptr - 1;
+      isEscape = true;
+      parsed += str.slice(sliceStart, tmp);
+    }
+  }
+  return parsed + str.slice(sliceStart, endPtr - 1);
+}
+function parseValue(value, toml, ptr, integersAsBigInt) {
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (value === "-inf")
+    return -Infinity;
+  if (value === "inf" || value === "+inf")
+    return Infinity;
+  if (value === "nan" || value === "+nan" || value === "-nan")
+    return NaN;
+  if (value === "-0")
+    return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value);
+  if (isInt || FLOAT_REGEX.test(value)) {
+    if (LEADING_ZERO.test(value)) {
+      throw new TomlError("leading zeroes are not allowed", {
+        toml,
+        ptr
+      });
+    }
+    value = value.replace(/_/g, "");
+    let numeric = +value;
+    if (isNaN(numeric)) {
+      throw new TomlError("invalid number", {
+        toml,
+        ptr
+      });
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", {
+          toml,
+          ptr
+        });
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric = BigInt(value);
+    }
+    return numeric;
+  }
+  const date = new TomlDate(value);
+  if (!date.isValid()) {
+    throw new TomlError("invalid value", {
+      toml,
+      ptr
+    });
+  }
+  return date;
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/extract.js
+function sliceAndTrimEndOf(str, startPtr, endPtr) {
+  let value = str.slice(startPtr, endPtr);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > -1) {
+    skipComment(str, commentIdx);
+    value = value.slice(0, commentIdx);
+  }
+  return [value.trimEnd(), commentIdx];
+}
+function extractValue(str, ptr, end, depth, integersAsBigInt) {
+  if (depth === 0) {
+    throw new TomlError("document contains excessively nested structures. aborting.", {
+      toml: str,
+      ptr
+    });
+  }
+  let c = str[ptr];
+  if (c === "[" || c === "{") {
+    let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
+    if (end) {
+      endPtr2 = skipVoid(str, endPtr2);
+      if (str[endPtr2] === ",")
+        endPtr2++;
+      else if (str[endPtr2] !== end) {
+        throw new TomlError("expected comma or end of structure", {
+          toml: str,
+          ptr: endPtr2
+        });
+      }
+    }
+    return [value, endPtr2];
+  }
+  let endPtr;
+  if (c === '"' || c === "'") {
+    endPtr = getStringEnd(str, ptr);
+    let parsed = parseString(str, ptr, endPtr);
+    if (end) {
+      endPtr = skipVoid(str, endPtr);
+      if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== "\n" && str[endPtr] !== "\r") {
+        throw new TomlError("unexpected character encountered", {
+          toml: str,
+          ptr: endPtr
+        });
+      }
+      endPtr += +(str[endPtr] === ",");
+    }
+    return [parsed, endPtr];
+  }
+  endPtr = skipUntil(str, ptr, ",", end);
+  let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ","));
+  if (!slice[0]) {
+    throw new TomlError("incomplete key-value declaration: no value specified", {
+      toml: str,
+      ptr
+    });
+  }
+  if (end && slice[1] > -1) {
+    endPtr = skipVoid(str, ptr + slice[1]);
+    endPtr += +(str[endPtr] === ",");
+  }
+  return [
+    parseValue(slice[0], str, ptr, integersAsBigInt),
+    endPtr
+  ];
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/struct.js
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(str, ptr, end = "=") {
+  let dot = ptr - 1;
+  let parsed = [];
+  let endPtr = str.indexOf(end, ptr);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: str,
+      ptr
+    });
+  }
+  do {
+    let c = str[ptr = ++dot];
+    if (c !== " " && c !== "	") {
+      if (c === '"' || c === "'") {
+        if (c === str[ptr + 1] && c === str[ptr + 2]) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        let eos = getStringEnd(str, ptr);
+        if (eos < 0) {
+          throw new TomlError("unfinished string encountered", {
+            toml: str,
+            ptr
+          });
+        }
+        dot = str.indexOf(".", eos);
+        let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: str,
+            ptr: ptr + dot + newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: str,
+            ptr: eos
+          });
+        }
+        if (endPtr < eos) {
+          endPtr = str.indexOf(end, eos);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: str,
+              ptr
+            });
+          }
+        }
+        parsed.push(parseString(str, ptr, eos));
+      } else {
+        dot = str.indexOf(".", ptr);
+        let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
+        if (!KEY_PART_RE.test(part)) {
+          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  return [parsed, skipVoid(str, endPtr + 1, true, true)];
+}
+function parseInlineTable(str, ptr, depth, integersAsBigInt) {
+  let res = {};
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "}" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+      let k;
+      let t = res;
+      let hasOwn = false;
+      let [key, keyEndPtr] = parseKey(str, ptr - 1);
+      for (let i = 0; i < key.length; i++) {
+        if (i)
+          t = hasOwn ? t[k] : t[k] = {};
+        k = key[i];
+        if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+          throw new TomlError("trying to redefine an already defined value", {
+            toml: str,
+            ptr
+          });
+        }
+        if (!hasOwn && k === "__proto__") {
+          Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        }
+      }
+      if (hasOwn) {
+        throw new TomlError("trying to redefine an already defined value", {
+          toml: str,
+          ptr
+        });
+      }
+      let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
+      seen.add(value);
+      t[k] = value;
+      ptr = valueEndPtr;
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished table encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
 }
-function containerOwnershipError(info, inventory) {
-  if (inventory.containerId && info.Id !== inventory.containerId) {
-    return { code: "CONTAINER_ID_MISMATCH", message: "container identity changed" };
+function parseArray(str, ptr, depth, integersAsBigInt) {
+  let res = [];
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "]" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+      let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
+      res.push(e[0]);
+      ptr = e[1];
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished array encountered", {
+      toml: str,
+      ptr
+    });
   }
-  if (info.Config?.Labels?.[INSTANCE_LABEL] !== "default") {
-    return { code: "CONTAINER_OWNERSHIP_MISMATCH", message: "container is not owned by this instance" };
+  return [res, ptr];
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/parse.js
+function peekTable(key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = {};
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      if (k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: {}
+      };
+    }
   }
-  const expectedImage = inventory.imageDigest ?? inventory.imageRef;
-  if (info.Config?.Image !== expectedImage || info.Config?.Labels?.[IMAGE_LABEL] !== expectedImage) {
-    return { code: "CONTAINER_IMAGE_MISMATCH", message: "container image does not match inventory" };
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
   }
-  const env = info.Config?.Env;
-  if (info.Config?.Hostname !== inventory.identity.hostname || exactEnv(env, "AGENT_WECHAT_MACHINE_ID") !== inventory.identity.machineId || exactEnv(env, "AGENT_WECHAT_HOSTNAME") !== inventory.identity.hostname || exactEnv(env, "AGENT_WECHAT_MAC") !== inventory.identity.mac) {
-    return { code: "CONTAINER_IDENTITY_MISMATCH", message: "container identity does not match inventory" };
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = {});
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
   }
-  const mounts = new Map((info.Mounts ?? []).map((mount) => [mount.Destination, mount]));
-  const data = mounts.get("/data");
-  const home = mounts.get("/home/wechat");
-  const token = mounts.get("/data/auth-token");
-  if (data?.Type !== "volume" || data.Name !== inventory.volumes[0] || home?.Type !== "volume" || home.Name !== inventory.volumes[1] || token?.Type !== "bind" || token.Source !== inventory.tokenPath) {
-    return { code: "CONTAINER_RESOURCE_MISMATCH", message: "container mounts do not match inventory" };
+  if (state.d) {
+    return null;
   }
-  const bindings = info.HostConfig?.PortBindings?.[`${inventory.port}/tcp`];
-  if (!bindings || bindings.length !== 1 || bindings[0]?.HostPort !== String(inventory.port)) {
-    return { code: "CONTAINER_PORT_MISMATCH", message: "container port does not match inventory" };
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = {};
+  } else if (type === 0 && hasOwn) {
+    return null;
   }
-  return void 0;
+  return [k, t, state.c];
 }
-function volumeOwnershipError(info, expectedName, expectedRole) {
-  if (info.Name !== expectedName || info.Driver !== "local" || info.Labels?.[INSTANCE_LABEL] !== "default" || info.Labels?.[VOLUME_ROLE_LABEL] !== expectedRole) {
-    return { code: "VOLUME_OWNERSHIP_MISMATCH", message: `volume ${expectedName} is outside the trusted instance scope` };
+function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+  let res = {};
+  let meta = {};
+  let tbl = res;
+  let m = meta;
+  for (let ptr = skipVoid(toml, 0); ptr < toml.length; ) {
+    if (toml[ptr] === "[") {
+      let isTableArray = toml[++ptr] === "[";
+      let k = parseKey(toml, ptr += +isTableArray, "]");
+      if (isTableArray) {
+        if (toml[k[1] - 1] !== "]") {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: k[1] - 1
+          });
+        }
+        k[1]++;
+      }
+      let p = peekTable(
+        k[0],
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+      ptr = k[1];
+    } else {
+      let k = parseKey(toml, ptr);
+      let p = peekTable(
+        k[0],
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
+      p[1][p[0]] = v[0];
+      ptr = v[1];
+    }
+    ptr = skipVoid(toml, ptr, true);
+    if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr
+      });
+    }
+    ptr = skipVoid(toml, ptr);
   }
-  return void 0;
+  return res;
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/stringify.js
+var BARE_KEY = /^[a-z0-9-_]+$/i;
+function extendedTypeOf(obj) {
+  let type = typeof obj;
+  if (type === "object") {
+    if (Array.isArray(obj))
+      return "array";
+    if (obj instanceof Date)
+      return "date";
+  }
+  return type;
+}
+function isArrayOfTables(obj) {
+  for (let i = 0; i < obj.length; i++) {
+    if (extendedTypeOf(obj[i]) !== "object")
+      return false;
+  }
+  return obj.length != 0;
+}
+function formatString(s) {
+  return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
+}
+function stringifyValue(val, type, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  if (type === "number") {
+    if (isNaN(val))
+      return "nan";
+    if (val === Infinity)
+      return "inf";
+    if (val === -Infinity)
+      return "-inf";
+    if (numberAsFloat && Number.isInteger(val))
+      return val.toFixed(1);
+    return val.toString();
+  }
+  if (type === "bigint" || type === "boolean") {
+    return val.toString();
+  }
+  if (type === "string") {
+    return formatString(val);
+  }
+  if (type === "date") {
+    if (isNaN(val.getTime())) {
+      throw new TypeError("cannot serialize invalid date");
+    }
+    return val.toISOString();
+  }
+  if (type === "object") {
+    return stringifyInlineTable(val, depth, numberAsFloat);
+  }
+  if (type === "array") {
+    return stringifyArray(val, depth, numberAsFloat);
+  }
+}
+function stringifyInlineTable(obj, depth, numberAsFloat) {
+  let keys = Object.keys(obj);
+  if (keys.length === 0)
+    return "{}";
+  let res = "{ ";
+  for (let i = 0; i < keys.length; i++) {
+    let k = keys[i];
+    if (i)
+      res += ", ";
+    res += BARE_KEY.test(k) ? k : formatString(k);
+    res += " = ";
+    res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
+  }
+  return res + " }";
+}
+function stringifyArray(array, depth, numberAsFloat) {
+  if (array.length === 0)
+    return "[]";
+  let res = "[ ";
+  for (let i = 0; i < array.length; i++) {
+    if (i)
+      res += ", ";
+    if (array[i] === null || array[i] === void 0) {
+      throw new TypeError("arrays cannot contain null or undefined values");
+    }
+    res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat);
+  }
+  return res + " ]";
+}
+function stringifyArrayTable(array, key, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let res = "";
+  for (let i = 0; i < array.length; i++) {
+    res += `${res && "\n"}[[${key}]]
+`;
+    res += stringifyTable(0, array[i], key, depth, numberAsFloat);
+  }
+  return res;
+}
+function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let preamble = "";
+  let tables = "";
+  let keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    let k = keys[i];
+    if (obj[k] !== null && obj[k] !== void 0) {
+      let type = extendedTypeOf(obj[k]);
+      if (type === "symbol" || type === "function") {
+        throw new TypeError(`cannot serialize values of type '${type}'`);
+      }
+      let key = BARE_KEY.test(k) ? k : formatString(k);
+      if (type === "array" && isArrayOfTables(obj[k])) {
+        tables += (tables && "\n") + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
+      } else if (type === "object") {
+        let tblKey = prefix ? `${prefix}.${key}` : key;
+        tables += (tables && "\n") + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat);
+      } else {
+        preamble += key;
+        preamble += " = ";
+        preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
+        preamble += "\n";
+      }
+    }
+  }
+  if (tableKey && (preamble || !tables))
+    preamble = preamble ? `[${tableKey}]
+${preamble}` : `[${tableKey}]`;
+  return preamble && tables ? `${preamble}
+${tables}` : preamble || tables;
+}
+function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
+  if (extendedTypeOf(obj) !== "object") {
+    throw new TypeError("stringify can only be called with an object");
+  }
+  let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat);
+  if (str[str.length - 1] !== "\n")
+    return str + "\n";
+  return str;
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/index.js
+var dist_default = { parse, stringify, TomlDate, TomlError };
+
+// src/outbound-config.ts
+var OUTBOUND_ENV_KEYS = [
+  "AGENT_WECHAT_OUTBOUND_QUEUE_CAPACITY",
+  "AGENT_WECHAT_OUTBOUND_MIN_SPACING_MS",
+  "AGENT_WECHAT_OUTBOUND_JITTER_MS",
+  "AGENT_WECHAT_CHAT_COOLDOWN_MS",
+  "AGENT_WECHAT_HOURLY_BUDGET",
+  "AGENT_WECHAT_DAILY_BUDGET",
+  "AGENT_WECHAT_QUIET_START_MIN",
+  "AGENT_WECHAT_QUIET_END_MIN",
+  "AGENT_WECHAT_OUTBOUND_LONG_TAIL_JITTER_MS",
+  "AGENT_WECHAT_OUTBOUND_LONG_TAIL_CHANCE_PERCENT",
+  "AGENT_WECHAT_OUTBOUND_TASK_TTL_MS",
+  "AGENT_WECHAT_OUTBOUND_IDEMPOTENCY_TTL_MS",
+  "AGENT_WECHAT_OUTBOUND_IDEMPOTENCY_MAX_ROWS",
+  "AGENT_WECHAT_OUTBOUND_DISABLED"
+];
+var aliases = {
+  queueCapacity: "AGENT_WECHAT_OUTBOUND_QUEUE_CAPACITY",
+  minSpacingMs: "AGENT_WECHAT_OUTBOUND_MIN_SPACING_MS",
+  jitterMs: "AGENT_WECHAT_OUTBOUND_JITTER_MS",
+  chatCooldownMs: "AGENT_WECHAT_CHAT_COOLDOWN_MS",
+  hourlyBudget: "AGENT_WECHAT_HOURLY_BUDGET",
+  dailyBudget: "AGENT_WECHAT_DAILY_BUDGET",
+  quietStartMin: "AGENT_WECHAT_QUIET_START_MIN",
+  quietEndMin: "AGENT_WECHAT_QUIET_END_MIN",
+  longTailJitterMs: "AGENT_WECHAT_OUTBOUND_LONG_TAIL_JITTER_MS",
+  longTailChancePercent: "AGENT_WECHAT_OUTBOUND_LONG_TAIL_CHANCE_PERCENT",
+  taskTtlMs: "AGENT_WECHAT_OUTBOUND_TASK_TTL_MS",
+  idempotencyTtlMs: "AGENT_WECHAT_OUTBOUND_IDEMPOTENCY_TTL_MS",
+  idempotencyMaxRows: "AGENT_WECHAT_OUTBOUND_IDEMPOTENCY_MAX_ROWS",
+  disabled: "AGENT_WECHAT_OUTBOUND_DISABLED"
+};
+function readOutboundConfig(file) {
+  if (!file) return {};
+  const parsed = dist_default.parse(fs3.readFileSync(path3.resolve(file), "utf8"));
+  const result = {};
+  for (const [key, env] of Object.entries(aliases)) if (parsed[key] !== void 0) result[env] = String(parsed[key]);
+  for (const key of OUTBOUND_ENV_KEYS) if (parsed[key] !== void 0) result[key] = String(parsed[key]);
+  return result;
+}
+function outboundFromEnvEntries(entries) {
+  const result = {};
+  const allowed = new Set(OUTBOUND_ENV_KEYS);
+  for (const entry of entries) {
+    const index = entry.indexOf("=");
+    if (index > 0 && allowed.has(entry.slice(0, index))) result[entry.slice(0, index)] = entry.slice(index + 1);
+  }
+  return result;
+}
+function resolveOutboundConfig(file, cli = {}) {
+  const config = file ? readOutboundConfig(file) : {};
+  const env = {};
+  for (const key of OUTBOUND_ENV_KEYS) if (process.env[key] !== void 0) env[key] = process.env[key];
+  return { ...config, ...env, ...cli };
+}
+
+// src/lifecycle-policy.ts
+var INSTANCE_LABEL = "dev.visionclaw.agent-wechat.instance";
+var IMAGE_LABEL = "dev.visionclaw.agent-wechat.image";
+var VOLUME_ROLE_LABEL = "dev.visionclaw.agent-wechat.volume-role";
+function hasOwnedContainer(info) {
+  return info.Config?.Labels?.[INSTANCE_LABEL] === "default";
+}
+function isReconcileableContainer(info, inventory) {
+  if (hasOwnedContainer(info)) return true;
+  const id = inventory?.containerId;
+  return Boolean(id && (info.Id === id || info.Id.startsWith(id) || id.startsWith(info.Id)));
+}
+function hasOwnedVolume(existing, name, role) {
+  return existing.Name === name && existing.Driver === "local" && existing.Labels?.[INSTANCE_LABEL] === "default" && existing.Labels?.[VOLUME_ROLE_LABEL] === role;
 }
 
 // src/lifecycle.ts
@@ -8490,8 +9449,12 @@ function ensureOwnedVolumes(inventory) {
       docker(["volume", "create", "--driver", "local", "--label", `${INSTANCE_LABEL}=default`, "--label", `${VOLUME_ROLE_LABEL}=${roles[index]}`, name]);
       continue;
     }
-    const violation = volumeOwnershipError(existing, name, roles[index]);
-    if (violation) throw new CliError(violation.code, violation.message, EXIT.ENVIRONMENT);
+    assertVolumeOwnership(existing, name, roles[index]);
+  }
+}
+function assertVolumeOwnership(existing, name, role) {
+  if (!hasOwnedVolume(existing, name, role)) {
+    throw new CliError("VOLUME_OWNERSHIP_MISMATCH", `refusing to use volume ${name} without trusted ownership`, EXIT.ENVIRONMENT);
   }
 }
 function assertOwnedVolumes(inventory) {
@@ -8499,10 +9462,12 @@ function assertOwnedVolumes(inventory) {
   for (const [index, name] of inventory.volumes.entries()) {
     const existing = inspectVolume(name);
     if (!existing) continue;
-    const violation = volumeOwnershipError(existing, name, roles[index]);
-    if (violation) throw new CliError(violation.code, violation.message, EXIT.CLEANUP);
+    assertVolumeOwnership(existing, name, roles[index]);
   }
 }
+function assertOwnedContainer(info, inventory) {
+  if (!isReconcileableContainer(info, inventory)) throw new CliError("CONTAINER_OWNERSHIP_MISMATCH", "refusing to operate on an unowned container with the fixed name", EXIT.ENVIRONMENT);
+}
 function clearContainerIdentity(inventory) {
   const info = inspectContainer();
   if (!info) throw new CliError("INSTANCE_NOT_RUNNING", "trusted container is required to clear container identity", EXIT.CLEANUP);
@@ -8519,8 +9484,7 @@ function removeOwnedVolume(inventory, index, role) {
   const name = inventory.volumes[index];
   const existing = inspectVolume(name);
   if (!existing) return false;
-  const violation = volumeOwnershipError(existing, name, role);
-  if (violation) throw new CliError(violation.code, violation.message, EXIT.CLEANUP);
+  assertVolumeOwnership(existing, name, role);
   docker(["volume", "rm", name]);
   return true;
 }
@@ -8542,10 +9506,6 @@ function resolveImage(options) {
   if (published && !digest) throw new CliError("IMAGE_DIGEST_UNRESOLVED", "published image did not resolve to a fork repo digest", EXIT.ENVIRONMENT);
   return { runReference: digest || requested, requestedReference: requested, digest };
 }
-function assertOwnedContainer(info, inventory) {
-  const violation = containerOwnershipError(info, inventory);
-  if (violation) throw new CliError(violation.code, violation.message, EXIT.ENVIRONMENT);
-}
 async function waitCompatible(token, timeoutMs = 3e4) {
   await waitHealthy(timeoutMs);
   try {
@@ -8572,21 +9532,19 @@ async function waitHealthy(timeoutMs = 3e4) {
 }
 async function startInstance(options) {
   if (!dockerAvailable()) throw new CliError("DOCKER_UNAVAILABLE", "Docker daemon is unavailable", EXIT.ENVIRONMENT);
-  const selected = resolveImage({ explicit: options.image, pull: options.pull, noPull: options.noPull, localDefault: options.localDefault });
   const existing = inspectContainer();
   const current = loadInventory();
   if (existing) {
-    if (!current) throw new CliError("INSTANCE_INVENTORY_MISSING", "existing container has no trusted inventory", EXIT.ENVIRONMENT);
     assertOwnedContainer(existing, current);
-    const expected = selected.digest || selected.runReference;
-    const recorded = existing.Config?.Labels?.["dev.visionclaw.agent-wechat.image"];
-    if (existing.Config?.Image !== expected || recorded !== expected) {
-      throw new CliError("IMAGE_COMPATIBILITY_MISMATCH", "existing container image does not match requested compatible image", EXIT.ENVIRONMENT);
+    if (options.outbound && Object.keys(options.outbound).length > 0) {
+      throw new CliError("OUTBOUND_RESTART_REQUIRED", "outbound policy changed; run wx restart to recreate the container", EXIT.ARGUMENT);
     }
-    if (!existing.State?.Running) docker(["start", existing.Id], { inherit: true });
+    if (!current) throw new CliError("INSTANCE_INVENTORY_MISSING", "existing container has no trusted inventory", EXIT.ENVIRONMENT);
+    if (!existing.State?.Running) docker(["start", CONTAINER_NAME], { inherit: true });
     await waitCompatible(options.token);
     return current;
   }
+  const selected = resolveImage({ explicit: options.image, pull: options.pull, noPull: options.noPull, localDefault: options.localDefault });
   const provisional = createInventory(selected.requestedReference, options.identity, selected.digest);
   saveInventory(provisional);
   ensureOwnedVolumes(provisional);
@@ -8595,7 +9553,8 @@ async function startInstance(options) {
     containerName: CONTAINER_NAME,
     tokenPath: TOKEN_PATH,
     port: DEFAULT_PORT,
-    proxy: options.proxy
+    proxy: options.proxy,
+    outbound: options.outbound
   });
   args.splice(args.length - 1, 0, "--label", `${INSTANCE_LABEL}=default`, "--label", `${IMAGE_LABEL}=${selected.digest || selected.runReference}`);
   docker(args, { inherit: true });
@@ -8612,13 +9571,28 @@ async function startInstance(options) {
   }
   return inventory;
 }
+function outboundFromContainer(info) {
+  return outboundFromEnvEntries(info.Config?.Env ?? []);
+}
+function stopContainer(idOrName) {
+  docker(["stop", idOrName], { inherit: true });
+}
+function renameContainer(id, name) {
+  docker(["rename", id, name], { inherit: true });
+}
+function removeContainer(id) {
+  docker(["rm", "-f", id], { inherit: true });
+}
+function startContainer(idOrName) {
+  docker(["start", idOrName], { inherit: true });
+}
 function stopInstance() {
   if (!dockerAvailable()) throw new CliError("DOCKER_UNAVAILABLE", "Docker daemon is unavailable", EXIT.ENVIRONMENT);
   const info = inspectContainer();
   if (!info) return { stopped: false };
   const inventory = loadInventory();
-  if (!inventory) throw new CliError("INSTANCE_INVENTORY_MISSING", "refusing to remove an unowned container", EXIT.ENVIRONMENT);
   assertOwnedContainer(info, inventory);
+  if (!inventory) throw new CliError("INSTANCE_INVENTORY_MISSING", "refusing to remove an unowned container", EXIT.ENVIRONMENT);
   docker(["rm", "-f", info.Id], { inherit: true });
   return { stopped: true };
 }
@@ -8637,18 +9611,18 @@ function purgeInstance() {
       remaining.push(`volume:${volume}`);
     }
   }
-  for (const file of [TOKEN_PATH, path3.join(CONFIG_DIR, "device-identity.env"), path3.join(CONFIG_DIR, "device-identity.json")]) {
+  for (const file of [TOKEN_PATH, path4.join(CONFIG_DIR, "device-identity.env"), path4.join(CONFIG_DIR, "device-identity.json")]) {
     try {
       assertSafePurgePath(file, CONFIG_DIR);
     } catch {
-      remaining.push(path3.basename(file));
+      remaining.push(path4.basename(file));
       continue;
     }
     try {
-      fs3.unlinkSync(file);
-      removed.push(path3.basename(file));
+      fs4.unlinkSync(file);
+      removed.push(path4.basename(file));
     } catch (error) {
-      if (error.code !== "ENOENT") remaining.push(path3.basename(file));
+      if (error.code !== "ENOENT") remaining.push(path4.basename(file));
     }
   }
   if (remaining.length === 0) removeInventory();
@@ -8660,8 +9634,9 @@ async function replaceImage(options) {
   if (!previous) throw new CliError("INSTANCE_INVENTORY_MISSING", "start the instance before image upgrade", EXIT.ENVIRONMENT);
   const info = inspectContainer();
   if (info) assertOwnedContainer(info, previous);
+  const reconciled = previous;
   const selected = resolveImage({ explicit: options.image, pull: true, localDefault: previous.imageRef });
-  if (selected.digest === previous.imageDigest) return previous;
+  if (selected.digest === reconciled.imageDigest) return reconciled;
   if (info) {
     if (info.State?.Running) docker(["stop", info.Id], { inherit: true });
     docker(["rename", info.Id, `${CONTAINER_NAME}-rollback`]);
@@ -8675,7 +9650,7 @@ async function replaceImage(options) {
       const failed = inspectContainer();
       if (failed) docker(["rm", "-f", failed.Id]);
       if (info) docker(["rename", info.Id, CONTAINER_NAME]);
-      saveInventory(previous);
+      saveInventory(reconciled);
       if (info?.State?.Running) docker(["start", CONTAINER_NAME]);
     } catch {
       throw new CliError("ROLLBACK_FAILED", "image upgrade failed and rollback was incomplete", EXIT.ROLLBACK);
@@ -8761,12 +9736,12 @@ function checkCliUpgrade(currentVersion, readLatest = () => execFileSync2("npm",
 }
 
 // src/cli.ts
-var VERSION = false ? "0.0.0-test" : "0.13.3";
+var VERSION = false ? "0.0.0-test" : "0.14.0";
 var MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
 function readToken() {
   try {
     secureRegularFile(TOKEN_PATH);
-    const value = fs4.readFileSync(TOKEN_PATH, "utf8").trim();
+    const value = fs5.readFileSync(TOKEN_PATH, "utf8").trim();
     if (!/^[a-f0-9]{64}$/.test(value)) throw new Error("INVALID_AUTH_TOKEN");
     return value;
   } catch (error) {
@@ -8778,9 +9753,9 @@ function readToken() {
 function ensureToken() {
   const current = readToken();
   if (current) return current;
-  fs4.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  fs5.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
   const token = randomBytes2(32).toString("hex");
-  fs4.writeFileSync(TOKEN_PATH, `${token}
+  fs5.writeFileSync(TOKEN_PATH, `${token}
 `, { mode: 384, flag: "wx" });
   return token;
 }
@@ -8880,13 +9855,13 @@ async function login(timeoutMs, newAccount) {
 function regularUpload(target) {
   let stat;
   try {
-    stat = fs4.lstatSync(target);
+    stat = fs5.lstatSync(target);
   } catch {
     throw new CliError("FILE_NOT_FOUND", `file not found: ${target}`, EXIT.ARGUMENT);
   }
   if (!stat.isFile() || stat.isSymbolicLink()) throw new CliError("INVALID_UPLOAD_FILE", "upload must be a regular non-symlink file", EXIT.ARGUMENT);
   if (stat.size > MAX_UPLOAD_BYTES) throw new CliError("UPLOAD_TOO_LARGE", `upload exceeds ${MAX_UPLOAD_BYTES} bytes`, EXIT.ARGUMENT);
-  return fs4.readFileSync(target);
+  return fs5.readFileSync(target);
 }
 function renderMessages(page) {
   for (const item of [...page.items].reverse()) console.log(`${item.localId}	${item.timestamp}	${item.senderName || item.sender || ""}	${item.content}`);
@@ -8903,15 +9878,15 @@ async function resetAuth(yes) {
   try {
     removeOwnedVolume(inventory, 1, "wechat-home");
   } catch (error) {
-    if (error instanceof CliError && error.code === "VOLUME_OWNERSHIP_MISMATCH") throw error;
+    if (error instanceof CliError && error.code === "VOLUME_DRIVER_UNSUPPORTED") throw error;
     throw new CliError("AUTH_RESET_CLEANUP_INCOMPLETE", `remaining resource: volume:${inventory.volumes[1]}`, EXIT.CLEANUP);
   }
   const remaining = [];
   for (const file of ["device-identity.env", "device-identity.json"]) {
-    const target = path4.join(CONFIG_DIR, file);
+    const target = path5.join(CONFIG_DIR, file);
     try {
       assertSafePurgePath(target, CONFIG_DIR);
-      fs4.unlinkSync(target);
+      fs5.unlinkSync(target);
     } catch (error) {
       if (error.code !== "ENOENT") remaining.push(file);
     }
@@ -8926,7 +9901,6 @@ function programStatus() {
   const container = inspectContainer();
   if (container) {
     if (!inventory) throw new CliError("INSTANCE_INVENTORY_MISSING", "existing container has no trusted inventory", EXIT.ENVIRONMENT);
-    assertOwnedContainer(container, inventory);
   }
   return {
     cliVersion: VERSION,
@@ -8959,9 +9933,9 @@ program2.name("wx").description("Single-instance agent-wechat CLI").version(VERS
 program2.showSuggestionAfterError();
 program2.configureOutput({ outputError: (text) => process.stderr.write(text) });
 program2.exitOverride();
-program2.command("start").description("Start the compatible single-instance container").option("--image <reference>", `exact ${GHCR_IMAGE} semver tag or digest`).option("--pull", "pull and resolve the selected image").option("--offline", "offline mode; never pull").option("--proxy <url>", "transparent proxy URL").action((options) => action(async () => {
+program2.command("start").description("Start the compatible single-instance container").option("--image <reference>", `exact ${GHCR_IMAGE} semver/commit tag or digest`).option("--pull", "pull and resolve the selected image").option("--offline", "offline mode; never pull").option("--proxy <url>", "transparent proxy URL").option("--outbound-config <file>", "TOML outbound policy file (never logged)").option("--outbound-queue-capacity <count>", "outbound queue capacity").option("--outbound-disabled", "disable outbound sending").option("--outbound-quiet-start <minutes>", "quiet-hours start minute").option("--outbound-quiet-end <minutes>", "quiet-hours end minute").option("--outbound-hourly-budget <count>", "hourly outbound budget").option("--outbound-daily-budget <count>", "daily outbound budget").option("--outbound-chat-cooldown-ms <ms>", "per-chat cooldown").option("--outbound-min-spacing-ms <ms>", "minimum spacing").option("--outbound-jitter-ms <ms>", "spacing jitter").option("--outbound-long-tail-jitter-ms <ms>", "long-tail jitter").option("--outbound-long-tail-chance-percent <percent>", "long-tail chance").option("--outbound-task-ttl-ms <ms>", "task TTL").option("--outbound-idempotency-ttl-ms <ms>", "idempotency TTL").option("--outbound-idempotency-max-rows <rows>", "idempotency max rows").action((options) => action(async () => {
   if (options.pull && options.offline) throw new CliError("ARGUMENT_CONFLICT", "--pull and --offline are mutually exclusive", EXIT.ARGUMENT);
-  const inventory = await startInstance({ identity: ensureDeviceIdentity(CONFIG_DIR), token: ensureToken(), localDefault: localBuildImage(), noPull: options.offline === true, ...options });
+  const inventory = await startInstance({ identity: ensureDeviceIdentity(CONFIG_DIR), token: ensureToken(), localDefault: localBuildImage(), noPull: options.offline === true, outbound: resolveOutboundConfig(options.outboundConfig, Object.fromEntries([["AGENT_WECHAT_OUTBOUND_QUEUE_CAPACITY", options.outboundQueueCapacity], ["AGENT_WECHAT_OUTBOUND_DISABLED", options.outboundDisabled ? "true" : void 0], ["AGENT_WECHAT_QUIET_START_MIN", options.outboundQuietStart], ["AGENT_WECHAT_QUIET_END_MIN", options.outboundQuietEnd], ["AGENT_WECHAT_HOURLY_BUDGET", options.outboundHourlyBudget], ["AGENT_WECHAT_DAILY_BUDGET", options.outboundDailyBudget], ["AGENT_WECHAT_CHAT_COOLDOWN_MS", options.outboundChatCooldownMs], ["AGENT_WECHAT_OUTBOUND_MIN_SPACING_MS", options.outboundMinSpacingMs], ["AGENT_WECHAT_OUTBOUND_JITTER_MS", options.outboundJitterMs], ["AGENT_WECHAT_OUTBOUND_LONG_TAIL_JITTER_MS", options.outboundLongTailJitterMs], ["AGENT_WECHAT_OUTBOUND_LONG_TAIL_CHANCE_PERCENT", options.outboundLongTailChancePercent], ["AGENT_WECHAT_OUTBOUND_TASK_TTL_MS", options.outboundTaskTtlMs], ["AGENT_WECHAT_OUTBOUND_IDEMPOTENCY_TTL_MS", options.outboundIdempotencyTtlMs], ["AGENT_WECHAT_OUTBOUND_IDEMPOTENCY_MAX_ROWS", options.outboundIdempotencyMaxRows]].filter(([, v]) => v !== void 0))), ...options });
   output({ container: inventory.containerName, imageDigest: inventory.imageDigest, port: inventory.port }, () => console.log(`Started ${inventory.containerName} on port ${inventory.port}`));
 }));
 program2.command("stop").description("Stop and remove the container; preserve data unless --purge").option("--purge", "delete every resource in the trusted default-instance inventory").option("--yes", "skip only the interactive confirmation").action((options) => action(async () => {
@@ -8976,12 +9950,59 @@ program2.command("stop").description("Stop and remove the container; preserve da
     output(result, () => console.log(result.stopped ? "Container stopped and removed" : "Container is absent"));
   }
 }));
-program2.command("restart").description("Restart while preserving data").action(() => action(async () => {
+program2.command("restart").description("Restart while preserving data").option("--outbound-config <file>", "TOML outbound policy file (never logged)").option("--outbound-queue-capacity <count>", "outbound queue capacity").option("--outbound-disabled", "disable outbound sending").option("--outbound-quiet-start <minutes>").option("--outbound-quiet-end <minutes>").option("--outbound-hourly-budget <count>").option("--outbound-daily-budget <count>").option("--outbound-chat-cooldown-ms <ms>").option("--outbound-min-spacing-ms <ms>").option("--outbound-jitter-ms <ms>").option("--outbound-long-tail-jitter-ms <ms>").option("--outbound-long-tail-chance-percent <percent>").option("--outbound-task-ttl-ms <ms>").option("--outbound-idempotency-ttl-ms <ms>").option("--outbound-idempotency-max-rows <rows>").action((options) => action(async () => {
   const inventory = loadInventory();
   if (!inventory) throw new CliError("INSTANCE_INVENTORY_MISSING", "start the instance first", EXIT.SERVICE);
-  stopInstance();
-  const result = await startInstance({ identity: ensureDeviceIdentity(CONFIG_DIR), token: ensureToken(), image: inventory.imageDigest || inventory.imageRef, noPull: true, localDefault: localBuildImage() });
-  output({ restarted: true, imageDigest: result.imageDigest }, () => console.log("Instance restarted"));
+  const oldContainer = inspectContainer();
+  const cliOverrides = Object.fromEntries([
+    ["AGENT_WECHAT_OUTBOUND_QUEUE_CAPACITY", options.outboundQueueCapacity],
+    ["AGENT_WECHAT_OUTBOUND_DISABLED", options.outboundDisabled ? "true" : void 0],
+    ["AGENT_WECHAT_QUIET_START_MIN", options.outboundQuietStart],
+    ["AGENT_WECHAT_QUIET_END_MIN", options.outboundQuietEnd],
+    ["AGENT_WECHAT_HOURLY_BUDGET", options.outboundHourlyBudget],
+    ["AGENT_WECHAT_DAILY_BUDGET", options.outboundDailyBudget],
+    ["AGENT_WECHAT_CHAT_COOLDOWN_MS", options.outboundChatCooldownMs],
+    ["AGENT_WECHAT_OUTBOUND_MIN_SPACING_MS", options.outboundMinSpacingMs],
+    ["AGENT_WECHAT_OUTBOUND_JITTER_MS", options.outboundJitterMs],
+    ["AGENT_WECHAT_OUTBOUND_LONG_TAIL_JITTER_MS", options.outboundLongTailJitterMs],
+    ["AGENT_WECHAT_OUTBOUND_LONG_TAIL_CHANCE_PERCENT", options.outboundLongTailChancePercent],
+    ["AGENT_WECHAT_OUTBOUND_TASK_TTL_MS", options.outboundTaskTtlMs],
+    ["AGENT_WECHAT_OUTBOUND_IDEMPOTENCY_TTL_MS", options.outboundIdempotencyTtlMs],
+    ["AGENT_WECHAT_OUTBOUND_IDEMPOTENCY_MAX_ROWS", options.outboundIdempotencyMaxRows]
+  ].filter(([, v]) => v !== void 0));
+  const outbound = resolveOutboundConfig(options.outboundConfig, cliOverrides);
+  const oldOutbound = oldContainer ? outboundFromContainer(oldContainer) : {};
+  const effectiveOutbound = { ...oldOutbound, ...outbound };
+  const previousInventory = inventory;
+  const rollbackName = `${CONTAINER_NAME}-rollback`;
+  let oldStopped = false;
+  let oldRenamed = false;
+  try {
+    if (oldContainer) {
+      if (oldContainer.State?.Running) {
+        stopContainer(oldContainer.Id);
+        oldStopped = true;
+      }
+      renameContainer(oldContainer.Id, rollbackName);
+      oldRenamed = true;
+    }
+    const result = await startInstance({ identity: ensureDeviceIdentity(CONFIG_DIR), token: ensureToken(), image: inventory.imageDigest || inventory.imageRef, noPull: true, localDefault: localBuildImage(), outbound: effectiveOutbound });
+    if (oldRenamed) removeContainer(rollbackName);
+    output({ restarted: true, imageDigest: result.imageDigest }, () => console.log("Instance restarted"));
+  } catch (error) {
+    try {
+      const failed = inspectContainer();
+      if (failed && failed.Id !== oldContainer?.Id) removeContainer(failed.Id);
+      if (oldContainer) {
+        if (oldRenamed) renameContainer(rollbackName, CONTAINER_NAME);
+        if (oldStopped && oldContainer.State?.Running) startContainer(CONTAINER_NAME);
+      }
+      saveInventory(previousInventory);
+    } catch {
+      throw new CliError("ROLLBACK_FAILED", "restart failed and rollback was incomplete", EXIT.ROLLBACK);
+    }
+    throw error;
+  }
 }));
 program2.command("status").description("Show read-only lifecycle and authentication status").action(() => action(async () => {
   const status = programStatus();
@@ -9008,7 +10029,7 @@ program2.command("doctor").description("Run read-only environment and compatibil
   const checks = programStatus();
   checks.architecture = os2.arch();
   checks.token = readToken() ? "present" : "absent";
-  checks.configPermissions = fs4.existsSync(CONFIG_DIR) ? (fs4.statSync(CONFIG_DIR).mode & 511).toString(8) : "absent";
+  checks.configPermissions = fs5.existsSync(CONFIG_DIR) ? (fs5.statSync(CONFIG_DIR).mode & 511).toString(8) : "absent";
   if (checks.container === "running") {
     try {
       checks.health = (await fetch(`http://localhost:${DEFAULT_PORT}/health`)).ok ? "ok" : "failed";
@@ -9067,6 +10088,13 @@ chats.command("mark-read <chat-id>").action((chatId) => action(async () => {
   if (!result.ok) throw new CliError(result.errorCode || "MARK_READ_FAILED", result.error || "mark-read was not verified", EXIT.SERVICE);
   output(result, () => console.log(`${chatId}: ${result.beforeUnread} -> ${result.afterUnread}`));
 }));
+chats.command("members <group-id>").description("List a bounded page of group members read-only").option("--limit <number>", "page size", "50").option("--cursor <cursor>", "opaque next-page cursor").action((groupId, options) => action(async () => {
+  const page = await client().listGroupMembersPage(groupId, integer(options.limit, "limit", 1, 100), options.cursor);
+  output(page, () => {
+    for (const member of page.items) console.log(`${member.memberId}	${member.displayName}	${member.groupAlias ?? ""}`);
+    if (page.nextCursor) console.error(`next cursor: ${page.nextCursor}`);
+  });
+}));
 var contacts = program2.command("contacts").description("List contacts read-only").option("--limit <number>", "page size", "200").option("--cursor <cursor>", "opaque next-page cursor").action((options) => action(async () => {
   const page = await client().listContactsPage(integer(options.limit, "limit", 1, 200), options.cursor);
   output(page, () => {
@@ -9083,8 +10111,8 @@ program2.command("messages <chat-id>").description("Read messages without openin
   output(page, () => renderMessages(page));
 }));
 program2.command("send <chat-id>").description("Send exactly one payload to a stable chat ID").option("--text <message>").option("--image <path>").option("--file <path>").option("--idempotency-key <key>", "stable key for retry/reconciliation").option("--confirm-similar", "confirm operator-reviewed similar text").action((chatId, options) => action(async () => {
-  const image = options.image ? { data: regularUpload(options.image).toString("base64"), mimeType: path4.extname(options.image).toLowerCase() === ".jpg" ? "image/jpeg" : "image/png" } : void 0;
-  const file = options.file ? { data: regularUpload(options.file).toString("base64"), filename: path4.basename(options.file) } : void 0;
+  const image = options.image ? { data: regularUpload(options.image).toString("base64"), mimeType: path5.extname(options.image).toLowerCase() === ".jpg" ? "image/jpeg" : "image/png" } : void 0;
+  const file = options.file ? { data: regularUpload(options.file).toString("base64"), filename: path5.basename(options.file) } : void 0;
   let params;
   try {
     params = buildCliSendParams({ chatId, text: options.text, image, file, confirmSimilar: options.confirmSimilar, idempotencyKey: options.idempotencyKey });
@@ -9098,7 +10126,7 @@ program2.command("send <chat-id>").description("Send exactly one payload to a st
   }
   output(result, () => console.log("Message sent"));
 }));
-program2.command("upgrade").description("Check CLI/image upgrades without claiming atomic self-upgrade").addOption(new Option("--check", "read-only upgrade check")).addOption(new Option("--cli", "print an exact npm CLI upgrade command")).addOption(new Option("--image <reference>", "transactionally rebuild with an exact compatible image")).action((options) => action(async () => {
+program2.command("upgrade").description("Check CLI/image upgrades without claiming atomic self-upgrade").addOption(new Option("--check", "read-only upgrade check")).addOption(new Option("--cli", "print an exact npm CLI upgrade command")).addOption(new Option("--image <reference>", "transactionally rebuild with an exact semver/commit tag or digest")).action((options) => action(async () => {
   const selected = [options.check === true, options.cli === true, typeof options.image === "string"].filter(Boolean).length;
   if (selected > 1) throw new CliError("ARGUMENT_CONFLICT", "--check, --cli, and --image are mutually exclusive", EXIT.ARGUMENT);
   if (options.cli) {
@@ -9132,9 +10160,9 @@ for (const [oldName, replacement] of [["up", "start"], ["down", "stop"], ["updat
 }
 function sameEntrypoint(left, right) {
   try {
-    return fs4.realpathSync(left) === fs4.realpathSync(right);
+    return fs5.realpathSync(left) === fs5.realpathSync(right);
   } catch {
-    return path4.resolve(left) === path4.resolve(right);
+    return path5.resolve(left) === path5.resolve(right);
   }
 }
 if (process.argv[1] && sameEntrypoint(process.argv[1], fileURLToPath(import.meta.url))) {
@@ -9148,3 +10176,42 @@ if (process.argv[1] && sameEntrypoint(process.argv[1], fileURLToPath(import.meta
     process.exitCode = EXIT.SERVICE;
   });
 }
+/*! Bundled license information:
+
+smol-toml/dist/error.js:
+smol-toml/dist/util.js:
+smol-toml/dist/date.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/