@inline-openclaw/inline 0.0.43 → 0.0.45

package/dist/channel-plugin-api.js

@@ -6984,7 +6984,8 @@ class Chat$Type extends import_runtime4.MessageType {
       { no: 9, name: "date", kind: "scalar", opt: true, T: 3, L: 0 },
       { no: 10, name: "created_by", kind: "scalar", opt: true, T: 3, L: 0 },
       { no: 11, name: "parent_chat_id", kind: "scalar", opt: true, T: 3, L: 0 },
-      { no: 12, name: "parent_message_id", kind: "scalar", opt: true, T: 3, L: 0 }
+      { no: 12, name: "parent_message_id", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 13, name: "untitled", kind: "scalar", opt: true, T: 8 }
     ]);
   }
   create(value) {
@@ -7036,6 +7037,9 @@ class Chat$Type extends import_runtime4.MessageType {
         case 12:
           message.parentMessageId = reader.int64().toBigInt();
           break;
+        case 13:
+          message.untitled = reader.bool();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -7072,6 +7076,8 @@ class Chat$Type extends import_runtime4.MessageType {
       writer.tag(11, import_runtime.WireType.Varint).int64(message.parentChatId);
     if (message.parentMessageId !== undefined)
       writer.tag(12, import_runtime.WireType.Varint).int64(message.parentMessageId);
+    if (message.untitled !== undefined)
+      writer.tag(13, import_runtime.WireType.Varint).bool(message.untitled);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -11181,6 +11187,70 @@ class GetUpdatesInput$Type extends import_runtime4.MessageType {
 }
 var GetUpdatesInput = new GetUpdatesInput$Type;
 
+class UpdateSidecars$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateSidecars", [
+      { no: 1, name: "users", kind: "message", repeat: 1, T: () => User },
+      { no: 2, name: "chats", kind: "message", repeat: 1, T: () => Chat },
+      { no: 3, name: "dialogs", kind: "message", repeat: 1, T: () => Dialog },
+      { no: 4, name: "spaces", kind: "message", repeat: 1, T: () => Space }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.users = [];
+    message.chats = [];
+    message.dialogs = [];
+    message.spaces = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.users.push(User.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case 2:
+          message.chats.push(Chat.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case 3:
+          message.dialogs.push(Dialog.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case 4:
+          message.spaces.push(Space.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0;i < message.users.length; i++)
+      User.internalBinaryWrite(message.users[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0;i < message.chats.length; i++)
+      Chat.internalBinaryWrite(message.chats[i], writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0;i < message.dialogs.length; i++)
+      Dialog.internalBinaryWrite(message.dialogs[i], writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0;i < message.spaces.length; i++)
+      Space.internalBinaryWrite(message.spaces[i], writer.tag(4, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UpdateSidecars = new UpdateSidecars$Type;
+
 class GetUpdatesResult$Type extends import_runtime4.MessageType {
   constructor() {
     super("GetUpdatesResult", [
@@ -11188,7 +11258,8 @@ class GetUpdatesResult$Type extends import_runtime4.MessageType {
       { no: 2, name: "seq", kind: "scalar", T: 3, L: 0 },
       { no: 3, name: "date", kind: "scalar", T: 3, L: 0 },
       { no: 4, name: "final", kind: "scalar", opt: true, T: 8 },
-      { no: 5, name: "result_type", kind: "enum", T: () => ["GetUpdatesResult.ResultType", GetUpdatesResult_ResultType, "RESULT_TYPE_"] }
+      { no: 5, name: "result_type", kind: "enum", T: () => ["GetUpdatesResult.ResultType", GetUpdatesResult_ResultType, "RESULT_TYPE_"] },
+      { no: 6, name: "sidecars", kind: "message", T: () => UpdateSidecars }
     ]);
   }
   create(value) {
@@ -11221,6 +11292,9 @@ class GetUpdatesResult$Type extends import_runtime4.MessageType {
         case 5:
           message.resultType = reader.int32();
           break;
+        case 6:
+          message.sidecars = UpdateSidecars.internalBinaryRead(reader, reader.uint32(), options, message.sidecars);
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -11243,6 +11317,8 @@ class GetUpdatesResult$Type extends import_runtime4.MessageType {
       writer.tag(4, import_runtime.WireType.Varint).bool(message.final);
     if (message.resultType !== 0)
       writer.tag(5, import_runtime.WireType.Varint).int32(message.resultType);
+    if (message.sidecars)
+      UpdateSidecars.internalBinaryWrite(message.sidecars, writer.tag(6, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -15969,7 +16045,7 @@ var ReserveChatIdsResult = new ReserveChatIdsResult$Type;
 class CreateChatInput$Type extends import_runtime4.MessageType {
   constructor() {
     super("CreateChatInput", [
-      { no: 1, name: "title", kind: "scalar", T: 9 },
+      { no: 1, name: "title", kind: "scalar", opt: true, T: 9 },
       { no: 2, name: "space_id", kind: "scalar", opt: true, T: 3, L: 0 },
       { no: 3, name: "description", kind: "scalar", opt: true, T: 9 },
       { no: 4, name: "emoji", kind: "scalar", opt: true, T: 9 },
@@ -15980,7 +16056,6 @@ class CreateChatInput$Type extends import_runtime4.MessageType {
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.title = "";
     message.isPublic = false;
     message.participants = [];
     if (value !== undefined)
@@ -16025,7 +16100,7 @@ class CreateChatInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.title !== "")
+    if (message.title !== undefined)
       writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.title);
     if (message.spaceId !== undefined)
       writer.tag(2, import_runtime.WireType.Varint).int64(message.spaceId);
@@ -16875,7 +16950,8 @@ class UpdateChatInfo$Type extends import_runtime4.MessageType {
     super("UpdateChatInfo", [
       { no: 1, name: "chat_id", kind: "scalar", T: 3, L: 0 },
       { no: 2, name: "title", kind: "scalar", opt: true, T: 9 },
-      { no: 3, name: "emoji", kind: "scalar", opt: true, T: 9 }
+      { no: 3, name: "emoji", kind: "scalar", opt: true, T: 9 },
+      { no: 4, name: "untitled", kind: "scalar", opt: true, T: 8 }
     ]);
   }
   create(value) {
@@ -16899,6 +16975,9 @@ class UpdateChatInfo$Type extends import_runtime4.MessageType {
         case 3:
           message.emoji = reader.string();
           break;
+        case 4:
+          message.untitled = reader.bool();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -16917,6 +16996,8 @@ class UpdateChatInfo$Type extends import_runtime4.MessageType {
       writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.title);
     if (message.emoji !== undefined)
       writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.emoji);
+    if (message.untitled !== undefined)
+      writer.tag(4, import_runtime.WireType.Varint).bool(message.untitled);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -20982,7 +21063,7 @@ class InlineSdkClient {
       await this.handleUpdate(update);
     }
   }
-  async handleUpdate(update) {
+  async handleUpdate(update, options) {
     const seq = update.seq ?? 0;
     const date = update.date ?? 0n;
     switch (update.update.oneofKind) {
@@ -21114,6 +21195,34 @@ class InlineSdkClient {
         });
         return;
       }
+      case "participantAdd": {
+        const payload = update.update.participantAdd;
+        if (options?.source !== "user" && options?.source !== "space") {
+          this.bumpChatSeq(payload.chatId, seq);
+        }
+        await this.eventStream.send({
+          kind: "chat.participant.add",
+          chatId: payload.chatId,
+          ...payload.participant ? { participant: payload.participant } : {},
+          seq,
+          date
+        });
+        return;
+      }
+      case "participantDelete": {
+        const payload = update.update.participantDelete;
+        if (options?.source !== "user" && options?.source !== "space") {
+          this.bumpChatSeq(payload.chatId, seq);
+        }
+        await this.eventStream.send({
+          kind: "chat.participant.delete",
+          chatId: payload.chatId,
+          userId: payload.userId,
+          seq,
+          date
+        });
+        return;
+      }
       case "messageActionInvoked": {
         const payload = update.update.messageActionInvoked;
         if (this.shouldSkipUserSeq(seq)) {
@@ -21214,14 +21323,14 @@ class InlineSdkClient {
     }
   }
   requestCatchUpUser() {
-    const lastUserSeq = this.state.lastUserSeq ?? 0;
-    if (lastUserSeq <= 0) {
+    const lastUserSeq = this.state.lastUserSeq;
+    if (lastUserSeq == null && !this.options.catchUpUserFromStart) {
       return;
     }
     if (this.userCatchUpInFlight) {
       return;
     }
-    this.userCatchUpInFlight = this.doCatchUpUser(lastUserSeq).catch((error) => {
+    this.userCatchUpInFlight = this.doCatchUpUser(lastUserSeq ?? 0).catch((error) => {
       this.log.warn?.("GET_UPDATES user catch-up failed; continuing live delivery", {
         error: extractErrorMessage(error)
       });
@@ -21262,7 +21371,7 @@ class InlineSdkClient {
         return;
       }
       for (const update of payload.updates) {
-        await this.handleUpdate(update);
+        await this.handleUpdate(update, { source: "user" });
       }
       this.bumpUserSeq(deliveredSeq);
       if (payload.date !== 0n) {
@@ -21361,7 +21470,7 @@ class InlineSdkClient {
       }
       this.bumpChatSeq(chatId, deliveredSeq);
       for (const update of payload.updates) {
-        await this.handleUpdate(update);
+        await this.handleUpdate(update, { source: "chat" });
       }
       if (payload.date !== 0n) {
         this.state.dateCursor = payload.date;
@@ -21463,7 +21572,7 @@ class InlineSdkClient {
       }
       this.bumpSpaceSeq(spaceId, deliveredSeq);
       for (const update of payload.updates) {
-        await this.handleUpdate(update);
+        await this.handleUpdate(update, { source: "space" });
       }
       if (payload.date !== 0n) {
         this.state.dateCursor = payload.date;
@@ -36398,6 +36507,8 @@ var InlineExecApprovalsSchema = exports_external.object({
 var InlineReactionNotificationsSchema = exports_external.enum(["off", "own", "all", "allowlist"]);
 var InlineStreamingModeSchema = exports_external.enum(["off", "partial", "block", "progress"]);
 var InlineStreamingCommandTextSchema = exports_external.enum(["raw", "status"]);
+var INLINE_DEFAULT_GROUP_POLICY = "open";
+var INLINE_DEFAULT_REQUIRE_MENTION = true;
 var InlineStreamingChunkSchema = exports_external.object({
   minChars: exports_external.number().int().positive().optional(),
   maxChars: exports_external.number().int().positive().optional(),
@@ -36469,7 +36580,7 @@ var InlineAccountSchemaBase = exports_external.object({
   defaultTo: InlineTargetSchema.optional(),
   systemPrompt: exports_external.string().optional(),
   groupAllowFrom: exports_external.array(InlineAllowEntrySchema).optional(),
-  groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+  groupPolicy: GroupPolicySchema.optional().default(INLINE_DEFAULT_GROUP_POLICY),
   groups: exports_external.record(exports_external.string(), InlineGroupSchema.optional()).optional(),
   requireMention: exports_external.boolean().optional(),
   replyThreadMode: InlineReplyThreadModeSchema.optional(),
@@ -36968,7 +37079,7 @@ function looksLikeInlineTargetId(raw, normalizedInput) {
 }
 
 // src/inline/monitor.ts
-import { mkdir } from "node:fs/promises";
+import { mkdir, stat } from "node:fs/promises";
 import path4 from "node:path";
 import {
   buildCommandTextFromArgs,
@@ -40823,11 +40934,339 @@ function redactInlineBotApiUrl(raw) {
   }
 }
 
+// src/inline/threadreply-command.ts
+var MODE_LABELS = {
+  auto: "auto",
+  thread: "thread",
+  main: "main"
+};
+var DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES = 50;
+var INLINE_THREADREPLY_NATIVE_NAME = "threadreply";
+var INLINE_THREADREPLY_COMMAND_SPEC = {
+  name: "threadreply",
+  nativeNames: { inline: INLINE_THREADREPLY_NATIVE_NAME },
+  description: "Set Inline reply-thread mode for this chat.",
+  channels: ["inline"],
+  acceptsArgs: true
+};
+function listInlineBuiltinCommandSpecs() {
+  return [
+    {
+      name: INLINE_THREADREPLY_COMMAND_SPEC.nativeNames.inline ?? INLINE_THREADREPLY_COMMAND_SPEC.name,
+      description: INLINE_THREADREPLY_COMMAND_SPEC.description,
+      acceptsArgs: INLINE_THREADREPLY_COMMAND_SPEC.acceptsArgs
+    }
+  ];
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asInlineConfig(value) {
+  return isRecord5(value) ? value : undefined;
+}
+function normalizeMode(raw) {
+  if (typeof raw !== "string")
+    return null;
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "on" || normalized === "threads")
+    return "thread";
+  if (normalized === "off" || normalized === "parent" || normalized === "parentchat")
+    return "main";
+  if (normalized === "auto" || normalized === "thread" || normalized === "main")
+    return normalized;
+  return null;
+}
+function normalizeMin(raw) {
+  if (typeof raw !== "number")
+    return null;
+  if (!Number.isInteger(raw) || raw < 0)
+    return null;
+  return raw;
+}
+function parseMinArg(raw) {
+  const value = raw?.trim().toLowerCase();
+  if (!value)
+    return null;
+  if (value === "inherit" || value === "default" || value === "unset")
+    return "inherit";
+  if (!/^\d+$/.test(value))
+    return null;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
+function resolveInlineGroupId(ctx) {
+  const raw = ctx.from?.trim() ?? "";
+  if (!/(^|:)chat:/i.test(raw))
+    return null;
+  const normalized = normalizeInlineTarget(raw);
+  return normalized && /^[0-9]+$/.test(normalized) ? normalized : null;
+}
+function resolveInlineConfigForAccount(inline, accountId) {
+  const normalized = normalizeAccountId(accountId);
+  const accounts = isRecord5(inline.accounts) ? inline.accounts : undefined;
+  const accountKey = accounts ? Object.keys(accounts).find((key) => normalizeAccountId(key) === normalized) : undefined;
+  if (accountKey && accounts?.[accountKey]) {
+    return accounts[accountKey];
+  }
+  if (normalized !== DEFAULT_ACCOUNT_ID) {
+    return {};
+  }
+  return inline;
+}
+function resolveCurrentMode(params) {
+  const inline = asInlineConfig(params.cfg.channels?.inline) ?? {};
+  const accountConfig = resolveInlineConfigForAccount(inline, params.accountId);
+  return resolveInlineGroupReplyThreadMode({
+    cfg: params.cfg,
+    accountId: params.accountId ?? null,
+    groupId: params.groupId,
+    defaultMode: normalizeMode(accountConfig.replyThreadMode) ?? "auto"
+  });
+}
+function resolveCurrentMinMessages(params) {
+  const inline = asInlineConfig(params.cfg.channels?.inline) ?? {};
+  const accountConfig = resolveInlineConfigForAccount(inline, params.accountId);
+  return resolveInlineGroupReplyThreadAutoCreateMinMessages({
+    cfg: params.cfg,
+    accountId: params.accountId ?? null,
+    groupId: params.groupId,
+    defaultMinMessages: normalizeMin(accountConfig.replyThreadAutoCreateMinMessages) ?? DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES
+  });
+}
+function readExplicitMode(params) {
+  const inline = asInlineConfig(params.cfg.channels?.inline);
+  if (!inline)
+    return null;
+  const accountConfig = resolveInlineConfigForAccount(inline, params.accountId);
+  const group = accountConfig.groups?.[params.groupId];
+  return normalizeMode(group?.replyThreadMode);
+}
+function readExplicitMinMessages(params) {
+  const inline = asInlineConfig(params.cfg.channels?.inline);
+  if (!inline)
+    return null;
+  const accountConfig = resolveInlineConfigForAccount(inline, params.accountId);
+  const group = accountConfig.groups?.[params.groupId];
+  return normalizeMin(group?.replyThreadAutoCreateMinMessages);
+}
+function ensureRecordField(parent, key) {
+  const current = parent[key];
+  if (isRecord5(current))
+    return current;
+  const next = {};
+  parent[key] = next;
+  return next;
+}
+function resolveMutableInlineConfigForAccount(inline, accountId) {
+  const normalized = normalizeAccountId(accountId);
+  if (normalized === DEFAULT_ACCOUNT_ID) {
+    const accounts2 = isRecord5(inline.accounts) ? inline.accounts : undefined;
+    const defaultKey = accounts2 ? Object.keys(accounts2).find((key) => normalizeAccountId(key) === DEFAULT_ACCOUNT_ID) : undefined;
+    const defaultAccount = defaultKey ? accounts2?.[defaultKey] : undefined;
+    return defaultAccount ?? inline;
+  }
+  const accounts = ensureRecordField(inline, "accounts");
+  const accountKey = Object.keys(accounts).find((key) => normalizeAccountId(key) === normalized) ?? normalized;
+  const account = asInlineConfig(accounts[accountKey]) ?? {};
+  accounts[accountKey] = account;
+  return account;
+}
+function setGroupMode(params) {
+  const root = params.draft;
+  const channels = root.channels ?? {};
+  root.channels = channels;
+  const inline = asInlineConfig(channels.inline) ?? {};
+  channels.inline = inline;
+  const accountConfig = resolveMutableInlineConfigForAccount(inline, params.accountId);
+  const groups = ensureRecordField(accountConfig, "groups");
+  const group = isRecord5(groups[params.groupId]) ? groups[params.groupId] : {};
+  groups[params.groupId] = group;
+  if (params.mode === "inherit") {
+    delete group.replyThreadMode;
+    return;
+  }
+  group.replyThreadMode = params.mode;
+}
+function setGroupMinMessages(params) {
+  const root = params.draft;
+  const channels = root.channels ?? {};
+  root.channels = channels;
+  const inline = asInlineConfig(channels.inline) ?? {};
+  channels.inline = inline;
+  const accountConfig = resolveMutableInlineConfigForAccount(inline, params.accountId);
+  const groups = ensureRecordField(accountConfig, "groups");
+  const group = isRecord5(groups[params.groupId]) ? groups[params.groupId] : {};
+  groups[params.groupId] = group;
+  if (params.minMessages === "inherit") {
+    delete group.replyThreadAutoCreateMinMessages;
+    return;
+  }
+  group.replyThreadAutoCreateMinMessages = params.minMessages;
+}
+function buildStatusText(params) {
+  const explicit = readExplicitMode(params);
+  const current = resolveCurrentMode(params);
+  const explicitMin = readExplicitMinMessages(params);
+  const currentMin = resolveCurrentMinMessages(params);
+  return [
+    `Thread reply mode for chat ${params.groupId}: ${MODE_LABELS[current]}.`,
+    explicit ? `Explicit chat override: ${MODE_LABELS[explicit]}.` : "Explicit chat override: inherit.",
+    `Auto-create minimum messages: ${currentMin}.`,
+    explicitMin != null ? `Explicit minimum override: ${explicitMin}.` : "Explicit minimum override: inherit."
+  ].join(`
+`);
+}
+function buildMenuText(params) {
+  return [
+    buildStatusText(params),
+    "",
+    "Choose where automatic replies for this group should go."
+  ].join(`
+`);
+}
+function buildModeButtons() {
+  return {
+    inline: {
+      buttons: [
+        [
+          { text: "Thread", callback_data: "/threadreply thread" },
+          { text: "Main", callback_data: "/threadreply main" },
+          { text: "Auto", callback_data: "/threadreply auto" }
+        ],
+        [{ text: "Inherit Mode", callback_data: "/threadreply inherit" }],
+        [
+          { text: "Min 0", callback_data: "/threadreply min 0" },
+          { text: "Min 50", callback_data: "/threadreply min 50" },
+          { text: "Inherit Min", callback_data: "/threadreply min inherit" }
+        ]
+      ]
+    }
+  };
+}
+function normalizeAction(args) {
+  const [first = ""] = args.split(/\s+/).filter(Boolean);
+  const normalized = first.trim().toLowerCase();
+  if (!normalized || normalized === "help" || normalized === "options")
+    return "help";
+  if (normalized === "status" || normalized === "show")
+    return "status";
+  if (normalized === "inherit" || normalized === "default" || normalized === "unset")
+    return "inherit";
+  return normalizeMode(normalized);
+}
+async function handleInlineThreadReplyCommand(api2, ctx) {
+  return await handleInlineThreadReplyCommandWithConfigRuntime(api2.runtime.config, ctx);
+}
+async function handleInlineThreadReplyCommandWithConfigRuntime(configRuntime, ctx) {
+  if (!ctx.isAuthorizedSender) {
+    return { text: "This command requires authorization." };
+  }
+  const groupId = resolveInlineGroupId(ctx);
+  if (!groupId) {
+    return { text: "/threadreply is only available in Inline group chats." };
+  }
+  const currentConfig = configRuntime.current();
+  const args = ctx.args?.trim() ?? "";
+  const [first = "", second, ...rest] = args.split(/\s+/).filter(Boolean);
+  if (["min", "minimum", "threshold", "limit"].includes(first.trim().toLowerCase())) {
+    const minMessages = parseMinArg(second);
+    if (minMessages == null || rest.length > 0) {
+      return { text: "Usage: /threadreply min <0-or-greater>|inherit" };
+    }
+    const committed2 = await configRuntime.mutateConfigFile({
+      afterWrite: { mode: "auto" },
+      mutate: (draft) => {
+        setGroupMinMessages({
+          draft,
+          accountId: ctx.accountId,
+          groupId,
+          minMessages
+        });
+      }
+    });
+    const nextConfig2 = committed2.nextConfig;
+    return {
+      text: buildStatusText({
+        cfg: nextConfig2,
+        accountId: ctx.accountId,
+        groupId
+      })
+    };
+  }
+  const action = normalizeAction(args);
+  if (action === "help") {
+    return {
+      text: buildMenuText({
+        cfg: currentConfig,
+        accountId: ctx.accountId,
+        groupId
+      }),
+      channelData: buildModeButtons()
+    };
+  }
+  if (action === "status") {
+    return {
+      text: buildStatusText({
+        cfg: currentConfig,
+        accountId: ctx.accountId,
+        groupId
+      })
+    };
+  }
+  if (!action) {
+    return {
+      text: [
+        "Usage: /threadreply thread|main|auto|inherit|status",
+        "       /threadreply min <0-or-greater>|inherit",
+        "",
+        "- thread: auto-route parent-chat replies into per-message Inline reply threads once the minimum is reached.",
+        "- main: keep automatic replies in the parent chat.",
+        "- auto: use Inline's automatic default behavior for this chat.",
+        "- inherit: remove this chat override and use account/default config.",
+        "- min: set how many parent-chat messages must exist before automatic thread creation."
+      ].join(`
+`)
+    };
+  }
+  const committed = await configRuntime.mutateConfigFile({
+    afterWrite: { mode: "auto" },
+    mutate: (draft) => {
+      setGroupMode({
+        draft,
+        accountId: ctx.accountId,
+        groupId,
+        mode: action
+      });
+    }
+  });
+  const nextConfig = committed.nextConfig;
+  return {
+    text: buildStatusText({
+      cfg: nextConfig,
+      accountId: ctx.accountId,
+      groupId
+    })
+  };
+}
+function createInlineThreadReplyCommand(api2) {
+  return {
+    ...INLINE_THREADREPLY_COMMAND_SPEC,
+    handler: async (ctx) => await handleInlineThreadReplyCommand(api2, ctx)
+  };
+}
+
 // src/inline/bot-commands-sync.ts
 var INLINE_COMMAND_NAME_RE = /^[a-z0-9_]{1,32}$/;
 var INLINE_COMMAND_LIMIT = 100;
 var INLINE_COMMAND_DESCRIPTION_LIMIT = 256;
 var INLINE_NATIVE_COMMAND_PROVIDER = "inline";
+function resolveInlineChannelCommands(cfg) {
+  const inline = cfg.channels?.inline;
+  if (typeof inline !== "object" || inline === null || Array.isArray(inline))
+    return;
+  const commands = inline.commands;
+  return typeof commands === "object" && commands !== null && !Array.isArray(commands) ? commands : undefined;
+}
 function normalizeDynamicCommandName(raw) {
   const trimmed = raw.trim().toLowerCase();
   const withoutSlash = trimmed.startsWith("/") ? trimmed.slice(1) : trimmed;
@@ -40848,11 +41287,11 @@ function appendUniqueCommand(out, seen, command, description, logger) {
   out.push({ command: normalized, description: trimmedDescription });
 }
 function shouldSyncInlineNativeCommandsForAccount(params) {
-  const effective = params.account.config.commands?.native ?? params.cfg.commands?.native ?? "auto";
+  const effective = params.account.config.commands?.native ?? resolveInlineChannelCommands(params.cfg)?.native ?? params.cfg.commands?.native ?? "auto";
   return effective !== false;
 }
 function shouldSyncInlineNativeSkillsForAccount(params) {
-  const effective = params.account.config.commands?.nativeSkills ?? params.cfg.commands?.nativeSkills ?? "auto";
+  const effective = params.account.config.commands?.nativeSkills ?? resolveInlineChannelCommands(params.cfg)?.nativeSkills ?? params.cfg.commands?.nativeSkills ?? "auto";
   return effective !== false;
 }
 async function buildInlineNativeCommandsForConfig(params) {
@@ -40869,7 +41308,10 @@ async function buildInlineNativeCommandsForConfig(params) {
     skillCommands,
     provider: INLINE_NATIVE_COMMAND_PROVIDER
   });
-  const pluginSpecs = getPluginCommandSpecs("inline", { config: params.cfg });
+  const pluginSpecs = [
+    ...getPluginCommandSpecs("inline", { config: params.cfg }),
+    ...listInlineBuiltinCommandSpecs()
+  ];
   const seen = new Set;
   const resolved = [];
   for (const spec of nativeSpecs) {
@@ -40973,8 +41415,10 @@ var INLINE_NATIVE_COMMAND_PROVIDER2 = CHANNEL_ID;
 var INLINE_NATIVE_COMMAND_CALLBACK_PREFIX = "icmd:";
 var INLINE_REQUEST_ERROR_FALLBACK = "OpenClaw could not process that request. Please try again.";
 var INLINE_DEBOUNCE_ERROR_FALLBACK = "OpenClaw could not process those messages. Please try again.";
-var DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES = 50;
+var DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES2 = 50;
 var DEFAULT_REPLY_THREAD_PARENT_HISTORY_LIMIT = 10;
+var INLINE_PARTICIPANT_ADD_READY_MAX_EVENT_AGE_MS = 10 * 60 * 1000;
+var INLINE_REPLY_THREAD_SYSTEM_PROMPT = "Inline reply threads are scoped conversations: answer only the current reply-thread message and this thread's own history; use parent-chat context only as background, and do not answer unrelated questions from the parent chat or other reply threads.";
 function buildInlineTypingDispatcherOptions(typingCallbacks) {
   if (!typingCallbacks) {
     return {};
@@ -41287,6 +41731,23 @@ function buildInlineReactionContextKey(params) {
   const emoji3 = params.emoji.trim() || "emoji";
   return `inline:reaction:${params.action}:${String(params.chatId)}:${String(params.messageId)}:${String(params.senderId)}:${emoji3}`;
 }
+function describeInlineParticipantAddSystemEvent(params) {
+  const header = `Inline bot was added as a participant in ${params.channelLabel}.`;
+  if (params.recentLines.length === 0)
+    return header;
+  return `${header}
+Recent messages before join:
+${params.recentLines.join(`
+`)}`;
+}
+function buildInlineParticipantAddContextKey(params) {
+  return [
+    "inline:participant:added",
+    String(params.chatId),
+    String(params.userId),
+    params.participantDate != null ? String(params.participantDate) : String(params.seq ?? 0)
+  ].join(":");
+}
 function normalizeInlineUsername(raw) {
   const trimmed = raw?.trim();
   if (!trimmed)
@@ -41328,6 +41789,28 @@ function parseInlineNativeCommandCallbackData(raw) {
   const commandText = trimmed.slice(INLINE_NATIVE_COMMAND_CALLBACK_PREFIX.length).trim();
   return commandText.startsWith("/") ? commandText : null;
 }
+function listHostInlinePluginCommandSpecs(cfg) {
+  return getPluginCommandSpecs2("inline", { config: cfg });
+}
+function listInlinePluginCommandSpecs(cfg) {
+  return [
+    ...listHostInlinePluginCommandSpecs(cfg),
+    ...listInlineBuiltinCommandSpecs()
+  ];
+}
+function hasInlineCommandSpec(specs, commandName) {
+  const normalized = commandName.trim().toLowerCase();
+  if (!normalized)
+    return false;
+  return specs.some((spec) => spec.name.trim().toLowerCase() === normalized);
+}
+function isInlineThreadReplyCommandBody(commandBody) {
+  return resolveInlineCommandNameFromBody(commandBody) === "threadreply";
+}
+function parseInlineCommandArgs(commandBody) {
+  const match = commandBody.trim().match(/^\/[^\s]+(?:\s+([\s\S]*))?$/);
+  return match?.[1]?.trim() ?? "";
+}
 function isInlineNativeCommandBody(params) {
   if (!shouldSyncInlineNativeCommandsForAccount({ cfg: params.cfg, account: params.account })) {
     return false;
@@ -41350,7 +41833,7 @@ function isInlineNativeCommandBody(params) {
     if (spec.name.trim().toLowerCase() === commandName)
       return true;
   }
-  for (const spec of getPluginCommandSpecs2("inline", { config: params.cfg })) {
+  for (const spec of listInlinePluginCommandSpecs(params.cfg)) {
     if (spec.name.trim().toLowerCase() === commandName)
       return true;
   }
@@ -41431,7 +41914,7 @@ function buildSyntheticInlineTextMessage(params) {
 }
 var INLINE_ACTION_MAX_ROWS2 = 8;
 var INLINE_ACTION_MAX_PER_ROW2 = 8;
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeOptionalString2(value) {
@@ -41452,7 +41935,7 @@ function normalizeInlineStreamingMode(value) {
   }
 }
 function resolveExplicitInlineStreamingMode(config2) {
-  const streaming = isRecord5(config2.streaming) ? config2.streaming : null;
+  const streaming = isRecord6(config2.streaming) ? config2.streaming : null;
   return normalizeInlineStreamingMode(streaming?.mode) ?? normalizeInlineStreamingMode(config2.streaming) ?? normalizeInlineStreamingMode(config2.streamMode);
 }
 function resolveInlineStreamingMode(config2) {
@@ -41472,14 +41955,14 @@ function resolveInlineProgressPlaceholderEnabled(config2) {
     return true;
   if (config2.streaming === false)
     return false;
-  if (isRecord5(config2.streaming) && isRecord5(config2.streaming.progress))
+  if (isRecord6(config2.streaming) && isRecord6(config2.streaming.progress))
     return true;
   return config2.streaming === undefined && config2.streamMode === undefined && config2.streamViaEditMessage !== true;
 }
 function resolveInlineBlockStreamingEnabled(config2) {
   const mode = resolveInlineStreamingMode(config2);
-  const streaming = isRecord5(config2.streaming) ? config2.streaming : null;
-  const block = streaming && isRecord5(streaming.block) ? streaming.block : null;
+  const streaming = isRecord6(config2.streaming) ? config2.streaming : null;
+  const block = streaming && isRecord6(streaming.block) ? streaming.block : null;
   if (typeof block?.enabled === "boolean")
     return block.enabled;
   if (typeof config2.blockStreaming === "boolean")
@@ -41703,7 +42186,7 @@ function normalizeReplyMarkupButtonsWith(raw, options) {
       continue;
     const row = [];
     for (const candidateButton of candidateRow) {
-      if (!isRecord5(candidateButton))
+      if (!isRecord6(candidateButton))
         continue;
       const text = sanitizeInlineActionLabel(typeof candidateButton.text === "string" ? candidateButton.text : "");
       const callbackDataRaw = typeof candidateButton.callback_data === "string" ? candidateButton.callback_data.trim() : "";
@@ -41724,9 +42207,9 @@ function normalizeReplyMarkupButtonsWith(raw, options) {
   return rows;
 }
 function resolveInlineReplyActions(payload) {
-  const channelData = isRecord5(payload.channelData) ? payload.channelData : undefined;
-  const inlineData = channelData && isRecord5(channelData.inline) ? channelData.inline : undefined;
-  const telegramData = channelData && isRecord5(channelData.telegram) ? channelData.telegram : undefined;
+  const channelData = isRecord6(payload.channelData) ? payload.channelData : undefined;
+  const inlineData = channelData && isRecord6(channelData.inline) ? channelData.inline : undefined;
+  const telegramData = channelData && isRecord6(channelData.telegram) ? channelData.telegram : undefined;
   let rawButtons = undefined;
   let hasExplicitButtons = false;
   let mapCallbackData;
@@ -41792,7 +42275,11 @@ function resolveInlineSystemPrompt(params) {
     groups: params.account.config.groups,
     groupId: params.groupId
   }) : undefined;
-  return [buildInlineSystemPrompt(params.account.config.systemPrompt), groupPrompt].filter((entry) => Boolean(entry)).join(`
+  return [
+    buildInlineSystemPrompt(params.account.config.systemPrompt),
+    groupPrompt,
+    params.replyThread ? INLINE_REPLY_THREAD_SYSTEM_PROMPT : undefined
+  ].filter((entry) => Boolean(entry)).join(`
 
 `);
 }
@@ -42231,13 +42718,6 @@ function buildInlineInboundBodyText(content) {
 `).trim();
   return textWithPlaceholder || content.text;
 }
-function hasDownloadableInlineMedia(content) {
-  if (!content)
-    return false;
-  if (content.media?.url)
-    return true;
-  return content.attachments.some((attachment) => attachment.kind === "urlPreview" && Boolean(attachment.previewImageUrl));
-}
 function resolveFilePathHint(params) {
   const preferred = params.preferredName?.trim();
   if (preferred)
@@ -42275,8 +42755,9 @@ async function resolveInlineInboundMedia(params) {
         maxBytes: params.maxBytes,
         ...filePathHint ? { filePathHint } : {}
       });
-      const saved = await params.core.channel.media.saveMediaBuffer(fetched.buffer, fetched.contentType ?? candidate.mimeType ?? undefined, "inbound", params.maxBytes, fetched.fileName ?? candidate.fileName ?? undefined);
-      const contentType = saved.contentType ?? fetched.contentType ?? candidate.mimeType ?? undefined;
+      const fetchedContentType = fetched.contentType ?? candidate.mimeType ?? undefined;
+      const saved = await params.core.channel.media.saveMediaBuffer(fetched.buffer, fetchedContentType, "inbound", params.maxBytes, fetched.fileName ?? candidate.fileName ?? undefined);
+      const contentType = saved.contentType ?? fetchedContentType;
       out.push({
         path: saved.path,
         ...contentType ? { contentType } : {}
@@ -42477,6 +42958,34 @@ ${entityLines.slice(-ATTACHMENT_CONTEXT_LIMIT).join(`
     hasBotMessage
   };
 }
+function buildInlineRecentHistoryLines(params) {
+  if (params.maxLines <= 0)
+    return [];
+  return params.messages.slice().sort((a, b) => {
+    const byDate = Number(a.date - b.date);
+    if (byDate !== 0)
+      return byDate;
+    if (a.id === b.id)
+      return 0;
+    return a.id < b.id ? -1 : 1;
+  }).map((message) => buildInlineHistoryEntryPayload({
+    message,
+    senderProfilesById: params.senderProfilesById,
+    meId: params.meId
+  })).map((entry) => entry.line ?? entry.attachmentLine ?? entry.entityLine).filter((line) => Boolean(line)).slice(-params.maxLines);
+}
+function buildInlineParticipantAddReadyText(botUsername) {
+  const mention = botUsername ? `@${botUsername}` : "me";
+  return `I'm here and ready. Mention ${mention} to ask me something.`;
+}
+function shouldSendInlineParticipantAddReadyMessage(participantDate, now = Date.now()) {
+  if (participantDate == null)
+    return true;
+  const eventMs = Number(participantDate) * 1000;
+  if (!Number.isFinite(eventMs) || eventMs <= 0)
+    return true;
+  return now - eventMs <= INLINE_PARTICIPANT_ADD_READY_MAX_EVENT_AGE_MS;
+}
 async function monitorInlineProvider(params) {
   const { cfg, account, runtime, abortSignal, log, statusSink } = params;
   const core3 = getInlineRuntime();
@@ -42486,6 +42995,7 @@ async function monitorInlineProvider(params) {
   const token = await resolveInlineToken(account);
   const stateDir = core3.state.resolveStateDir();
   const statePath = path4.join(stateDir, "channels", "inline", `${account.accountId}.json`);
+  const hasExistingState = await stat(statePath).then(() => true).catch(() => false);
   await mkdir(path4.dirname(statePath), { recursive: true });
   let client = null;
   const pushDiagnostics = (patch) => {
@@ -42512,7 +43022,8 @@ async function monitorInlineProvider(params) {
     baseUrl: account.baseUrl,
     token,
     logger: sdkLog,
-    state: new JsonFileStateStore(statePath)
+    state: new JsonFileStateStore(statePath),
+    catchUpUserFromStart: hasExistingState
   });
   await client.connect(abortSignal);
   pushDiagnostics();
@@ -42614,7 +43125,7 @@ async function monitorInlineProvider(params) {
     const senderId = params2.senderId != null ? String(params2.senderId) : null;
     const dmPolicy = account.config.dmPolicy ?? "pairing";
     const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? INLINE_DEFAULT_GROUP_POLICY;
     if (isGroup) {
       if (groupPolicy === "disabled") {
         log?.info(`[${account.accountId}] inline: drop ${params2.eventKind} chat=${String(params2.chatId)} (groupPolicy=disabled)`);
@@ -42627,6 +43138,7 @@ async function monitorInlineProvider(params) {
         senderId
       });
       if (groupPolicy === "allowlist") {
+        const shouldBypassGroupAccess = params2.eventKind === "participant.add";
         const groupAccess = resolveInlineGroupAccessPolicy({
           cfg,
           accountId: account.accountId,
@@ -42634,11 +43146,11 @@ async function monitorInlineProvider(params) {
           hasGroupAllowFrom: groupSenderAllowlist.raw.length > 0,
           groupPolicy
         });
-        if (groupAccess.allowlistEnabled && !groupAccess.allowed) {
+        if (groupAccess.allowlistEnabled && !groupAccess.allowed && !shouldBypassGroupAccess) {
           log?.info(`[${account.accountId}] inline: drop ${params2.eventKind} chat=${String(effectiveChatId)} (groupPolicy=allowlist)`);
           return null;
         }
-        if (groupSenderAllowlist.raw.length > 0) {
+        if (groupSenderAllowlist.raw.length > 0 && !shouldBypassGroupAccess) {
           if (senderId == null && !groupSenderAllowlist.raw.includes("*")) {
             log?.info(`[${account.accountId}] inline: drop ${params2.eventKind} chat=${String(effectiveChatId)} (sender unknown)`);
             return null;
@@ -42777,6 +43289,74 @@ async function monitorInlineProvider(params) {
       messageId: params2.messageId
     }), eventOptions);
   };
+  const queueInlineParticipantAddSystemEvent = async (params2) => {
+    if (params2.participant?.userId !== meId)
+      return;
+    const inboundAt = Date.now();
+    statusSink?.({
+      lastInboundAt: inboundAt,
+      lastEventAt: inboundAt,
+      ...createTransportActivityStatusPatch(inboundAt)
+    });
+    const ingress = await resolveInlineSystemEventContext({
+      chatId: params2.chatId,
+      senderId: null,
+      eventKind: "participant.add"
+    });
+    if (!ingress)
+      return;
+    await hydrateChatParticipants(params2.chatId);
+    const chatInfo = chatCache.get(params2.chatId);
+    const isGroup = chatInfo?.kind !== "direct";
+    const historyLimit = resolveHistoryLimit({
+      cfg,
+      isGroup,
+      historyLimit: account.config.historyLimit,
+      dmHistoryLimit: account.config.dmHistoryLimit
+    });
+    const recentMessages = historyLimit > 0 ? await loadChatHistoryMessages({
+      client,
+      chatId: params2.chatId,
+      limit: Math.min(historyLimit, 10)
+    }).catch((err) => {
+      statusSink?.({ lastError: `getChatHistory (participant add) failed: ${String(err)}` });
+      return null;
+    }) : null;
+    const recentLines = recentMessages ? buildInlineRecentHistoryLines({
+      messages: recentMessages,
+      senderProfilesById,
+      meId,
+      maxLines: Math.min(historyLimit, 10)
+    }) : [];
+    const contextKey = buildInlineParticipantAddContextKey({
+      chatId: params2.chatId,
+      userId: meId,
+      ...params2.participant.date != null ? { participantDate: params2.participant.date } : {},
+      ...params2.seq != null ? { seq: params2.seq } : {}
+    });
+    core3.system.enqueueSystemEvent(describeInlineParticipantAddSystemEvent({
+      channelLabel: ingress.channelLabel,
+      recentLines
+    }), {
+      sessionKey: ingress.sessionKey,
+      contextKey,
+      forceSenderIsOwnerFalse: true,
+      trusted: false
+    });
+    if (shouldSendInlineParticipantAddReadyMessage(params2.participant.date)) {
+      try {
+        await client.sendMessage({
+          chatId: params2.chatId,
+          text: buildInlineParticipantAddReadyText(botUsername),
+          parseMarkdown: account.config.parseMarkdown ?? true
+        });
+        statusSink?.({ lastOutboundAt: Date.now() });
+      } catch (err) {
+        runtime.error?.(`inline participant-add ready message failed: ${String(err)}`);
+        statusSink?.({ lastError: `participant-add ready message failed: ${String(err)}` });
+      }
+    }
+  };
   const shouldQueueInlineReactionSystemEvent = async (params2) => {
     const mode = account.config.reactionNotifications ?? "own";
     if (mode === "off")
@@ -42862,8 +43442,8 @@ async function monitorInlineProvider(params) {
       cfg,
       accountId: account.accountId,
       groupId: String(effectiveChatId),
-      defaultMinMessages: account.config.replyThreadAutoCreateMinMessages ?? inlineThreadDefaults.replyThreadAutoCreateMinMessages ?? DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES
-    }) : DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES;
+      defaultMinMessages: account.config.replyThreadAutoCreateMinMessages ?? inlineThreadDefaults.replyThreadAutoCreateMinMessages ?? DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES2
+    }) : DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES2;
     const replyThreadRequireExplicitMention = isGroup && replyThreadsEnabled ? resolveInlineGroupReplyThreadRequireExplicitMention({
       cfg,
       accountId: account.accountId,
@@ -42887,7 +43467,7 @@ async function monitorInlineProvider(params) {
     }
     const dmPolicy = account.config.dmPolicy ?? "pairing";
     const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? INLINE_DEFAULT_GROUP_POLICY;
     const configAllowFrom = await resolveInlineAllowlist({
       cfg,
       accountId: account.accountId,
@@ -42967,6 +43547,8 @@ async function monitorInlineProvider(params) {
     });
     const hasControlCommand = hasTextControlCommand || isRegisteredNativeCommand;
     const commandSource = hasControlCommand ? isRegisteredNativeCommand ? "native" : "text" : undefined;
+    const normalizedCommandName = resolveInlineCommandNameFromBody(normalizedCommandBody);
+    const hostInlinePluginCommandRegistered = normalizedCommandName ? hasInlineCommandSpec(listHostInlinePluginCommandSpecs(cfg), normalizedCommandName) : false;
     const allowTextCommands = core3.channel.commands.shouldHandleTextCommands({
       cfg,
       surface: CHANNEL_ID,
@@ -42990,6 +43572,7 @@ async function monitorInlineProvider(params) {
       commandAuthorized: commandGate.commandAuthorized
     });
     const shouldBlockControlCommand = allowTextCommands && hasControlCommand && !commandAuthorized;
+    const nativeMentioned = typeof msg.mentioned === "boolean" ? msg.mentioned : false;
     if (isGroup) {
       if (groupPolicy === "disabled") {
         log?.info(`[${account.accountId}] inline: drop group chat=${String(chatId)} (groupPolicy=disabled)`);
@@ -43006,7 +43589,7 @@ async function monitorInlineProvider(params) {
           hasGroupAllowFrom: groupSenderAllowlist.raw.length > 0,
           groupPolicy
         });
-        if (groupAccess.allowlistEnabled && !groupAccess.allowed) {
+        if (groupAccess.allowlistEnabled && !groupAccess.allowed && !nativeMentioned) {
           log?.info(`[${account.accountId}] inline: drop group chat=${String(effectiveChatId)} (groupPolicy=allowlist)`);
           await answerCallbackIfNeeded().catch((error51) => {
             runtime.error?.(`inline callback answer failed: ${String(error51)}`);
@@ -43078,7 +43661,6 @@ async function monitorInlineProvider(params) {
       return;
     }
     const mentionRegexes = core3.channel.mentions.buildMentionRegexes(cfg, route.agentId);
-    const nativeMentioned = typeof msg.mentioned === "boolean" ? msg.mentioned : false;
     const patternMentioned = mentionRegexes.length ? core3.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) : false;
     const wasMentioned = nativeMentioned || patternMentioned;
     const messageTimestamp = Number(msg.date) * 1000;
@@ -43136,7 +43718,7 @@ async function monitorInlineProvider(params) {
       cfg,
       groupId: String(effectiveChatId),
       accountId: account.accountId,
-      requireMentionDefault: account.config.requireMention ?? false
+      requireMentionDefault: account.config.requireMention ?? INLINE_DEFAULT_REQUIRE_MENTION
     }) : false;
     const mentionGate = resolveMentionGatingWithBypass({
       isGroup,
@@ -43181,6 +43763,74 @@ async function monitorInlineProvider(params) {
       return;
     }
     const parseMarkdown = account.config.parseMarkdown ?? true;
+    if (isInlineThreadReplyCommandBody(normalizedCommandBody) && !hostInlinePluginCommandRegistered) {
+      const configRuntime = core3.config;
+      if (typeof configRuntime?.current !== "function" || typeof configRuntime.mutateConfigFile !== "function") {
+        runtime.error?.("inline /threadreply fallback unavailable: runtime config API missing");
+      } else {
+        const result = await handleInlineThreadReplyCommandWithConfigRuntime(configRuntime, {
+          senderId,
+          channel: CHANNEL_ID,
+          channelId: CHANNEL_ID,
+          isAuthorizedSender: commandAuthorized,
+          senderIsOwner: commandAuthorized,
+          sessionKey: inboundSessionKey,
+          args: parseInlineCommandArgs(normalizedCommandBody),
+          commandBody: normalizedCommandBody,
+          config: cfg,
+          from: isGroup ? `inline:chat:${String(effectiveChatId)}` : `inline:${senderId}`,
+          to: `inline:${String(effectiveChatId)}`,
+          accountId: account.accountId,
+          ...replyThreadContext ? {
+            messageThreadId: String(replyThreadContext.childChatId),
+            threadParentId: String(replyThreadContext.parentChatId)
+          } : {},
+          requestConversationBinding: async () => ({ ok: false }),
+          detachConversationBinding: async () => ({ removed: false }),
+          getCurrentConversationBinding: async () => null
+        });
+        const resultRecord = result;
+        const actions = resolveInlineReplyActions(resultRecord);
+        const text = typeof result.text === "string" ? sanitizeInlineDeliveryText(result.text) : "";
+        if (text || actions) {
+          let delivered = false;
+          if (shouldEditCallbackTargetInPlace && callbackActionEvent) {
+            try {
+              const editResult = await client.invokeRaw(Method.EDIT_MESSAGE, {
+                oneofKind: "editMessage",
+                editMessage: {
+                  messageId: callbackActionEvent.targetMessageId,
+                  peerId: buildChatPeer3(chatId),
+                  text,
+                  ...actions ? { actions } : {},
+                  parseMarkdown
+                }
+              });
+              if (editResult.oneofKind !== "editMessage") {
+                throw new Error(`inline /threadreply edit: expected editMessage result, got ${String(editResult.oneofKind)}`);
+              }
+              delivered = true;
+            } catch (error51) {
+              runtime.error?.(`inline /threadreply edit failed; falling back to send (${String(error51)})`);
+            }
+          }
+          if (!delivered) {
+            const sent = await client.sendMessage({
+              chatId,
+              text,
+              ...actions ? { actions } : {},
+              parseMarkdown
+            });
+            rememberSentBotMessage({ chatId, messageId: sent.messageId, replyThreadContext });
+          }
+          statusSink?.({ lastOutboundAt: Date.now() });
+        }
+        await answerCallbackIfNeeded().catch((error51) => {
+          runtime.error?.(`inline callback answer failed: ${String(error51)}`);
+        });
+        return;
+      }
+    }
     const commandsPageCallback = callbackActionEvent ? parseInlineCommandsPageCallback(callbackDataToUtf8(callbackActionEvent.data)) : null;
     if (shouldEditCallbackTargetInPlace && callbackActionEvent && commandsPageCallback) {
       if (commandsPageCallback.page === "noop")
@@ -43513,13 +44163,6 @@ This model will be used for your next message.`, []);
       maxBytes: inboundMediaMaxBytes,
       ...log ? { log } : {}
     });
-    const inheritedAnchorMedia = deliveryReplyThreadContext?.anchorMessage != null && currentContent != null && !hasDownloadableInlineMedia(currentContent) ? await resolveInlineInboundMedia({
-      core: core3,
-      message: deliveryReplyThreadContext.anchorMessage,
-      maxBytes: inboundMediaMaxBytes,
-      ...log ? { log } : {}
-    }) : [];
-    const mediaForAgent = inboundMedia.length > 0 ? inboundMedia : inheritedAnchorMedia;
     const timestamp = messageTimestamp;
     const fromLabel = resolveInlineConversationLabel({
       isGroup,
@@ -43556,7 +44199,8 @@ This model will be used for your next message.`, []);
     const effectiveSurface = CHANNEL_ID;
     const systemPrompt = resolveInlineSystemPrompt({
       account,
-      ...isGroup ? { groupId: String(effectiveChatId) } : {}
+      ...isGroup ? { groupId: String(effectiveChatId) } : {},
+      replyThread: Boolean(deliveryReplyThreadContext)
     });
     const messageSid = buildInlineInboundMessageSid({
       msgId: msg.id,
@@ -43608,7 +44252,7 @@ This model will be used for your next message.`, []);
         MessageActionDataBase64: callbackDataToBase64(callbackActionEvent.data),
         ...callbackDataToUtf8(callbackActionEvent.data) ? { MessageActionDataUtf8: callbackDataToUtf8(callbackActionEvent.data) } : {}
       } : {},
-      ...buildInlineInboundMediaPayload(mediaForAgent),
+      ...buildInlineInboundMediaPayload(inboundMedia),
       Timestamp: timestamp || Date.now(),
       ...isGroup ? { WasMentioned: mentionGate.effectiveWasMentioned } : {},
       ...isGroup ? {
@@ -44351,6 +44995,19 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
           });
           continue;
         }
+        if (rawEvent["kind"] === "chat.participant.add") {
+          const eventChatId = rawEvent["chatId"];
+          if (!eventChatId)
+            continue;
+          const participant = rawEvent["participant"];
+          const seq = rawEvent["seq"];
+          await queueInlineParticipantAddSystemEvent({
+            chatId: eventChatId,
+            ...participant ? { participant } : {},
+            ...seq != null ? { seq } : {}
+          });
+          continue;
+        }
         if (rawEvent["kind"] === "message.action.invoke") {
           const actorUserId = rawEvent["actorUserId"];
           const interactionId = rawEvent["interactionId"];
@@ -44415,7 +45072,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
 }
 
 // src/inline/doctor.ts
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function readInherited(account, parent, key) {
@@ -44426,18 +45083,18 @@ function hasEntries(value) {
 }
 function hasConfiguredGroups(account, parent) {
   const groups = readInherited(account, parent, "groups");
-  return isRecord6(groups) && Object.keys(groups).length > 0;
+  return isRecord7(groups) && Object.keys(groups).length > 0;
 }
 function hasGroupScopedSenders(groups) {
-  if (!isRecord6(groups))
+  if (!isRecord7(groups))
     return false;
-  return Object.values(groups).some((group) => isRecord6(group) && hasEntries(group.allowFrom));
+  return Object.values(groups).some((group) => isRecord7(group) && hasEntries(group.allowFrom));
 }
 function hasGroupSenders(account, parent) {
   return hasEntries(readInherited(account, parent, "groupAllowFrom")) || hasGroupScopedSenders(readInherited(account, parent, "groups"));
 }
 function getGroupPolicy(account, parent) {
-  return String(readInherited(account, parent, "groupPolicy") ?? "allowlist");
+  return String(readInherited(account, parent, "groupPolicy") ?? INLINE_DEFAULT_GROUP_POLICY);
 }
 function collectInlineEmptyAllowlistWarnings(params) {
   if (params.channelName !== "inline")
@@ -44594,7 +45251,8 @@ var INLINE_USER_ID_HELP_LINES = [
   "Docs: https://inline.chat/docs/openclaw"
 ];
 var INLINE_GROUP_HELP_LINES = [
-  "Allowlist Inline group chats by numeric chat id.",
+  "Inline groups are open by default and require a bot mention by default.",
+  "Optionally allowlist Inline group chats by numeric chat id.",
   "Accepted forms: 123456789, chat:123456789, inline:123456789, *.",
   "Use * for every group chat; the setup keeps requireMention=true for broad group access.",
   "Use /whoami in a group and copy the Chat line to get the Inline chat id.",
@@ -44741,7 +45399,7 @@ function buildInlineDmAccessWarningLines(accountId) {
 function buildInlineGroupAccessWarningLines(params) {
   const resolved = resolveInlineAccount({ cfg: params.cfg, accountId: params.accountId });
   const configBase = formatInlineConfigBase(params.accountId);
-  const policy = resolved.config.groupPolicy ?? "allowlist";
+  const policy = resolved.config.groupPolicy ?? INLINE_DEFAULT_GROUP_POLICY;
   const groups = resolved.config.groups ?? {};
   const hasGroups = Object.keys(groups).length > 0;
   const hasGroupAllowFrom = (resolved.config.groupAllowFrom ?? []).some((entry) => String(entry).trim());
@@ -44754,7 +45412,8 @@ function buildInlineGroupAccessWarningLines(params) {
     ];
   }
   const wildcard = groups["*"];
-  if (policy === "open" && wildcard?.requireMention !== true) {
+  const requireMention = wildcard?.requireMention ?? resolved.config.requireMention ?? INLINE_DEFAULT_REQUIRE_MENTION;
+  if (policy === "open" && requireMention !== true) {
     return [
       "Inline groups are open to every group chat without a default mention requirement.",
       "For safer broad group access, require bot mentions or switch to an explicit group allowlist:",
@@ -45018,11 +45677,11 @@ async function probeInlineAccount(account, timeoutMs) {
 }
 
 // src/inline/status-issues.ts
-import { asString, isRecord as isRecord7 } from "openclaw/plugin-sdk/status-helpers";
+import { asString, isRecord as isRecord8 } from "openclaw/plugin-sdk/status-helpers";
 var RECENT_RUNTIME_ISSUE_MS = 30 * 60 * 1000;
 var INLINE_CONNECT_GRACE_MS = 120 * 1000;
 function readInlineProbeSummary(value) {
-  if (!isRecord7(value)) {
+  if (!isRecord8(value)) {
     return {};
   }
   const summary = {};
@@ -45039,12 +45698,12 @@ function looksLikeAuthError(text) {
   return /(401|403|unauth|forbidden|invalid token|token invalid|unauthorized)/i.test(text);
 }
 function readInlineDiagnosticsSummary(value) {
-  if (!isRecord7(value)) {
+  if (!isRecord8(value)) {
     return {};
   }
-  const protocolValue = isRecord7(value.protocol) ? value.protocol : undefined;
-  const transportValue = (protocolValue && isRecord7(protocolValue.transport) ? protocolValue.transport : undefined) ?? (isRecord7(value.transport) ? value.transport : undefined);
-  const pingValue = protocolValue && isRecord7(protocolValue.ping) ? protocolValue.ping : undefined;
+  const protocolValue = isRecord8(value.protocol) ? value.protocol : undefined;
+  const transportValue = (protocolValue && isRecord8(protocolValue.transport) ? protocolValue.transport : undefined) ?? (isRecord8(value.transport) ? value.transport : undefined);
+  const pingValue = protocolValue && isRecord8(protocolValue.ping) ? protocolValue.ping : undefined;
   return {
     ...protocolValue ? {
       protocol: {
@@ -45076,7 +45735,7 @@ function asFiniteNumber(value) {
 function collectInlineStatusIssues(accounts) {
   const issues = [];
   for (const entry of accounts) {
-    if (!isRecord7(entry)) {
+    if (!isRecord8(entry)) {
       continue;
     }
     const accountId = asString(entry.accountId);
@@ -45212,6 +45871,14 @@ function hasInlineCommandAllowFrom(cfg) {
   const byProvider = allowFrom;
   return hasEntries2(byProvider.inline) || hasEntries2(byProvider["*"]);
 }
+function groupDefaultRequiresMention(account) {
+  const groups = account.config.groups;
+  const wildcard = groups && typeof groups === "object" && !Array.isArray(groups) ? groups["*"] : undefined;
+  const wildcardRequireMention = wildcard && typeof wildcard === "object" && !Array.isArray(wildcard) ? wildcard.requireMention : undefined;
+  if (typeof wildcardRequireMention === "boolean")
+    return wildcardRequireMention;
+  return account.config.requireMention ?? INLINE_DEFAULT_REQUIRE_MENTION;
+}
 function collectInvalidAllowFromEntries(params) {
   if (!Array.isArray(params.entries))
     return;
@@ -45268,7 +45935,7 @@ var inlineSecurityAdapter = {
   },
   collectWarnings: ({ account, cfg }) => {
     const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? INLINE_DEFAULT_GROUP_POLICY;
     const groupRulesConfigured = Boolean(account.config.groups) && Object.keys(account.config.groups ?? {}).length > 0;
     const groupSendersConfigured = hasGroupSenderEntries(account);
     if (groupPolicy === "allowlist" && !groupRulesConfigured && !groupSendersConfigured) {
@@ -45279,14 +45946,12 @@ var inlineSecurityAdapter = {
     if (groupPolicy !== "open") {
       return [];
     }
-    if (groupRulesConfigured) {
+    if (!groupDefaultRequiresMention(account)) {
       return [
-        '- Inline groups: groupPolicy="open" allows any group message to reach the agent (subject to mention policy). Set channels.inline.groupPolicy="allowlist" for stricter routing.'
+        '- Inline groups: groupPolicy="open" allows every group message to trigger replies because requireMention is disabled. Set channels.inline.requireMention=true or channels.inline.groups."*".requireMention=true.'
       ];
     }
-    return [
-      '- Inline groups: groupPolicy="open" with no group rules means every group can trigger replies. Consider channels.inline.groupPolicy="allowlist".'
-    ];
+    return [];
   },
   collectAuditFindings: ({ account, cfg }) => {
     const findings = [];
@@ -45311,7 +45976,7 @@ var inlineSecurityAdapter = {
     });
     appendInvalidReactionAllowlistFinding(findings, invalidReactionAllowlistEntries);
     const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? INLINE_DEFAULT_GROUP_POLICY;
     const groupsConfigured = Boolean(account.config.groups) && Object.keys(account.config.groups ?? {}).length > 0;
     const groupSendersConfigured = hasGroupSenderEntries(account);
     const groupAccessEnabled = groupPolicy === "open" || groupPolicy === "allowlist" && (groupsConfigured || groupSendersConfigured);
@@ -46644,7 +47309,7 @@ var inlineChannelPlugin = {
         cfg,
         groupId,
         accountId,
-        requireMentionDefault: resolved.config.requireMention ?? false
+        requireMentionDefault: resolved.config.requireMention ?? INLINE_DEFAULT_REQUIRE_MENTION
       });
     },
     resolveToolPolicy: ({ cfg, accountId, groupId, senderId, senderName, senderUsername, senderE164 }) => resolveInlineGroupToolPolicy({
@@ -46705,7 +47370,7 @@ var inlineChannelPlugin = {
       "- Inline reply threads: use `thread-create` to create or reuse a real reply thread under the current/target chat. On parent-chat inbound turns, omit `messageId` to anchor it to the current message, or pass `messageId`/`parentMessageId` explicitly.",
       "- Inline reply threads: use `thread-reply` to send into a real reply thread, with `threadId` set to the reply-thread chat id returned by `thread-create`. Reuse that `threadId` only for the same reply-thread session; unrelated parent-chat messages need separate parent-message anchors.",
       "- Inline reply threads: when already inside a reply-thread chat, continue in that reply thread and do not create nested reply threads.",
-      "- Inline reply-thread turns include nearby parent-chat context by default. If that context is incomplete, call `inline_parent_context` before answering."
+      "- Inline reply-thread turns include nearby parent-chat context as background only; answer the current reply-thread conversation, not unrelated parent-chat or other-thread questions."
     ]
   },
   messaging: {
@@ -47068,5 +47733,5 @@ export {
   inlineChannelPlugin
 };
 
-//# debugId=FEB3F6CD06C6A7CC64756E2164756E21
+//# debugId=93A450B5B900350964756E2164756E21
 //# sourceMappingURL=channel-plugin-api.js.map