Significant-Gravitas · Bentlybro · Sep 7, 2026 · Sep 8, 2026 · Sep 8, 2026 · Sep 8, 2026
@@ -107,6 +107,22 @@ class ChannelInfo(BaseModel):
     server_name: Optional[str] = None
 
 
+class EditOutcome(Enum):
+    """Result of a proactive edit — see ``PlatformAdapter.edit_channel_message``.
+
+    Distinct from a bool so the caller can surface *why* an edit didn't land:
+    the platform never supports edits at all (``UNSUPPORTED``), the target
+    message is gone or too old to touch (``NOT_FOUND``), or the platform
+    rejected the call for another reason — wrong author, no permission, body
+    too long (``FAILED``).
+    """
+
+    OK = "ok"
+    UNSUPPORTED = "unsupported"
+    NOT_FOUND = "not_found"
+    FAILED = "failed"
+
+
 class PostedRef(BaseModel):
     """Pointer to something the bot just created on the platform.
 
@@ -399,6 +415,20 @@ async def create_channel_thread(
         """
         ...
 
+    async def edit_channel_message(
+        self, channel_id: str, ref_id: str, text: str
+    ) -> EditOutcome:
+        """Edit a message this bot previously posted via ``post_channel_message``.
+
+        ``channel_id``/``ref_id`` are exactly what that call (or
+        ``create_channel_thread``) returned — adapters that encode extra state
+        into those ids (Slack) must decode the same way as their send path.
+        Default: unsupported — platforms without a wired edit call (or not yet
+        implemented) simply inherit this rather than every caller special-casing
+        ``NotImplementedError``.
+        """
+        return EditOutcome.UNSUPPORTED
+
 
 class SocketAdapter(PlatformAdapter):
     """Adapter that owns a long-lived connection (Discord Gateway, Slack Socket

@@ -28,6 +28,7 @@
 from ..base import (
     ChannelInfo,
     ChannelType,
+    EditOutcome,
     FileAttachment,
     InboundAttachment,
     MessageCallback,
@@ -146,12 +147,22 @@ async def _resolve_channel(self, channel_id: str):
         ``Client.get_channel`` only reads the in-memory cache, so it misses
         threads the bot hasn't seen since its last restart. Fall back to
         ``fetch_channel`` (REST) so long-lived threads keep working.
+
+        ``channel_id`` reaches here as a caller-supplied string (a model-chosen
+        edit target, a raw proactive-post ID) that was never guaranteed to look
+        like a snowflake, so the ``int()`` conversion is inside the guarded
+        block rather than raising ``ValueError`` straight out to the RPC layer.
         """
-        channel = self._client.get_channel(int(channel_id))
+        try:
+            numeric_id = int(channel_id)
+        except ValueError:
+            logger.warning("Channel id %r is not a valid snowflake", channel_id)
+            return None
+        channel = self._client.get_channel(numeric_id)
         if channel is not None:
             return channel
         try:
-            return await self._client.fetch_channel(int(channel_id))
+            return await self._client.fetch_channel(numeric_id)
         except (discord.NotFound, discord.Forbidden, discord.HTTPException):
             logger.warning("Channel %s not found or inaccessible", channel_id)
             return None
@@ -355,6 +366,33 @@ async def create_channel_thread(
             )
         return PostedRef(id=str(thread.id), url=thread.jump_url)
 
+    async def edit_channel_message(
+        self, channel_id: str, ref_id: str, text: str
+    ) -> EditOutcome:
+        channel = await self._resolve_channel(channel_id)
+        if channel is None or not isinstance(channel, discord.abc.Messageable):
+            return EditOutcome.NOT_FOUND
+        try:
+            message = await channel.fetch_message(int(ref_id))
+        except ValueError:
+            return EditOutcome.NOT_FOUND
+        except discord.NotFound:
+            return EditOutcome.NOT_FOUND
+        except discord.HTTPException:
+            logger.exception("Failed to fetch message %s for edit", ref_id)
+            return EditOutcome.FAILED
+        rendered, allowed = _resolve_mentions(
+            text, await self._mentionables_for(channel, text, ())
+        )
+        try:
+            await message.edit(content=rendered, allowed_mentions=allowed)
+        except discord.HTTPException:
+            # Covers both a rejected edit (message too old/foreign author) and
+            # a body over Discord's cap — either way the edit did not land.
+            logger.exception("Failed to edit message %s", ref_id)
+            return EditOutcome.FAILED
+        return EditOutcome.OK
+
     async def _send_chunked(
         self, channel: discord.abc.Messageable, text: str
     ) -> Optional[discord.Message]:

@@ -6,7 +6,7 @@
 import discord
 import pytest
 
