@badgerclaw/connect 1.3.1 → 1.3.3

package/SETUP.md

@@ -6,7 +6,6 @@ Connect your OpenClaw AI agent to BadgerClaw encrypted chat rooms.
 
 - **BadgerClaw iOS app** installed and logged in
 - **OpenClaw** installed on your machine (`npm install -g openclaw`)
-- Both on the same network (not required, just for initial setup)
 
 ---
 
@@ -14,28 +13,24 @@ Connect your OpenClaw AI agent to BadgerClaw encrypted chat rooms.
 
 Open the BadgerClaw app on your phone.
 
-1. Open any room or DM
-2. Type: `/bot create <name>`
-   - Example: `/bot create jarvis`
-3. BotBadger responds with:
+1. Open any room or DM with BotBadger
+2. Type: `/bot new`
+3. Follow the guided flow to set a bot name and username
+4. BotBadger responds with a pairing code:
 
 ```
 🦡 Bot created!
 
 Name: jarvis
-ID: @abc123_jarvis_bot:badger.signout.io
-
 Connect to OpenClaw:
-  openclaw plugins install @badgerclaw/connect
   openclaw badgerclaw connect BCK-A8F3-X9K2
 
 Code expires in 24 hours.
-Run /bot pair jarvis to generate a new code.
 ```
 
-4. **Copy the pairing code** (BCK-XXXX-XXXX)
+5. **Copy the pairing code** (BCK-XXXX-XXXX)
 
-> **Need a new code?** Type `/bot pair jarvis` to regenerate.
+> **Need a new code?** Type `/bot pair <name>` to regenerate.
 
 ---
 
@@ -44,38 +39,42 @@ Run /bot pair jarvis to generate a new code.
 On your machine (Mac, PC, Linux, Pi), run:
 
 ```bash
-# From GitHub (current method)
+openclaw plugins install @badgerclaw/connect
+```
+
+Or install from source:
+
+```bash
 git clone https://github.com/darkstaar4/badgerclaw-plugin.git
 openclaw plugins install ./badgerclaw-plugin
-
-# From npm (coming soon)
-# openclaw plugins install @badgerclaw/connect
 ```
 
 ---
 
 ## Step 3: Connect with Pairing Code
 
-Run the OpenClaw configure wizard:
+```bash
+openclaw badgerclaw connect BCK-XXXX-XXXX
+```
+
+Or run the full configure wizard:
 
 ```bash
 openclaw configure
 ```
 
-1. Select **BadgerClaw** as your channel
-2. Enter your pairing code: `BCK-XXXX-XXXX`
-3. The plugin automatically:
-   - Validates the code with BadgerClaw servers
-   - Retrieves your bot's credentials
-   - Enables end-to-end encryption
-   - Configures auto-join for room invites
-4. Done! Your agent is connected.
+The plugin automatically:
+- Validates the code with BadgerClaw servers
+- Retrieves your bot's credentials
+- Enables end-to-end encryption
+- Configures auto-join for room invites
+- Sets up auto-reply in group chats
 
 ---
 
 ## Step 4: Start Chatting
 
