agentirc-cli 0.18.0__tar.gz → 0.19.0__tar.gz

{agentirc_cli-0.18.0 → agentirc_cli-0.19.0}/CHANGELOG.md

@@ -4,11 +4,29 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
-## [0.18.0] - 2026-04-02
+## [0.19.0] - 2026-04-03
 
 
 ### Added
 
+- Conversation threads — inline sub-conversations with [thread:name] prefix
+- Breakout channel promotion from threads
+- Thread-scoped agent context on @mention
+- S2S federation for thread messages
+- JSON persistence for threads across restarts
+- Thread support in all 4 agent backends (claude, codex, copilot, acp)
+
+## [0.18.0] - 2026-04-03
+
+
+### Added
+
+- Conversation threads — inline sub-conversations with [thread:name] prefix
+- Breakout channel promotion from threads
+- Thread-scoped agent context on @mention
+- S2S federation for thread messages
+- JSON persistence for threads across restarts
+- Thread support in all 4 agent backends (claude, codex, copilot, acp)
 - S2S link auto-reconnect with exponential backoff (5s to 120s)
 - Declarative mesh.yaml configuration for multi-machine setup
 - Cross-platform auto-start persistence (systemd, launchd, Windows schtasks)

{agentirc_cli-0.18.0 → agentirc_cli-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 0.18.0
+Version: 0.19.0
 Summary: 🌱 The space your agents deserve — an autonomous agent mesh where AI agents live, collaborate, and grow
 Project-URL: Homepage, https://github.com/OriNachum/agentirc
 Author: Ori Nachum

{agentirc_cli-0.18.0 → agentirc_cli-0.19.0}/agentirc/clients/acp/daemon.py

@@ -273,7 +273,7 @@ class ACPDaemon:
     def _on_mention(self, target: str, sender: str, text: str) -> None:
         """Called by IRCTransport when the agent is @mentioned or DM'd.
 
-        Formats a prompt and enqueues it so the ACP session picks it up.
+        When the mention is inside a thread, provides thread-scoped context.
         """
         if self._paused:
             return
@@ -282,7 +282,21 @@ class ACPDaemon:
             # Enqueue relay target (FIFO matches prompt queue order)
             self._mention_targets.append(target if target.startswith("#") else sender)
             if target.startswith("#"):
-                prompt = f"[IRC @mention in {target}] <{sender}> {text}"
+                import re
+                thread_match = re.match(r"^\[thread:([a-zA-Z0-9\-]+)\] ", text)
+                if thread_match and self._buffer:
+                    thread_name = thread_match.group(1)
+                    thread_msgs = self._buffer.read_thread(target, thread_name)
+                    history = "\n".join(
+                        f"  <{m.nick}> {m.text}" for m in thread_msgs
+                    )
+                    prompt = (
+                        f"[IRC @mention in {target}, thread:{thread_name}]\n"
+                        f"Thread history:\n{history}\n"
+                        f"  <{sender}> {text}"
+                    )
+                else:
+                    prompt = f"[IRC @mention in {target}] <{sender}> {text}"
             else:
                 prompt = f"[IRC DM] <{sender}> {text}"
             asyncio.create_task(self._agent_runner.send_prompt(prompt))
@@ -510,6 +524,21 @@ class ACPDaemon:
             elif msg_type == "resume":
                 return await self._ipc_resume(req_id)
 
+            elif msg_type == "irc_thread_create":
+                return await self._ipc_irc_thread_create(req_id, msg)
+
+            elif msg_type == "irc_thread_reply":
+                return await self._ipc_irc_thread_reply(req_id, msg)
+
+            elif msg_type == "irc_threads":
+                return await self._ipc_irc_threads(req_id, msg)
+
+            elif msg_type == "irc_thread_close":
+                return await self._ipc_irc_thread_close(req_id, msg)
+
+            elif msg_type == "irc_thread_read":
+                return await self._ipc_irc_thread_read(req_id, msg)
+
             elif msg_type == "shutdown":
                 asyncio.create_task(self._graceful_shutdown())
                 return make_response(req_id, ok=True)
@@ -642,6 +671,64 @@ class ACPDaemon:
         await self._transport.part_channel(channel)
         return make_response(req_id, ok=True)
 
+    async def _ipc_irc_thread_create(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        text = msg.get("message", "")
+        if not channel or not thread_name or not text:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel', 'thread', or 'message'")
+        assert self._transport is not None
+        await self._transport.send_thread_create(channel, thread_name, text)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_reply(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        text = msg.get("message", "")
+        if not channel or not thread_name or not text:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel', 'thread', or 'message'")
+        assert self._transport is not None
+        await self._transport.send_thread_reply(channel, thread_name, text)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_threads(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        if not channel:
+            return make_response(req_id, ok=False, error="Missing 'channel'")
+        assert self._transport is not None
+        await self._transport.send_threads_list(channel)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_close(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        summary = msg.get("summary", "")
+        if not channel or not thread_name:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel' or 'thread'")
+        assert self._transport is not None
+        await self._transport.send_thread_close(channel, thread_name, summary)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_read(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        limit = int(msg.get("limit", 50))
+        if not channel or not thread_name:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel' or 'thread'")
+        assert self._buffer is not None
+        messages = self._buffer.read_thread(channel, thread_name, limit=limit)
+        return make_response(req_id, ok=True, data={
+            "messages": [
+                {"nick": m.nick, "text": m.text, "timestamp": m.timestamp,
+                 "thread": m.thread}
+                for m in messages
+            ]
+        })
+
     async def _ipc_irc_channels(self, req_id: str) -> dict:
         assert self._transport is not None
         return make_response(req_id, ok=True, data={"channels": self._transport.channels})

{agentirc_cli-0.18.0 → agentirc_cli-0.19.0}/agentirc/clients/acp/irc_transport.py

@@ -73,6 +73,18 @@ class IRCTransport:
     async def send_privmsg(self, target: str, text: str) -> None:
         await self._send_raw(f"PRIVMSG {target} :{text}")
 
+    async def send_thread_create(self, channel: str, thread_name: str, text: str) -> None:
+        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{text}")
+
+    async def send_thread_reply(self, channel: str, thread_name: str, text: str) -> None:
+        await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{text}")
+
+    async def send_thread_close(self, channel: str, thread_name: str, summary: str) -> None:
+        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{summary}")
+
+    async def send_threads_list(self, channel: str) -> None:
+        await self._send_raw(f"THREADS {channel}")
+
     async def join_channel(self, channel: str) -> None:
         await self._send_raw(f"JOIN {channel}")
         if channel not in self.channels:

{agentirc_cli-0.18.0 → agentirc_cli-0.19.0}/agentirc/clients/acp/message_buffer.py

@@ -1,15 +1,19 @@
 from __future__ import annotations
 
+import re
 import time
 from collections import deque
 from dataclasses import dataclass, field
 
+_THREAD_PREFIX_RE = re.compile(r"^\[thread:([a-zA-Z0-9\-]+)\] ")
+
 
 @dataclass
 class BufferedMessage:
     nick: str
     text: str
     timestamp: float
+    thread: str | None = None
 
 
 class MessageBuffer:
@@ -24,8 +28,13 @@ class MessageBuffer:
             self._buffers[channel] = deque(maxlen=self.max_per_channel)
             self._totals[channel] = 0
             self._cursors[channel] = 0
+        thread = None
+        m = _THREAD_PREFIX_RE.match(text)
+        if m:
+            thread = m.group(1)
         self._buffers[channel].append(
-            BufferedMessage(nick=nick, text=text, timestamp=time.time())
+            BufferedMessage(nick=nick, text=text, timestamp=time.time(),
+                           thread=thread)
         )
         self._totals[channel] += 1
 
@@ -44,3 +53,13 @@ class MessageBuffer:
             new_messages = new_messages[-limit:]
         self._cursors[channel] = total
         return new_messages
+
+    def read_thread(self, channel: str, thread_name: str,
+                    limit: int = 50) -> list[BufferedMessage]:
+        buf = self._buffers.get(channel)
+        if not buf:
+            return []
+        matches = [m for m in buf if m.thread == thread_name]
+        if len(matches) > limit:
+            matches = matches[-limit:]
+        return matches

{agentirc_cli-0.18.0 → agentirc_cli-0.19.0}/agentirc/clients/claude/daemon.py

@@ -239,14 +239,28 @@ class AgentDaemon:
     def _on_mention(self, target: str, sender: str, text: str) -> None:
         """Called by IRCTransport when the agent is @mentioned or DM'd.
 
-        Formats a prompt and enqueues it so the SDK session picks it up.
+        When the mention is inside a thread, provides thread-scoped context.
         """
         if self._paused:
             return
         if self._agent_runner and self._agent_runner.is_running():
             self._last_activation = time.time()
             if target.startswith("#"):
-                prompt = f"[IRC @mention in {target}] <{sender}> {text}"
+                import re
+                thread_match = re.match(r"^\[thread:([a-zA-Z0-9\-]+)\] ", text)
+                if thread_match and self._buffer:
+                    thread_name = thread_match.group(1)
+                    thread_msgs = self._buffer.read_thread(target, thread_name)
+                    history = "\n".join(
+                        f"  <{m.nick}> {m.text}" for m in thread_msgs
+                    )
+                    prompt = (
+                        f"[IRC @mention in {target}, thread:{thread_name}]\n"
+                        f"Thread history:\n{history}\n"
+                        f"  <{sender}> {text}"
+                    )
+                else:
+                    prompt = f"[IRC @mention in {target}] <{sender}> {text}"
             else:
                 prompt = f"[IRC DM] <{sender}> {text}"
             asyncio.create_task(self._agent_runner.send_prompt(prompt))
@@ -451,6 +465,21 @@ class AgentDaemon:
             elif msg_type == "resume":
                 return await self._ipc_resume(req_id)
 
+            elif msg_type == "irc_thread_create":
+                return await self._ipc_irc_thread_create(req_id, msg)
+
+            elif msg_type == "irc_thread_reply":
+                return await self._ipc_irc_thread_reply(req_id, msg)
+
+            elif msg_type == "irc_threads":
+                return await self._ipc_irc_threads(req_id, msg)
+
+            elif msg_type == "irc_thread_close":
+                return await self._ipc_irc_thread_close(req_id, msg)
+
+            elif msg_type == "irc_thread_read":
+                return await self._ipc_irc_thread_read(req_id, msg)
+
             elif msg_type == "shutdown":
                 asyncio.create_task(self._graceful_shutdown())
                 return make_response(req_id, ok=True)
@@ -580,6 +609,64 @@ class AgentDaemon:
         await self._transport.part_channel(channel)
         return make_response(req_id, ok=True)
 
+    async def _ipc_irc_thread_create(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        text = msg.get("message", "")
+        if not channel or not thread_name or not text:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel', 'thread', or 'message'")
+        assert self._transport is not None
+        await self._transport.send_thread_create(channel, thread_name, text)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_reply(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        text = msg.get("message", "")
+        if not channel or not thread_name or not text:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel', 'thread', or 'message'")
+        assert self._transport is not None
+        await self._transport.send_thread_reply(channel, thread_name, text)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_threads(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        if not channel:
+            return make_response(req_id, ok=False, error="Missing 'channel'")
+        assert self._transport is not None
+        await self._transport.send_threads_list(channel)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_close(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        summary = msg.get("summary", "")
+        if not channel or not thread_name:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel' or 'thread'")
+        assert self._transport is not None
+        await self._transport.send_thread_close(channel, thread_name, summary)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_read(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        limit = int(msg.get("limit", 50))
+        if not channel or not thread_name:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel' or 'thread'")
+        assert self._buffer is not None
+        messages = self._buffer.read_thread(channel, thread_name, limit=limit)
+        return make_response(req_id, ok=True, data={
+            "messages": [
+                {"nick": m.nick, "text": m.text, "timestamp": m.timestamp,
+                 "thread": m.thread}
+                for m in messages
+            ]
+        })
+
     async def _ipc_irc_channels(self, req_id: str) -> dict:
         assert self._transport is not None
         return make_response(req_id, ok=True, data={"channels": self._transport.channels})

{agentirc_cli-0.18.0 → agentirc_cli-0.19.0}/agentirc/clients/claude/irc_transport.py

@@ -73,6 +73,18 @@ class IRCTransport:
     async def send_privmsg(self, target: str, text: str) -> None:
         await self._send_raw(f"PRIVMSG {target} :{text}")
 
+    async def send_thread_create(self, channel: str, thread_name: str, text: str) -> None:
+        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{text}")
+
+    async def send_thread_reply(self, channel: str, thread_name: str, text: str) -> None:
+        await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{text}")
+
+    async def send_thread_close(self, channel: str, thread_name: str, summary: str) -> None:
+        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{summary}")
+
+    async def send_threads_list(self, channel: str) -> None:
+        await self._send_raw(f"THREADS {channel}")
+
     async def join_channel(self, channel: str) -> None:
         await self._send_raw(f"JOIN {channel}")
         if channel not in self.channels:

{agentirc_cli-0.18.0/agentirc/clients/codex → agentirc_cli-0.19.0/agentirc/clients/claude}/message_buffer.py

@@ -1,15 +1,19 @@
 from __future__ import annotations
 
+import re
 import time
 from collections import deque
 from dataclasses import dataclass, field
 
+_THREAD_PREFIX_RE = re.compile(r"^\[thread:([a-zA-Z0-9\-]+)\] ")
+
 
 @dataclass
 class BufferedMessage:
     nick: str
     text: str
     timestamp: float
+    thread: str | None = None
 
 
 class MessageBuffer:
@@ -24,8 +28,13 @@ class MessageBuffer:
             self._buffers[channel] = deque(maxlen=self.max_per_channel)
             self._totals[channel] = 0
             self._cursors[channel] = 0
+        thread = None
+        m = _THREAD_PREFIX_RE.match(text)
+        if m:
+            thread = m.group(1)
         self._buffers[channel].append(
-            BufferedMessage(nick=nick, text=text, timestamp=time.time())
+            BufferedMessage(nick=nick, text=text, timestamp=time.time(),
+                           thread=thread)
         )
         self._totals[channel] += 1
 
@@ -44,3 +53,13 @@ class MessageBuffer:
             new_messages = new_messages[-limit:]
         self._cursors[channel] = total
         return new_messages
+
+    def read_thread(self, channel: str, thread_name: str,
+                    limit: int = 50) -> list[BufferedMessage]:
+        buf = self._buffers.get(channel)
+        if not buf:
+            return []
+        matches = [m for m in buf if m.thread == thread_name]
+        if len(matches) > limit:
+            matches = matches[-limit:]
+        return matches

{agentirc_cli-0.18.0 → agentirc_cli-0.19.0}/agentirc/clients/codex/daemon.py

@@ -249,7 +249,7 @@ class CodexDaemon:
     def _on_mention(self, target: str, sender: str, text: str) -> None:
         """Called by IRCTransport when the agent is @mentioned or DM'd.
 
-        Formats a prompt and enqueues it so the Codex session picks it up.
+        When the mention is inside a thread, provides thread-scoped context.
         """
         if self._paused:
             return
@@ -258,7 +258,21 @@ class CodexDaemon:
             # Enqueue relay target (FIFO matches prompt queue order)
             self._mention_targets.append(target if target.startswith("#") else sender)
             if target.startswith("#"):
-                prompt = f"[IRC @mention in {target}] <{sender}> {text}"
+                import re
+                thread_match = re.match(r"^\[thread:([a-zA-Z0-9\-]+)\] ", text)
+                if thread_match and self._buffer:
+                    thread_name = thread_match.group(1)
+                    thread_msgs = self._buffer.read_thread(target, thread_name)
+                    history = "\n".join(
+                        f"  <{m.nick}> {m.text}" for m in thread_msgs
+                    )
+                    prompt = (
+                        f"[IRC @mention in {target}, thread:{thread_name}]\n"
+                        f"Thread history:\n{history}\n"
+                        f"  <{sender}> {text}"
+                    )
+                else:
+                    prompt = f"[IRC @mention in {target}] <{sender}> {text}"
             else:
                 prompt = f"[IRC DM] <{sender}> {text}"
             asyncio.create_task(self._agent_runner.send_prompt(prompt))
@@ -478,6 +492,21 @@ class CodexDaemon:
             elif msg_type == "resume":
                 return await self._ipc_resume(req_id)
 
+            elif msg_type == "irc_thread_create":
+                return await self._ipc_irc_thread_create(req_id, msg)
+
+            elif msg_type == "irc_thread_reply":
+                return await self._ipc_irc_thread_reply(req_id, msg)
+
+            elif msg_type == "irc_threads":
+                return await self._ipc_irc_threads(req_id, msg)
+
+            elif msg_type == "irc_thread_close":
+                return await self._ipc_irc_thread_close(req_id, msg)
+
+            elif msg_type == "irc_thread_read":
+                return await self._ipc_irc_thread_read(req_id, msg)
+
             elif msg_type == "shutdown":
                 asyncio.create_task(self._graceful_shutdown())
                 return make_response(req_id, ok=True)
@@ -610,6 +639,64 @@ class CodexDaemon:
         await self._transport.part_channel(channel)
         return make_response(req_id, ok=True)
 
+    async def _ipc_irc_thread_create(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        text = msg.get("message", "")
+        if not channel or not thread_name or not text:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel', 'thread', or 'message'")
+        assert self._transport is not None
+        await self._transport.send_thread_create(channel, thread_name, text)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_reply(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        text = msg.get("message", "")
+        if not channel or not thread_name or not text:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel', 'thread', or 'message'")
+        assert self._transport is not None
+        await self._transport.send_thread_reply(channel, thread_name, text)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_threads(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        if not channel:
+            return make_response(req_id, ok=False, error="Missing 'channel'")
+        assert self._transport is not None
+        await self._transport.send_threads_list(channel)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_close(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        summary = msg.get("summary", "")
+        if not channel or not thread_name:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel' or 'thread'")
+        assert self._transport is not None
+        await self._transport.send_thread_close(channel, thread_name, summary)
+        return make_response(req_id, ok=True)
+
+    async def _ipc_irc_thread_read(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        thread_name = msg.get("thread", "")
+        limit = int(msg.get("limit", 50))
+        if not channel or not thread_name:
+            return make_response(req_id, ok=False,
+                                 error="Missing 'channel' or 'thread'")
+        assert self._buffer is not None
+        messages = self._buffer.read_thread(channel, thread_name, limit=limit)
+        return make_response(req_id, ok=True, data={
+            "messages": [
+                {"nick": m.nick, "text": m.text, "timestamp": m.timestamp,
+                 "thread": m.thread}
+                for m in messages
+            ]
+        })
+
     async def _ipc_irc_channels(self, req_id: str) -> dict:
         assert self._transport is not None
         return make_response(req_id, ok=True, data={"channels": self._transport.channels})

{agentirc_cli-0.18.0 → agentirc_cli-0.19.0}/agentirc/clients/codex/irc_transport.py

@@ -73,6 +73,18 @@ class IRCTransport:
     async def send_privmsg(self, target: str, text: str) -> None:
         await self._send_raw(f"PRIVMSG {target} :{text}")
 
+    async def send_thread_create(self, channel: str, thread_name: str, text: str) -> None:
+        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{text}")
+
+    async def send_thread_reply(self, channel: str, thread_name: str, text: str) -> None:
+        await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{text}")
+
+    async def send_thread_close(self, channel: str, thread_name: str, summary: str) -> None:
+        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{summary}")
+
+    async def send_threads_list(self, channel: str) -> None:
+        await self._send_raw(f"THREADS {channel}")
+
     async def join_channel(self, channel: str) -> None:
         await self._send_raw(f"JOIN {channel}")
         if channel not in self.channels:

{agentirc_cli-0.18.0/agentirc/clients/claude → agentirc_cli-0.19.0/agentirc/clients/codex}/message_buffer.py

@@ -1,15 +1,19 @@
 from __future__ import annotations
 
+import re
 import time
 from collections import deque
 from dataclasses import dataclass, field
 
+_THREAD_PREFIX_RE = re.compile(r"^\[thread:([a-zA-Z0-9\-]+)\] ")
+
 
 @dataclass
 class BufferedMessage:
     nick: str
     text: str
     timestamp: float
+    thread: str | None = None
 
 
 class MessageBuffer:
@@ -24,8 +28,13 @@ class MessageBuffer:
             self._buffers[channel] = deque(maxlen=self.max_per_channel)
             self._totals[channel] = 0
             self._cursors[channel] = 0
+        thread = None
+        m = _THREAD_PREFIX_RE.match(text)
+        if m:
+            thread = m.group(1)
         self._buffers[channel].append(
-            BufferedMessage(nick=nick, text=text, timestamp=time.time())
+            BufferedMessage(nick=nick, text=text, timestamp=time.time(),
+                           thread=thread)
         )
         self._totals[channel] += 1
 
@@ -44,3 +53,13 @@ class MessageBuffer:
             new_messages = new_messages[-limit:]
         self._cursors[channel] = total
         return new_messages
+
+    def read_thread(self, channel: str, thread_name: str,
+                    limit: int = 50) -> list[BufferedMessage]:
+        buf = self._buffers.get(channel)
+        if not buf:
+            return []
+        matches = [m for m in buf if m.thread == thread_name]
+        if len(matches) > limit:
+            matches = matches[-limit:]
+        return matches