-from backend.copilot.bot.adapters.base import FileAttachment
+from backend.copilot.bot.adapters.base import EditOutcome, FileAttachment
 from backend.copilot.bot.adapters.discord.adapter import (
     MAX_INBOUND_ATTACHMENTS,
     THREAD_HISTORY_CHAR_BUDGET,
@@ -1260,6 +1260,16 @@ async def test_get_channel_server_id_none_when_missing(self):
         )
         assert await adapter.get_channel_server_id("10") is None
 
+    @pytest.mark.asyncio
+    async def test_get_channel_server_id_none_for_non_numeric_id(self):
+        # A non-snowflake channel_id (a caller-chosen edit target, not
+        # necessarily one that passed the numeric-ID grammar check first)
+        # must resolve to None rather than raise ValueError out of int().
+        adapter, client = _bare_adapter()
+
+        assert await adapter.get_channel_server_id("not-a-snowflake") is None
+        client.get_channel.assert_not_called()
+
     @pytest.mark.asyncio
     async def test_post_channel_message_returns_ref_with_url(self):
         adapter, client = _bare_adapter()
@@ -1366,6 +1376,80 @@ async def test_create_thread_returns_ref_when_content_post_fails(self):
         assert ref is not None
         assert ref.id == "777"
 
+    @pytest.mark.asyncio
+    async def test_edit_channel_message_edits_in_place(self):
+        adapter, client = _bare_adapter()
+        channel = MagicMock(spec=discord.TextChannel)
+        message = MagicMock()
+        message.edit = AsyncMock()
+        channel.fetch_message = AsyncMock(return_value=message)
+        client.get_channel.return_value = channel
+
+        outcome = await adapter.edit_channel_message("10", "999", "updated text")
+
+        assert outcome == EditOutcome.OK
+        message.edit.assert_awaited_once()
+        assert message.edit.call_args.kwargs["content"] == "updated text"
+
+    @pytest.mark.asyncio
+    async def test_edit_channel_message_not_found_when_message_missing(self):
+        adapter, client = _bare_adapter()
+        channel = MagicMock(spec=discord.TextChannel)
+        channel.fetch_message = AsyncMock(
+            side_effect=discord.NotFound(MagicMock(status=404), "gone")
+        )
+        client.get_channel.return_value = channel
+
+        outcome = await adapter.edit_channel_message("10", "999", "updated text")
+
+        assert outcome == EditOutcome.NOT_FOUND
+
+    @pytest.mark.asyncio
+    async def test_edit_channel_message_not_found_for_bad_ref_id(self):
+        adapter, client = _bare_adapter()
+        channel = MagicMock(spec=discord.TextChannel)
+        client.get_channel.return_value = channel
+
+        outcome = await adapter.edit_channel_message("10", "not-a-number", "x")
+
+        assert outcome == EditOutcome.NOT_FOUND
+
+    @pytest.mark.asyncio
+    async def test_edit_channel_message_not_found_for_non_numeric_channel_id(self):
+        adapter, client = _bare_adapter()
+
+        outcome = await adapter.edit_channel_message("not-a-snowflake", "999", "x")
+
+        assert outcome == EditOutcome.NOT_FOUND
+        client.get_channel.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_edit_channel_message_failed_when_platform_rejects(self):
+        adapter, client = _bare_adapter()
+        channel = MagicMock(spec=discord.TextChannel)
+        message = MagicMock()
+        message.edit = AsyncMock(
+            side_effect=discord.HTTPException(MagicMock(status=403), "forbidden")
+        )
+        channel.fetch_message = AsyncMock(return_value=message)
+        client.get_channel.return_value = channel
+
+        outcome = await adapter.edit_channel_message("10", "999", "updated text")
+
+        assert outcome == EditOutcome.FAILED
+
+    @pytest.mark.asyncio
+    async def test_edit_channel_message_not_found_for_non_messageable_channel(self):
+        adapter, client = _bare_adapter()
+        client.get_channel.return_value = None
+        client.fetch_channel = AsyncMock(
+            side_effect=discord.NotFound(MagicMock(status=404), "gone")
+        )
+
+        outcome = await adapter.edit_channel_message("10", "999", "x")
+
+        assert outcome == EditOutcome.NOT_FOUND
+
 
 # ── Referenced-conversation fetch ──────────────────────────────────────
 

@@ -24,12 +24,14 @@
 import httpx
 from fastapi import FastAPI, Request, Response
 from fastapi.responses import JSONResponse, PlainTextResponse