-Restart the OpenClaw gateway to apply the new config:
+Restart the OpenClaw gateway:
 
 ```bash
 openclaw gateway restart
@@ -83,30 +82,191 @@ openclaw gateway restart
 
 Now in the BadgerClaw app:
 
-1. **DM your bot** — find it in your contacts (`@xxx_jarvis_bot:badger.signout.io`) and send a message
-2. **Add to a room** — type `/bot add @jarvis` in any room
+1. **DM your bot** — find it in your contacts and send a message
+2. **Add to a room** — type `/bot add <name>` in any room
 3. **Add to a Space** — add the bot to any room inside a Space
 
-Your OpenClaw agent will receive messages and respond through BadgerClaw — fully end-to-end encrypted.
+Your OpenClaw agent will receive messages and respond — fully end-to-end encrypted.
 
 ---
 
-## Troubleshooting
+## Bot Commands
+
+Use these commands in any BadgerClaw room or DM where your bot is present.
+
+| Command | Description |
+|---------|-------------|
+| `/bot help` | Show all available commands |
+| `/bot talk on` | **Enable auto-reply** — bot responds to every message without needing an @mention. If multiple bots are in the room, you'll be asked to specify which one. |
+| `/bot talk on @botname` | **Enable auto-reply for a specific bot** — use when multiple bots are in the room. |
+| `/bot talk off` | **Disable auto-reply for ALL bots** — kill switch. All bots in the room go quiet and only respond when @mentioned. |
+| `/bot add <name>` | Invite a bot to the current room (e.g. `/bot add jarvis`) |
+| `/bot list` | List all your bots and their connection status |
+
+### How Auto-Reply Works
+
+- **New installs:** Auto-reply is **ON by default** in all rooms
+- **Per-room toggle:** `/bot talk on` and `/bot talk off` override the default for that specific room
+- **Multi-bot rooms:** If multiple bots are present, `/bot talk on` asks which bot to enable. `/bot talk off` silences all bots at once.
+- **@mentions always work:** Even with auto-reply off, the bot responds when @mentioned
+
+---
+
+## Group Chat Configuration
+
+### Default Behavior
+
+When you install BadgerClaw with a fresh pairing code, the plugin automatically configures:
+
+```json
+{
+  "groupPolicy": "open",
+  "groups": {
+    "*": {
+      "autoReply": true,
+      "enabled": true
+    }
+  }
+}
+```
+
+This means:
+- Bot joins any room it's invited to
+- Bot responds to all messages (no @mention required)
+- Bot uses **your OpenClaw workspace personality** (SOUL.md, IDENTITY.md, etc.) in all conversations — groups and DMs alike
+
+When the bot joins a new encrypted room, it sends a hint message explaining the `/bot talk on|off` commands so room members know how to control it.
+
+### Your Personality, Everywhere
+
+BadgerClaw respects your OpenClaw workspace files. If you've configured a custom personality (SOUL.md), the bot uses that personality in groups and DMs. This means:
+
+- A "pirate assistant" SOUL.md → bot talks like a pirate in groups
+- A "professional COO" SOUL.md → bot acts professional in groups
+- No SOUL.md → bot uses the default helpful assistant behavior
+
+**If your bot stays silent in groups**, your workspace files may include instructions like "stay silent in groups" or "only respond when needed." To fix this:
+
+1. Edit your SOUL.md to allow group responses, OR
+2. Add a group-specific system prompt override:
+
+```json
+{
+  "channels": {
+    "badgerclaw": {
+      "groups": {
+        "*": {
+          "autoReply": true,
+          "systemPrompt": "You are a helpful AI assistant. Always respond to messages in group chats."
+        }
+      }
+    }
+  }
+}
+```
+
+### Per-Room Configuration
+
+You can configure specific rooms differently:
+
+```json
+{
+  "channels": {
+    "badgerclaw": {
+      "groups": {
+        "*": { "autoReply": true },
+        "!specificRoomId:server": {
+          "autoReply": false,
+          "systemPrompt": "Custom prompt for this room only"
+        }
+      }
+    }
+  }
+}
+```
+
+---
+
+## Upgrading from v1.1.x or Earlier
+
+If you installed BadgerClaw before v1.2.0, your config is missing the group auto-reply settings. The bot may not respond in group chats without @mentions.
+
+**Quick fix — run the update command:**
+
+```bash
+openclaw plugins update @badgerclaw/connect
+openclaw configure
+```
+
+Select BadgerClaw and re-enter a pairing code. The new onboarding will add the missing group config automatically.
+
+**Manual fix — if you don't want to re-pair:**
+
+Add this to your `~/.openclaw/openclaw.json` inside `channels.badgerclaw`:
+
+```json
+{
+  "channels": {
+    "badgerclaw": {
+      "groupPolicy": "open",
+      "groups": {
+        "*": {
+          "autoReply": true,
+          "enabled": true
+        }
+      }
+    }
+  }
+}
+```
+
+Then restart: `openclaw gateway restart`
+
+---
+
+## FAQ
+
+### Bot doesn't respond in group chats
+
+1. Send `/bot talk on` in the room to enable auto-reply
+2. Make sure the bot is a member of the room (`/bot add <name>`)
+3. Check OpenClaw is running: `openclaw status`
+
+### Bot shows typing indicator but never replies
+
+Your workspace personality (SOUL.md) may tell the agent to stay silent in groups. BadgerClaw respects your workspace files, so if SOUL.md says "don't respond in groups," the bot won't.
+
+**Fix options:**
+1. Edit your SOUL.md to allow group responses
+2. Add a `systemPrompt` override in `channels.badgerclaw.groups.*` that tells the agent to respond (see Group Chat Configuration above)
+3. Run `openclaw configure` and reconfigure BadgerClaw
+
+### `/bot talk on` doesn't work
+
+After changing bot commands, you may need to restart the gateway:
+
+```bash
+openclaw gateway restart
+```
+
+### Bot responds with wrong personality
+
+The bot uses your **OpenClaw workspace personality** (SOUL.md, IDENTITY.md) for both DMs and groups. To set a different personality for groups only, add a `systemPrompt` in `channels.badgerclaw.groups.*` in your config.
+
+### Bot keeps saying "NO_REPLY" or stays silent
+
+Your workspace files (SOUL.md) instruct the agent to stay silent in groups. BadgerClaw respects your personality — this is intentional.
+
+**To fix:** Add a `systemPrompt` override to your groups config that tells the agent to always respond. See the "Your Personality, Everywhere" section above. Then restart: `openclaw gateway restart`
 
 ### "Invalid pairing code"
-- Code may have expired (24h limit). Run `/bot pair <name>` in the app to get a new one.
-- Make sure you're entering the code exactly as shown (BCK-XXXX-XXXX).
 
-### Bot doesn't respond
-1. Check OpenClaw is running: `openclaw status`
-2. Check gateway logs: `openclaw logs --follow`
-3. Verify the BadgerClaw channel is configured: `openclaw channels status`
+- Code expires after 24 hours. Run `/bot pair <name>` in the app for a new one.
+- Enter the code exactly as shown (BCK-XXXX-XXXX).
 
 ### "Pairing code already redeemed"
-Each code is one-time use. Run `/bot pair <name>` to generate a fresh one.
 
-### Need to reconnect
-Run `openclaw configure` again and enter a new pairing code.
+Each code is one-time use. Run `/bot pair <name>` to generate a fresh one.
 
 ---
 
@@ -115,9 +275,9 @@ Run `openclaw configure` again and enter a new pairing code.
 ```
 Your Phone (BadgerClaw App)
      │
