Replace prefix-based feature request detection with Claude-driven intent detection

Chat system prompt now instructs Claude to append [FEATURE] or [IMPROVEMENT]
markers when it detects a feature request intent. The marker is stripped before
display/history and routes to the cog's new start_from_intent() method. No
extra API call — piggybacks on the existing chat call. Explicit prefixes
("feature request:", "bot improvement:") still work as before.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: adam

CLAUDE.md

@@ -48,8 +48,9 @@ data/               — Plugin storage (created automatically, per-plugin isolat
 ## Key Behaviors
 
 - **Chat**: @mention the bot → Claude responds with per-channel conversation memory (last 20 messages)
-- **Feature requests**: @mention with "feature request: <description>" → role check → creates Discord thread → multi-turn planning conversation with Claude → user confirms → code gen → AST scan → opens PR
-- **Bot improvements**: @mention with "bot improvement: <description>" → role check → creates Discord thread → planning conversation → user confirms → code gen → PR flagged as CORE CHANGE
+- **Intent detection**: During chat, the system prompt instructs Claude to append `[FEATURE]` or `[IMPROVEMENT]` markers when it detects the user wants a feature. The marker is stripped before display/history and routes to the feature request flow. No extra API call — piggybacks on the existing chat call.
+- **Feature requests**: Detected naturally via chat intent, or explicitly with "feature request: <description>" → role check → creates Discord thread → multi-turn planning conversation with Claude → user confirms → code gen → AST scan → opens PR
+- **Bot improvements**: Detected naturally via chat intent, or explicitly with "bot improvement: <description>" → role check → creates Discord thread → planning conversation → user confirms → code gen → PR flagged as CORE CHANGE
 - **Deploy**: GitHub webhook on PR merge → bot writes `.deploy` + exits → supervisor pulls + restarts
 - **Rollback**: If bot crashes within 30s of deploy, supervisor reverts to last known good commit
 - **Admin channel**: `LOG_CHANNEL_ID` — bot posts deploy status, errors, feature request activity, rollback alerts
@@ -58,8 +59,8 @@ data/               — Plugin storage (created automatically, per-plugin isolat
 
 Feature requests use a multi-turn thread conversation instead of one-shot code generation:
 
-1. User @mentions the bot with a feature request in a regular channel
-2. Bot creates a Discord thread from the message
+1. User @mentions the bot with a feature request (natural language or explicit prefix) in a regular channel
+2. Bot detects intent (via chat marker or prefix) and creates a Discord thread from the message
 3. Bot calls Claude (using `PLANNING_SYSTEM_PROMPT`) to evaluate the request and ask clarifying questions
 4. User and Claude go back and forth in the thread until the plan is clear
 5. When Claude is satisfied, it includes a `---PLAN_READY---` marker in its response

PRIVACY_POLICY.md

@@ -17,7 +17,7 @@ When you @mention the Bot, the text of your message (with the mention stripped)
 
 ### 1.2 Feature Request Content
 
-When you submit a feature request or bot improvement, the Bot creates a **Discord thread** for a collaborative planning conversation. During this process:
+The Bot detects feature request intent during normal chat — no additional API call is made for intent detection. When a feature request is identified (either through natural language detection or an explicit prefix), the Bot creates a **Discord thread** for a collaborative planning conversation. During this process:
 
 - Your request description and all follow-up messages in the thread are sent to the Anthropic Claude API for planning and code generation
 - The conversation history for the thread is stored in application memory (RAM) for the duration of the session (up to 30 minutes of inactivity) and is lost on Bot restart

README.md

@@ -67,24 +67,38 @@ The supervisor manages the bot lifecycle, handles deploys on PR merge, and rolls
 
 ### Feature Requests (Plugin)
 
+Just describe what you want in natural language:
+
 ```
-@Turbot feature request: add a command that tells jokes
+@Turbot can you add a command that tells jokes?
 ```
 
-The bot creates a **Discord thread** and starts a collaborative planning conversation. It will ask clarifying questions, propose an implementation plan, and wait for your confirmation before generating code. Once you reply **go**, it generates a sandboxed plugin in `plugins/`, scans it for security policy violations, and opens a PR. Reply **cancel** to abort at any time. Requires the `BotAdmin` role (configurable).
+Turbot detects the intent automatically during normal chat. When it recognizes a feature request, it creates a **Discord thread** and starts a collaborative planning conversation. It will ask clarifying questions, propose an implementation plan, and wait for your confirmation before generating code. Once you reply **go**, it generates a sandboxed plugin in `plugins/`, scans it for security policy violations, and opens a PR. Reply **cancel** to abort at any time. Requires the `BotAdmin` role (configurable).
+
+You can also use the explicit prefix if you prefer:
+```
+@Turbot feature request: add a command that tells jokes
+```
 
 ### Bot Improvements (Core)
 
+If Turbot detects you want to change its core behavior, it routes through the improvement flow:
+
 ```
-@Turbot bot improvement: add rate limiting to chat responses
+@Turbot can you make the error messages friendlier?
 ```
 
 Same conversational flow as feature requests, but this can modify any file in the project. The PR is flagged with "CORE CHANGE" and triggers an admin channel warning.
 
+Explicit prefix also works:
+```
+@Turbot bot improvement: add rate limiting to chat responses
+```
+
 ### Feature Request Flow
 
-1. User submits a request in any channel
-2. Bot creates a thread and evaluates the request
+1. User @mentions the bot with a request (natural language or explicit prefix)
+2. Bot detects the intent and creates a thread
 3. Bot asks clarifying questions (1-3 at a time)
 4. User and bot refine the plan collaboratively
 5. Bot proposes a plan and waits for confirmation

TERMS_OF_SERVICE.md

@@ -24,7 +24,7 @@ You agree not to:
 
 ## 4. Feature Requests and Generated Code
 
-- Feature requests and bot improvements are handled through a **conversational planning process** in Discord threads. The Bot will ask clarifying questions and propose a plan before generating code
+- Feature requests and bot improvements can be triggered through natural language or explicit prefixes, and are handled through a **conversational planning process** in Discord threads. The Bot will ask clarifying questions and propose a plan before generating code
 - You may confirm the plan to proceed with code generation, or cancel the request at any time
 - Feature request sessions time out after 30 minutes of inactivity
 - All generated code is subject to review before merge; the Bot does not auto-apply changes

bot.py

@@ -66,6 +66,26 @@ def _split_reply(text: str, limit: int = DISCORD_MSG_LIMIT) -> list[str]:
     return chunks
 
 
+def _extract_intent(text: str) -> tuple[str, str | None]:
+    """Strip intent marker from response, return (clean_text, request_type)."""
+    stripped = text.rstrip()
+    if stripped.endswith("[FEATURE]"):
+        return stripped[: -len("[FEATURE]")].rstrip(), "plugin"
+    if stripped.endswith("[IMPROVEMENT]"):
+        return stripped[: -len("[IMPROVEMENT]")].rstrip(), "core"
+    return text, None
+
+
+async def _start_feature_request(
+    message: discord.Message, description: str, request_type: str,
+) -> None:
+    """Bridge: hand off detected intent to the FeatureRequestCog."""
+    cog = bot.get_cog("FeatureRequestCog")
+    if cog is None:
+        return
+    await cog.start_from_intent(message, description, request_type)
+
+
 @bot.event
 async def on_ready() -> None:
     print(f"Turbot is online as {bot.user} — feeling Turbotastic!")
@@ -123,8 +143,9 @@ async def on_message(message: discord.Message) -> None:
     if not bot.user or bot.user not in message.mentions:
         return
 
-    # Skip feature requests — handled by the cog
     text = re.sub(r"<@!?\d+>", "", message.content).strip()
+
+    # Skip explicit feature request prefixes — handled directly by the cog
     if text.lower().startswith(("feature request:", "bot improvement:")):
         return
 
@@ -150,29 +171,40 @@ async def on_message(message: discord.Message) -> None:
     was_recovering = claude_health.state == "half_open"
 
     try:
-        response = await claude.messages.create(
-            model=config.CLAUDE_MODEL,
-            max_tokens=1024,
-            system=(
-                "You are Turbot, a friendly and helpful Discord bot. "
-                "You are Turbotastic — cheerful, concise, and occasionally "
-                "make fish puns. Keep replies under a few paragraphs."
-            ),
-            messages=list(history),
-        )
-        reply = response.content[0].text
+        async with message.channel.typing():
+            response = await claude.messages.create(
+                model=config.CLAUDE_MODEL,
+                max_tokens=1024,
+                system=(
+                    "You are Turbot, a friendly and helpful Discord bot. "
+                    "You are Turbotastic — cheerful, concise, and occasionally "
+                    "make fish puns. Keep replies under a few paragraphs.\n"
+                    "If the user is asking you to add a new feature or command, "
+                    "end your reply with [FEATURE].\n"
+                    "If they want a change to your core behavior, "
+                    "end with [IMPROVEMENT].\n"
+                    "Only add a marker when the intent is clear."
+                ),
+                messages=list(history),
+            )
+            raw_reply = response.content[0].text
+
+            claude_health.record_success()
+            if was_recovering:
+                await log_to_admin("**Claude API recovered** — circuit breaker reset.")
+
+            reply, intent = _extract_intent(raw_reply)
 
-        claude_health.record_success()
-        if was_recovering:
-            await log_to_admin("**Claude API recovered** — circuit breaker reset.")
+            history.append({"role": "assistant", "content": reply})
+            if len(history) > MAX_HISTORY:
+                history[:] = history[-MAX_HISTORY:]
 
-        history.append({"role": "assistant", "content": reply})
-        if len(history) > MAX_HISTORY:
-            history[:] = history[-MAX_HISTORY:]
+            # Split long replies to respect Discord's 2000-char limit
+            for chunk in _split_reply(reply):
+                await message.reply(chunk)
 
-        # Split long replies to respect Discord's 2000-char limit
-        for chunk in _split_reply(reply):
-            await message.reply(chunk)
+            if intent is not None:
+                await _start_feature_request(message, text, intent)
 
     except Exception as e:
         if is_transient(e):

cog_feature.py

@@ -270,9 +270,10 @@ async def _handle_thread_message(
                     "Generating code changes... this may take a moment."
                 )
                 try:
-                    pr_url = await self._handle_request(
-                        description, session.request_type,
-                    )
+                    async with message.channel.typing():
+                        pr_url = await self._handle_request(
+                            description, session.request_type,
+                        )
                     session.state = "done"
                     await message.channel.send(
                         f"Turbotastic! PR created: {pr_url}"
@@ -324,7 +325,8 @@ async def _handle_thread_message(
         session.messages.append({"role": "user", "content": user_text})
 
         try:
-            reply_text = await self._call_planning_claude(session)
+            async with message.channel.typing():
+                reply_text = await self._call_planning_claude(session)
         except Exception as e:
             if is_transient(e):
                 claude_health.record_failure()
@@ -358,31 +360,21 @@ async def _handle_thread_message(
         session.messages.append({"role": "assistant", "content": reply_text})
         await message.channel.send(display_text)
 
-    @commands.Cog.listener()
-    async def on_message(self, message: discord.Message) -> None:
-        if message.author.bot:
-            return
-
-        # Check if this is a message in a tracked thread
-        session = _sessions.get(message.channel.id)
-        if session is not None:
-            await self._handle_thread_message(message, session)
-            return
-
-        if not self.bot.user or self.bot.user not in message.mentions:
-            return
-
-        text = message.content
-        # Strip the mention itself
-        text = re.sub(r"<@!?\d+>", "", text).strip()
-
-        request_type = _detect_request_type(text)
-        if request_type is None:
-            return  # Not a feature request — let the chat handler deal with it
+    async def start_from_intent(
+        self,
+        message: discord.Message,
+        description: str,
+        request_type: str,
+    ) -> None:
+        """Start a feature request flow from an intent detected during chat.
 
+        Also used internally by the prefix-based on_message path. Performs role
+        check, cooldown, circuit breaker check, thread creation, and first
+        planning call.
+        """
         # Role check
         required_role = config.FEATURE_REQUEST_ROLE
-        roles = getattr(message.author, 'roles', ())
+        roles = getattr(message.author, "roles", ())
         has_role = any(r.name == required_role for r in roles)
 
         if not has_role:
@@ -391,9 +383,8 @@ async def on_message(self, message: discord.Message) -> None:
             )
             return
 
-        feature_desc = _extract_description(text, request_type)
-        if not feature_desc:
-            await message.reply("Please describe the feature after the request prefix.")
+        if not description:
+            await message.reply("Please describe the feature you'd like.")
             return
 
         # Per-user cooldown
@@ -420,30 +411,31 @@ async def on_message(self, message: discord.Message) -> None:
 
         await _log(
             f"**{label}** from {message.author} "
-            f"in <#{message.channel.id}>: {feature_desc}"
+            f"in <#{message.channel.id}>: {description}"
         )
 
         # Create a thread for the conversation
         thread = await message.create_thread(
-            name=f"Feature: {feature_desc[:80]}",
+            name=f"Feature: {description[:80]}",
         )
 
         session = ThreadSession(
             thread_id=thread.id,
             user_id=message.author.id,
             request_type=request_type,
-            original_description=feature_desc,
+            original_description=description,
         )
         _sessions[thread.id] = session
 
         # First planning call
         session.messages.append({
             "role": "user",
-            "content": f"{label}: {feature_desc}",
+            "content": f"{label}: {description}",
         })
 
         try:
-            reply_text = await self._call_planning_claude(session)
+            async with thread.typing():
+                reply_text = await self._call_planning_claude(session)
         except Exception as e:
             if is_transient(e):
                 tripped = claude_health.record_failure()
@@ -480,6 +472,31 @@ async def on_message(self, message: discord.Message) -> None:
         session.messages.append({"role": "assistant", "content": reply_text})
         await thread.send(display_text)
 
+    @commands.Cog.listener()
+    async def on_message(self, message: discord.Message) -> None:
+        if message.author.bot:
+            return
+
+        # Check if this is a message in a tracked thread
+        session = _sessions.get(message.channel.id)
+        if session is not None:
+            await self._handle_thread_message(message, session)
+            return
+
+        if not self.bot.user or self.bot.user not in message.mentions:
+            return
+
+        text = message.content
+        # Strip the mention itself
+        text = re.sub(r"<@!?\d+>", "", text).strip()
+
+        request_type = _detect_request_type(text)
+        if request_type is None:
+            return  # Not a feature request — let the chat handler deal with it
+
+        feature_desc = _extract_description(text, request_type)
+        await self.start_from_intent(message, feature_desc, request_type)
+
     async def _handle_request(self, description: str, request_type: str) -> str:
         """Generate code changes and create a PR."""
         security_policy = _load_security_policy()