+from slack_sdk.errors import SlackApiError
 from slack_sdk.web.async_client import AsyncWebClient
 
 from backend.copilot.bot import threads
 from backend.copilot.bot.adapters.base import (
     ChannelInfo,
     ChannelType,
+    EditOutcome,
     FileAttachment,
     MessageCallback,
     MessageContext,
@@ -632,6 +634,29 @@ async def create_channel_thread(
             url=await self._permalink(team, channel, root_ts),
         )
 
+    async def edit_channel_message(
+        self, channel_id: str, ref_id: str, text: str
+    ) -> EditOutcome:
+        team, channel, _ = _decode_target(channel_id)
+        client = await self._client_for(team)
+        if client is None:
+            return EditOutcome.FAILED
+        try:
+            await client.chat_update(
+                channel=channel, ts=ref_id, text=self.localize_markup(text)
+            )
+        except SlackApiError as e:
+            if e.response.get("error") == "message_not_found":
+                return EditOutcome.NOT_FOUND
+            logger.warning(
+                "Slack chat.update rejected edit: %s", e.response.get("error")
+            )
+            return EditOutcome.FAILED
+        except Exception:
+            logger.exception("Failed to edit Slack message %s", ref_id)
+            return EditOutcome.FAILED
+        return EditOutcome.OK
+
     async def _post_chunked(
         self, team_id: str, channel: str, text: str, thread_ts: Optional[str] = None
     ) -> Optional[str]:

@@ -7,7 +7,7 @@
 import pytest
 from slack_sdk.errors import SlackApiError
 
-from backend.copilot.bot.adapters.base import FileAttachment
+from backend.copilot.bot.adapters.base import EditOutcome, FileAttachment
 from backend.data.bot_installs import BotInstallCredentials
 
 from . import config
@@ -33,6 +33,7 @@ def _mock_client() -> MagicMock:
     client = MagicMock()
     client.token = "xoxb-test"
     client.chat_postMessage = AsyncMock(return_value={"ts": "111.222"})
+    client.chat_update = AsyncMock(return_value={"ok": True})
     client.chat_postEphemeral = AsyncMock()
     client.chat_getPermalink = AsyncMock(return_value={"permalink": "https://x/p"})
     client.files_upload_v2 = AsyncMock()
@@ -617,6 +618,38 @@ async def test_create_thread_encodes_target(self, adapter):
     async def test_rename_thread_is_noop(self, adapter):
         assert await adapter.rename_thread("T1|C1|9.9", "x") is False
 
+    @pytest.mark.asyncio
+    async def test_edit_channel_message_calls_chat_update(self, adapter):
+        outcome = await adapter.edit_channel_message("T1|C1|", "111.222", "updated")
+
+        assert outcome == EditOutcome.OK
+        call = adapter._clients["T1"].chat_update.await_args.kwargs
+        assert call["channel"] == "C1"
+        assert call["ts"] == "111.222"
+        assert call["text"] == "updated"
+
+    @pytest.mark.asyncio
+    async def test_edit_channel_message_not_found(self, adapter):
+        adapter._clients["T1"].chat_update = AsyncMock(
+            side_effect=SlackApiError("not found", {"error": "message_not_found"})
+        )
+
+        outcome = await adapter.edit_channel_message("T1|C1|", "111.222", "updated")
+
+        assert outcome == EditOutcome.NOT_FOUND
+
+    @pytest.mark.asyncio
+    async def test_edit_channel_message_failed_on_other_slack_error(self, adapter):
+        adapter._clients["T1"].chat_update = AsyncMock(
+            side_effect=SlackApiError(
+                "edit forbidden", {"error": "cant_update_message"}
+            )
+        )
+
+        outcome = await adapter.edit_channel_message("T1|C1|", "111.222", "updated")
+
+        assert outcome == EditOutcome.FAILED
+
 
 class TestChannelIdGrammar:
     def test_slack_ids_match(self, adapter):

@@ -31,6 +31,7 @@
 from backend.copilot.bot.adapters.base import (
     ChannelInfo,
     ChannelType,
+    EditOutcome,
     FileAttachment,
     MessageCallback,
     MessageContext,
@@ -428,6 +429,25 @@ async def create_channel_thread(
         body = f"**{name}**\n\n{text}" if name else text
         return await self.post_channel_message(channel_id, body)
 
+    async def edit_channel_message(
+        self, channel_id: str, ref_id: str, text: str
+    ) -> EditOutcome:
+        activity = {
+            "type": "message",
+            "text": self.localize_markup(text),
+            "textFormat": "markdown",
+        }
+        try:
+            await self._client.update_activity(
+                self._service_url_for(channel_id), channel_id, ref_id, activity
+            )
+        except TeamsApiError as e:
+            logger.exception("Failed to edit Teams activity %s", ref_id)
+            if e.status_code == 404:
+                return EditOutcome.NOT_FOUND
+            return EditOutcome.FAILED
+        return EditOutcome.OK
+
     async def open_dm_channel(self, platform_user_id: str) -> Optional[str]:
         """Create (or fetch) the bot's 1:1 conversation with a user.