-     │ E2EE Messages
+     │ E2EE Messages (Megolm/Olm)
      ▼
-BadgerClaw Server (badger.signout.io)
+BadgerClaw Server (Matrix homeserver)
      │
      │ E2EE Messages
      ▼

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@badgerclaw/connect",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "BadgerClaw channel plugin for OpenClaw",
   "type": "module",
   "dependencies": {

package/src/group-mentions.ts

@@ -38,26 +38,44 @@ export function resolveMatrixGroupRequireMention(params: ChannelGroupContext): b
       ".openclaw/extensions/badgerclaw/room-config.json"
     );
     const raw = fs.readFileSync(configPath, "utf-8");
-    const roomConfig = JSON.parse(raw) as Record<string, { autoReply?: boolean }>;
+    const roomConfig = JSON.parse(raw) as Record<string, { autoReply?: boolean; activeBots?: string[] }>;
     const rawGroupId = params.groupId?.trim() ?? "";
-    // Try multiple formats: raw, stripped prefixes, just the room ID part
     const variants = [
       rawGroupId,
       rawGroupId.replace(/^badgerclaw:/, ""),
       rawGroupId.replace(/^channel:/, ""),
       rawGroupId.replace(/^room:/, ""),
     ];
+    const configKeys = Object.keys(roomConfig);
     for (const variant of variants) {
-      if (variant && roomConfig[variant]?.autoReply === true) {
-        console.log(`[badgerclaw] room-config autoReply=true for ${variant}`);
-        return false;
-      }
-      if (variant && roomConfig[variant]?.autoReply === false) {
-        console.log(`[badgerclaw] room-config autoReply=false for ${variant}`);
-        return true;
+      if (!variant) continue;
+      const matchedKey = configKeys.find(
+        (k) => k.toLowerCase() === variant.toLowerCase()
+      );
+      if (matchedKey) {
+        const entry = roomConfig[matchedKey];
+        // New format: activeBots list
+        if (Array.isArray(entry.activeBots)) {
+          if (entry.activeBots.length > 0) {
+            console.log(`[badgerclaw] room-config activeBots=[${entry.activeBots.map(b => b.split(":")[0]).join(",")}] for ${matchedKey}`);
+            return false; // At least one bot active — let handler do per-bot filtering
+          } else {
+            console.log(`[badgerclaw] room-config activeBots=[] (all off) for ${matchedKey}`);
+            return true; // No bots active
+          }
+        }
+        // Legacy format
+        if (entry.autoReply === true) {
+          console.log(`[badgerclaw] room-config autoReply=true for ${matchedKey} (lookup=${variant})`);
+          return false;
+        }
+        if (entry.autoReply === false) {
+          console.log(`[badgerclaw] room-config autoReply=false for ${matchedKey} (lookup=${variant})`);
+          return true;
+        }
       }
     }
-    console.log(`[badgerclaw] room-config: no match for groupId="${rawGroupId}", keys=${Object.keys(roomConfig).join(",")}`);
+    console.log(`[badgerclaw] room-config: no match for groupId="${rawGroupId}", keys=${configKeys.join(",")}`);
   } catch (err) {
     console.log(`[badgerclaw] room-config error: ${err}`);
   }

package/src/matrix/monitor/auto-join.ts

@@ -3,6 +3,7 @@ import type { RuntimeEnv } from "openclaw/plugin-sdk/matrix";
 import { getMatrixRuntime } from "../../runtime.js";
 import type { CoreConfig } from "../../types.js";
 import { loadMatrixSdk } from "../sdk-runtime.js";
+import { initRoomHistory } from "./chat-history.js";
 
 // Track clients that already have auto-join registered to prevent duplicate listeners
 const autoJoinRegistered = new WeakSet<object>();
@@ -34,47 +35,49 @@ export function registerMatrixAutoJoin(params: {
   }
   autoJoinRegistered.add(client);
 
+  // After joining a room, send a notice in encrypted rooms to force Megolm session rotation.
+  // When the bot joins, other clients may use a cached outbound Megolm session that doesn't
+  // include the bot. Sending a message causes compliant clients to detect the new member and
+  // rotate their session so subsequent messages are decryptable by the bot.
+  async function postJoinEncryptionHandshake(roomId: string) {
+    try {
+      const encryptionState = await client
+        .getRoomStateEvent(roomId, "m.room.encryption", "")
+        .catch(() => null);
+
+      if (!encryptionState) {
+        logVerbose(`badgerclaw: room ${roomId} is not encrypted, skipping handshake`);
+        return;
+      }
+
+      logVerbose(`badgerclaw: room ${roomId} is encrypted, sending notice to trigger key rotation`);
+      await client.sendNotice(
+        roomId,
+        "🔐 Connected — encryption active.\n\n" +
+          "I'll respond when @mentioned. To toggle auto-reply:\n" +
+          "• /bot talk on — I'll respond to every message\n" +
+          "• /bot talk off — I'll only respond when @mentioned\n" +
+          "• /bot help — see all commands",
+      );
+      logVerbose(`badgerclaw: sent encryption handshake + hint notice in room ${roomId}`);
+    } catch (err) {
+      runtime.log?.(`badgerclaw: encryption handshake failed for room ${roomId}: ${String(err)}`);
+    }
+  }
+
   if (autoJoin === "always") {
     // Use the built-in autojoin mixin for "always" mode
     const { AutojoinRoomsMixin } = loadMatrixSdk();
     AutojoinRoomsMixin.setupOnClient(client);
     logVerbose("badgerclaw: auto-join enabled for all invites");
 
-    // Also join any rooms with pending invites from before startup
-    (async () => {
-      try {
-        const syncData = await client.doRequest("GET", "/_matrix/client/v3/sync", { timeout: "0" });
-        const invitedRooms = Object.keys(syncData?.rooms?.invite ?? {});
-        for (const roomId of invitedRooms) {
-          try {
-            await client.joinRoom(roomId);
-            logVerbose(`badgerclaw: joined pending invite room ${roomId}`);
-          } catch (err) {
-            logVerbose(`badgerclaw: failed to join pending invite ${roomId}: ${err}`);
-          }
-        }
-      } catch {
-        // Ignore sync errors
-      }
-    })();
-
-    // When bot joins a new room, send a presence message to force Megolm session rotation
-    // This ensures all clients create a new session that includes the bot's device
-    client.on("room.join", async (roomId: string) => {
-      logVerbose(`badgerclaw: bot joined room ${roomId}, requesting key share`);
-      try {
-        // Send a dummy state event to signal our device presence
-        // This forces clients to include our device in the next Megolm session
-        await client.sendStateEvent(roomId, "m.room.member", await client.getUserId(), {
-          membership: "join",
-          displayname: "testbot",
-        }).catch(() => {});
-
-        // Also send a notice message to trigger session rotation
-        await client.sendNotice(roomId, "🦡 Bot connected to this room.").catch(() => {});
-      } catch (err) {
-        logVerbose(`badgerclaw: failed to send join notice in ${roomId}: ${err}`);
+    // AutojoinRoomsMixin handles the join, so listen for room.join to run post-join logic
+    client.on("room.join", async (roomId: string, _joinEvent: unknown) => {
+      logVerbose(`badgerclaw: bot joined room ${roomId} (always mode), running post-join handshake`);
+      if (cfg.chatHistory?.enabled) {
+        initRoomHistory(roomId);
       }
+      await postJoinEncryptionHandshake(roomId);
     });
     return;
   }
@@ -112,6 +115,10 @@ export function registerMatrixAutoJoin(params: {
     try {
       await client.joinRoom(roomId);
       logVerbose(`badgerclaw: joined room ${roomId}`);
+      if (cfg.chatHistory?.enabled) {
+        initRoomHistory(roomId);
+      }
+      await postJoinEncryptionHandshake(roomId);
     } catch (err) {
       runtime.error?.(`badgerclaw: failed to join room ${roomId}: ${String(err)}`);
     }

package/src/matrix/monitor/bot-commands.ts

@@ -13,7 +13,12 @@ const SESSION_STORE_PATH = path.join(
   ".openclaw/agents/main/sessions/sessions.json"
 );
 
-function loadRoomConfig(): Record<string, { autoReply?: boolean }> {
+type RoomConfig = {
+  autoReply?: boolean; // legacy — kept for migration
+  activeBots?: string[]; // per-bot auto-reply list
+};
+
+function loadRoomConfig(): Record<string, RoomConfig> {
   try {
     return JSON.parse(fs.readFileSync(ROOM_CONFIG_PATH, "utf-8"));
   } catch {
@@ -21,14 +26,13 @@ function loadRoomConfig(): Record<string, { autoReply?: boolean }> {
   }
 }
 
-function saveRoomConfig(config: Record<string, { autoReply?: boolean }>): void {
+function saveRoomConfig(config: Record<string, RoomConfig>): void {
   fs.writeFileSync(ROOM_CONFIG_PATH, JSON.stringify(config, null, 2));
 }
 
 function setGroupActivation(roomId: string, activation: "always" | "mention"): void {
   try {
     const store = JSON.parse(fs.readFileSync(SESSION_STORE_PATH, "utf-8"));
-    // Session key format: agent:main:badgerclaw:channel:!roomid (lowercase)
     const sessionKey = `agent:main:badgerclaw:channel:${roomId.toLowerCase()}`;
     if (!store[sessionKey]) {
       store[sessionKey] = {};
@@ -41,9 +45,82 @@ function setGroupActivation(roomId: string, activation: "always" | "mention"): v
   }
 }
 
+/**
+ * Check if a specific bot has auto-reply enabled in a room.
+ * Returns true if the bot is in the activeBots list.
+ * Migrates legacy autoReply boolean to activeBots format.
+ */
+export function isBotAutoReplyEnabled(roomId: string, botUserId: string): boolean | undefined {
+  const config = loadRoomConfig();
+  const normalizedRoomId = roomId.toLowerCase();
+  const keys = Object.keys(config);
+  const matchedKey = keys.find((k) => k.toLowerCase() === normalizedRoomId);
+  if (!matchedKey) return undefined;
+
+  const room = config[matchedKey];
+
+  // New format: check activeBots list
+  if (Array.isArray(room.activeBots)) {
+    return room.activeBots.some(
+      (b) => b.toLowerCase() === botUserId.toLowerCase()
+    );
+  }
+
+  // Legacy migration: if autoReply is set but no activeBots, treat as legacy
+  if (typeof room.autoReply === "boolean") {
+    return room.autoReply;
+  }
+
+  return undefined;
+}
+
+// Legacy compat export
 export function getRoomAutoReply(roomId: string): boolean | undefined {
   const config = loadRoomConfig();
-  return config[roomId]?.autoReply;
+  const normalizedRoomId = roomId.toLowerCase();
+  const keys = Object.keys(config);
+  const matchedKey = keys.find((k) => k.toLowerCase() === normalizedRoomId);
+  if (!matchedKey) return undefined;
+
+  const room = config[matchedKey];
+  if (Array.isArray(room.activeBots) && room.activeBots.length > 0) {
+    return true; // At least one bot is active
+  }
+  return room.autoReply;
+}
+
+function addBotToActive(roomId: string, botUserId: string): void {
+  const config = loadRoomConfig();
+  const normalizedRoomId = roomId.toLowerCase();
+  if (!config[normalizedRoomId]) {
+    config[normalizedRoomId] = {};
+  }
+  const room = config[normalizedRoomId];
+  if (!Array.isArray(room.activeBots)) {
+    room.activeBots = [];
+  }
+  const botLower = botUserId.toLowerCase();
+  if (!room.activeBots.some((b) => b.toLowerCase() === botLower)) {
+    room.activeBots.push(botUserId);
+  }
+  // Clear legacy field
+  delete room.autoReply;
+  saveRoomConfig(config);
+}
+
+function removeAllActiveBots(roomId: string): void {
+  const config = loadRoomConfig();
+  const normalizedRoomId = roomId.toLowerCase();
+  if (!config[normalizedRoomId]) {
+    config[normalizedRoomId] = {};
+  }
+  config[normalizedRoomId].activeBots = [];
+  delete config[normalizedRoomId].autoReply;
+  saveRoomConfig(config);
+}
+
+function getDisplayName(userId: string): string {
+  return userId.split(":")[0];
 }
 
 export async function handleBotCommand(params: {
@@ -63,7 +140,6 @@ export async function handleBotCommand(params: {
   const parts = trimmed.split(/\s+/);
   const command = parts[1]?.toLowerCase();
   const arg = parts[2]?.toLowerCase();
-  const arg2 = parts[3];
 
   try {
     switch (command) {
@@ -77,112 +153,196 @@ export async function handleBotCommand(params: {
             "",
             "/bot help",
             "  Show this help message with all available commands.",
-            "  Works in: Any room or DM",
             "",
             "/bot talk on",
-            "  Enable auto-reply mode. The bot will respond to every",
-            "  message in this room without needing an @mention.",
-            "  Perfect for 1-on-1 rooms with your AI assistant.",
-            "  Works in: Any room or DM",
+            "  Enable auto-reply for this bot. It will respond to",
+            "  every message without needing an @mention.",
+            "  If multiple bots are in the room, specify which one:",
+            "  /bot talk on @botname",
             "",
             "/bot talk off",
-            "  Disable auto-reply mode. The bot will only respond",
-            "  when @mentioned. Use this in busy group rooms where",
-            "  you don't want the bot responding to everything.",
-            "  Works in: Any room or DM",
+            "  Disable auto-reply for ALL bots in this room.",
+            "  All bots go back to mention-only mode.",
             "",
             "/bot add <botname>",
-            "  Invite a bot to the current room. The bot username",
-            "  will be @<botname>_bot on this server.",
+            "  Invite a bot to the current room.",
             "  Example: /bot add jarvis → invites @jarvis_bot",
-            "  Works in: Any room",
+            "  Also accepts: /bot add @jarvis_bot",
             "",
-            "━━━ BotBadger DM Only ━━━",
-            "",
-            "/bot new",
-            "  Create a new bot. Starts a guided flow to set up",
-            "  a bot name, username, and generate a pairing code",
-            "  for connecting to an OpenClaw instance.",
-            "  Works in: Direct message with BotBadger only",
-            "",
-            "/bot pair <name>",
-            "  Generate a new pairing code for an existing bot.",
-            "  Use this to connect or reconnect a bot to OpenClaw.",
-            "  Works in: Direct message with BotBadger only",
+            "/bot list",
+            "  List all bots in this room and their auto-reply status.",
             "",
-            "/bot delete <name>",
-            "  Permanently delete a bot and remove it from all rooms.",
-            "  This action cannot be undone.",
-            "  Works in: Direct message with BotBadger only",
+            "━━━ BotBadger DM Only ━━━",
             "",
-            "/bot list",
-            "  List all your bots and their connection status.",
-            "  🟢 Connected — bot is online and responding",
-            "  🔴 Not connected — bot needs pairing",
-            "  Works in: Any room or DM",
+            "/bot new — Create a new bot",
+            "/bot pair <name> — Get a pairing code",
+            "/bot delete <name> — Permanently delete a bot",
           ].join("\n"),
         });
         return true;
       }
 
       case "talk": {
+        // Resolve bot members in the room
+        const botSuffix = "_bot:badger.signout.io";
+        let roomBots: string[] = [];
+        try {
+          const members = await client.getJoinedRoomMembers(roomId);
+          roomBots = members.filter((m: string) => m.includes(botSuffix) && m !== selfUserId);
+        } catch {
+          // If we can't list members, proceed as single-bot
+        }
+        const multipleBots = roomBots.length > 0;
+
+        // Check if a specific bot was mentioned: /bot talk on @botname
+        const mentionArg = parts.slice(3).join(" ").trim();
+        const mentionedBot = mentionArg
+          ? mentionArg.startsWith("@") ? mentionArg : `@${mentionArg}`
+          : null;
+
+        // If a bot was mentioned and it's not us, ignore the command (let that bot handle it)
+        if (mentionedBot) {
+          const mentionLower = mentionedBot.toLowerCase();
+          const selfLower = selfUserId.toLowerCase();
+          const selfLocalpart = selfLower.split(":")[0];
+          if (!selfLower.startsWith(mentionLower) && !mentionLower.startsWith(selfLocalpart)) {
+            return false;
+          }
+        }
+
         if (arg === "on") {
-          const config = loadRoomConfig();
-          config[roomId] = { ...config[roomId], autoReply: true };
-          saveRoomConfig(config);
+          // Multiple bots + no specific mention → ask which bot
+          if (multipleBots && !mentionedBot) {
+            const allBots = [selfUserId, ...roomBots];
+            const config = loadRoomConfig();
+            const normalizedRoomId = roomId.toLowerCase();
+            const active = config[normalizedRoomId]?.activeBots ?? [];
+
+            const botList = allBots
+              .map((b, i) => {
+                const name = getDisplayName(b);
+                const isActive = active.some((a) => a.toLowerCase() === b.toLowerCase());
+                return `  ${i + 1}. ${name} ${isActive ? "🟢 auto-reply on" : "⚪ mention-only"}`;
+              })
+              .join("\n");
+
+            await client.sendMessage(roomId, {
+              msgtype: "m.text",
+              body: [
+                "🦡 Multiple bots in this room:",
+                "",
+                botList,
+                "",
+                "Specify which bot: /bot talk on @botname",
+              ].join("\n"),
+            });
+            return true;
+          }
+
+          // Add THIS bot to activeBots
+          addBotToActive(roomId, selfUserId);
           setGroupActivation(roomId, "always");
           await client.sendMessage(roomId, {
             msgtype: "m.text",
-            body: "✅ Auto-reply enabled — I'll respond to every message in this room.",
+            body: `✅ Auto-reply enabled for ${getDisplayName(selfUserId)} — I'll respond to every message in this room.`,
           });
           return true;
         }
+
         if (arg === "off") {
-          const config = loadRoomConfig();
-          config[roomId] = { ...config[roomId], autoReply: false };
-          saveRoomConfig(config);
+          // Kill switch — remove ALL bots from activeBots
+          removeAllActiveBots(roomId);
           setGroupActivation(roomId, "mention");
           await client.sendMessage(roomId, {
             msgtype: "m.text",
-            body: "✅ Auto-reply disabled — I'll only respond when @mentioned.",
+            body: "✅ Auto-reply disabled for all bots — bots will only respond when @mentioned.",
           });
           return true;
         }
+
         await client.sendMessage(roomId, {
           msgtype: "m.text",
-          body: "Usage: /bot talk on  or  /bot talk off",
+          body: "Usage: /bot talk on [@botname]  or  /bot talk off",
         });
         return true;
       }
 
       case "add": {
-        const botName = arg;
-        if (!botName) {
+        let rawName = parts.slice(2).join(" ").trim();
+        if (!rawName) {
           await client.sendMessage(roomId, {
             msgtype: "m.text",
-            body: "Usage: /bot add <botname>",
+            body: "Usage: /bot add <botname>\nExample: /bot add jarvis  or  /bot add @jarvis_bot",
           });
           return true;
         }
-        const botUserId = `@${botName}_bot:badger.signout.io`;
+        rawName = rawName.replace(/^@/, "").split(":")[0].replace(/_bot$/i, "").toLowerCase();
+        const addBotUserId = `@${rawName}_bot:badger.signout.io`;
+        const addBotDisplay = `@${rawName}_bot`;
         try {
-          await client.inviteUser(botUserId, roomId);
+          await client.inviteUser(addBotUserId, roomId);
           await client.sendMessage(roomId, {
             msgtype: "m.text",
-            body: `✅ Invited ${botUserId} to this room.`,
+            body: `✅ Invited ${addBotDisplay} to this room.`,
           });
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
+          const cleanMsg = msg.replace(/:badger\.signout\.io/g, "");
           await client.sendMessage(roomId, {
             msgtype: "m.text",
-            body: `❌ Failed to invite ${botUserId}: ${msg}`,
+            body: `❌ Failed to invite ${addBotDisplay}: ${cleanMsg}`,
           });
         }
         return true;
       }
 
+      case "list": {
+        const botSuffix2 = "_bot:badger.signout.io";
+        let botsInRoom: string[] = [];
+        try {
+          const members = await client.getJoinedRoomMembers(roomId);
+          botsInRoom = members.filter((m: string) => m.includes(botSuffix2));
+        } catch {
+          botsInRoom = [selfUserId];
+        }
+
+        if (botsInRoom.length === 0) {
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: "No bots in this room.",
+          });
+          return true;
+        }
+
+        const config = loadRoomConfig();
+        const normalizedRoomId = roomId.toLowerCase();
+        const active = config[normalizedRoomId]?.activeBots ?? [];
+        // Legacy: if autoReply is true and no activeBots, all bots are active
+        const legacyAllActive = !Array.isArray(config[normalizedRoomId]?.activeBots) && config[normalizedRoomId]?.autoReply === true;
+
+        const botList = botsInRoom
+          .map((b) => {
+            const displayName = getDisplayName(b);
+            const isMe = b === selfUserId;
+            const isActive = legacyAllActive || active.some((a) => a.toLowerCase() === b.toLowerCase());
+            return `  ${isActive ? "🟢" : "⚪"} ${displayName}${isMe ? " (me)" : ""} — ${isActive ? "auto-reply on" : "mention-only"}`;
+          })
+          .join("\n");
+
+        await client.sendMessage(roomId, {
+          msgtype: "m.text",
+          body: [
+            "🦡 Bots in this room:",
+            "",
+            botList,
+            "",
+            `${botsInRoom.length} bot${botsInRoom.length === 1 ? "" : "s"} total`,
+          ].join("\n"),
+        });
+        return true;
+      }
+
       default: {
-        // Unknown /bot command — show help hint
         await client.sendMessage(roomId, {
           msgtype: "m.text",
           body: "Unknown command. Type /bot help for available commands.",
@@ -192,6 +352,6 @@ export async function handleBotCommand(params: {
     }
   } catch (err) {
     console.error("badgerclaw: bot command error:", err);
-    return true; // Still consumed the command
+    return true;
   }
 }

package/src/matrix/monitor/chat-history.ts

@@ -0,0 +1,75 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const HISTORY_DIR = path.join(os.homedir(), ".openclaw", "extensions", "badgerclaw", "history");
+const MAX_MESSAGES = 200;
+
+export interface HistoryEntry {
+  ts: string;       // ISO timestamp
+  sender: string;   // display name or username
+  text: string;     // message text
+  role: "user" | "bot";
+}
+
+export function getHistoryPath(roomId: string): string {
+  // Sanitize roomId for filename: replace ! and : with safe chars
+  const safe = roomId.replace(/[!:]/g, "_").replace(/\./g, "-");
+  return path.join(HISTORY_DIR, `${safe}.md`);
+}
+
+export function ensureHistoryDir(): void {
+  if (!fs.existsSync(HISTORY_DIR)) {
+    fs.mkdirSync(HISTORY_DIR, { recursive: true });
+  }
+}
+
+export function readHistory(roomId: string): HistoryEntry[] {
+  const filePath = getHistoryPath(roomId);
+  if (!fs.existsSync(filePath)) return [];
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    const lines = content.split("\n").filter((l: string) => l.startsWith("["));
+    return lines.map((line: string) => {
+      // Format: [2026-03-27T08:05:00Z] [user] sender: text
+      const match = line.match(/^\[([^\]]+)\] \[(user|bot)\] ([^:]+): (.+)$/);
+      if (!match) return null;
+      return { ts: match[1], role: match[2] as "user" | "bot", sender: match[3], text: match[4] };
+    }).filter(Boolean) as HistoryEntry[];
+  } catch {
+    return [];
+  }
+}
+
+export function appendHistory(roomId: string, entry: HistoryEntry, roomName?: string): void {
+  ensureHistoryDir();
+  const filePath = getHistoryPath(roomId);
+
+  // Read existing, append, trim to 200
+  let entries = readHistory(roomId);
+  entries.push(entry);
+  if (entries.length > MAX_MESSAGES) {
+    entries = entries.slice(entries.length - MAX_MESSAGES);
+  }
+
+  // Write header + entries
+  const header = `# Chat History — ${roomId}\n# Group: ${roomName || roomId} | Updated: ${new Date().toISOString()}\n# Last ${MAX_MESSAGES} messages (rolling)\n\n`;
+  const body = entries.map(e => `[${e.ts}] [${e.role}] ${e.sender}: ${e.text}`).join("\n");
+  fs.writeFileSync(filePath, header + body + "\n", "utf8");
+}
+
+export function formatHistoryForContext(roomId: string): string | null {
+  const entries = readHistory(roomId);
+  if (entries.length === 0) return null;
+  const lines = entries.map(e => `${e.sender}: ${e.text}`).join("\n");
+  return `## Recent conversation history (last ${entries.length} messages):\n${lines}\n\n---\n`;
+}
+
+export function initRoomHistory(roomId: string, roomName?: string): void {
+  ensureHistoryDir();
+  const filePath = getHistoryPath(roomId);
+  if (!fs.existsSync(filePath)) {
+    const header = `# Chat History — ${roomId}\n# Group: ${roomName || roomId} | Created: ${new Date().toISOString()}\n# Last ${MAX_MESSAGES} messages (rolling)\n\n`;
+    fs.writeFileSync(filePath, header, "utf8");
+  }
+}

package/src/matrix/monitor/handler.ts

@@ -30,6 +30,7 @@ import {
   resolveMatrixAllowListMatch,
   resolveMatrixAllowListMatches,
 } from "./allowlist.js";
+import { appendHistory, formatHistoryForContext } from "./chat-history.js";
 import {
   resolveMatrixBodyForAgent,
   resolveMatrixInboundSenderLabel,
@@ -472,14 +473,50 @@ export function createMatrixRoomMessageHandler(params: MatrixMonitorHandlerParam
         });
         return;
       }
+      // Check room-config.json first (set by /bot talk on|off) — it takes priority
+      // over the OpenClaw config wildcard entry. Supports per-bot activeBots list.
+      const roomConfigJsonAutoReply = (() => {
+        try {
+          const fs = require("fs");
+          const path = require("path");
+          const configPath = path.join(
+            process.env.HOME || "/tmp",
+            ".openclaw/extensions/badgerclaw/room-config.json"
+          );
+          const raw = fs.readFileSync(configPath, "utf-8");
+          const roomCfg = JSON.parse(raw) as Record<string, { autoReply?: boolean; activeBots?: string[] }>;
+          const normalizedRoomId = roomId.toLowerCase();
+          const keys = Object.keys(roomCfg);
+          const matchedKey = keys.find((k) => k.toLowerCase() === normalizedRoomId);
+          if (matchedKey) {
+            const entry = roomCfg[matchedKey];
+            // New per-bot format: check if THIS bot is in activeBots
+            if (Array.isArray(entry.activeBots)) {
+              const botActive = entry.activeBots.some(
+                (b: string) => b.toLowerCase() === selfUserId.toLowerCase()
+              );
+              return botActive; // true = this bot auto-replies, false = mention-only
+            }
+            // Legacy format
+            if (typeof entry.autoReply === "boolean") {
+              return entry.autoReply;
+            }
+          }
+        } catch { /* ignore */ }
+        return undefined;
+      })();
       const shouldRequireMention = isRoom
-        ? roomConfig?.autoReply === true
+        ? roomConfigJsonAutoReply === true
           ? false
-          : roomConfig?.autoReply === false
+          : roomConfigJsonAutoReply === false
             ? true
-            : typeof roomConfig?.requireMention === "boolean"
-              ? roomConfig?.requireMention
-              : true
+            : roomConfig?.autoReply === true
+              ? false
+              : roomConfig?.autoReply === false
+                ? true
+                : typeof roomConfig?.requireMention === "boolean"
+                  ? roomConfig?.requireMention
+                  : true
         : false;
       const shouldBypassMention =
         allowTextCommands &&
@@ -594,13 +631,33 @@ export function createMatrixRoomMessageHandler(params: MatrixMonitorHandlerParam
       });
 
       const groupSystemPrompt = roomConfig?.systemPrompt?.trim() || undefined;
+
+      // Append inbound user message to chat history
+      if (cfg.chatHistory?.enabled) {
+        appendHistory(roomId, {
+          ts: new Date().toISOString(),
+          role: "user",
+          sender: senderName || senderId,
+          text: bodyText,
+        }, roomName);
+      }
+
+      // Inject rolling history into BodyForAgent context
+      let bodyForAgent = resolveMatrixBodyForAgent({
+        isDirectMessage,
+        bodyText,
+        senderLabel,
+      });
+      if (cfg.chatHistory?.enabled) {
+        const history = formatHistoryForContext(roomId);
+        if (history) {
+          bodyForAgent = history + bodyForAgent;
+        }
+      }
+
       const ctxPayload = core.channel.reply.finalizeInboundContext({
         Body: body,
-        BodyForAgent: resolveMatrixBodyForAgent({
-          isDirectMessage,
-          bodyText,
-          senderLabel,
-        }),
+        BodyForAgent: bodyForAgent,
         RawBody: bodyText,
         CommandBody: bodyText,
         From: isDirectMessage ? `badgerclaw:${senderId}` : `badgerclaw:channel:${roomId}`,
@@ -739,6 +796,15 @@ export function createMatrixRoomMessageHandler(params: MatrixMonitorHandlerParam
               accountId: route.accountId,
               tableMode,
             });
+            if (cfg.chatHistory?.enabled && payload?.text) {
+              const botSender = resolveMatrixSenderUsername(selfUserId) || selfUserId;
+              appendHistory(roomId, {
+                ts: new Date().toISOString(),
+                role: "bot",
+                sender: botSender,
+                text: payload.text,
+              }, roomName);
+            }
             didSendReply = true;
           },
           onError: (err, info) => {

package/src/onboarding.ts

@@ -245,6 +245,16 @@ export const badgerclawOnboardingAdapter: ChannelOnboardingAdapter = {
             autoJoin: "always",
             // Open policy: bot responds in any room it's invited to
             groupPolicy: "open",
+            // Default group config: auto-reply in all rooms.
+            // No systemPrompt override — the bot respects the user's workspace personality
+            // (SOUL.md, IDENTITY.md, etc.). When the bot joins a group, it sends a hint
+            // message about /bot talk on|off so users know how to control it.
+            groups: {
+              "*": {
+                autoReply: true,
+                enabled: true,
+              },
+            },
             dm: {
               ...next.channels?.badgerclaw?.dm,
               policy: "open",

package/src/types.ts

@@ -114,5 +114,8 @@ export type CoreConfig = {
     ackReaction?: string;
     ackReactionScope?: "group-mentions" | "group-all" | "direct" | "all" | "off" | "none";
   };
+  chatHistory?: {
+    enabled: boolean;
+  };
   [key: string]: unknown;
 };

package/room-config.json

@@ -1,8 +0,0 @@
-{
-  "!oVrHNyMFgnOCfmjlLU:badger.signout.io": {
-    "autoReply": true
-  },
-  "!hcLBnfZOzoIHENRxuU:badger.signout.io": {
-    "autoReply": true
-  }
-}