linkgravity 1.4.0 → 1.5.0

package/README.md

@@ -1,33 +1,66 @@
 # LinkGravity
 
-A Discord bot interface for the Antigravity agentic AI system. It translates Antigravity CLI prompts into Discord UI components and provides voice interaction capabilities.
+A Discord, Telegram, and Slack bot interface for the Antigravity agentic AI system. It translates Antigravity CLI prompts into chat UI components and provides voice interaction capabilities.
 
 ## Features
 
 - **Environment Sync:** Automatically syncs with the host's `~/.gemini` configuration.
 - **Voice Interaction:** Supports voice channels with adaptive voice activity detection to segment speech and filter environmental noise, plus live "listening..." feedback while you're still talking.
-- **Wake Word Recognition:** Uses phoneme-level similarity to detect wake words and activate voice commands.
-- **Approval Flow:** Command and tool-call approvals become interactive Discord buttons. Chained shell commands are approved individually, and any approval can be scoped to auto-allow that command or tool going forward - something plain `agy` doesn't do.
+  - **Wake Word Recognition:** Uses phoneme-level similarity to detect wake words and activate voice commands.
+- **Approval Flow:** Command and tool-call approvals become interactive chat buttons. Chained shell commands are approved individually, and any approval can be scoped to auto-allow that command or tool going forward - something plain `agy` doesn't do.
 - **Multi-Modal Input:** Attach files for the AI to read, including audio, which gets transcribed to text automatically.
 
+## Supported Platforms
+
+|                           | Discord | Telegram | Slack   |
+| ------------------------- | ------- | -------- | ------- |
+| Sessions                  | Threads | Flat     | Threads |
+| Voice                     | ✓       | ✗        | ✗       |
+| Approval buttons          | ✓       | ✓        | ✓       |
+| File attachments          | ✓       | ✓        | ✓       |
+| Session title auto-rename | ✓       | ✗        | ✓       |
+| DMs                       | ✓       | ✓        | ✓       |
+| Group                     | ✓       | ✗        | ✓       |
+
 ## Requirements
 
 - Node.js >= 18
 - Python >= 3.10
 - Antigravity CLI installed on this machine
-- A messenger bot token, and at least one server/channel to allow it in
-  - **Discord** - currently the only one supported
+- A messenger bot token, and at least one server/channel to allow it in - Discord, Telegram, and Slack are all supported, and you can enable more than one at once
 
 ### Creating the Discord bot
 
-In the [Discord Developer Portal](https://discord.com/developers/applications), create an application and bot, then:
+In the [Discord Developer Portal](https://discord.com/developers/applications):
+
+1. **New Application**, name it, then go to **Bot** in the left sidebar.
+2. Under **Privileged Gateway Intents**, enable **Message Content Intent** - required, since the bot reads message text/attachments.
+3. Click **Reset Token** to reveal the bot token, and copy it - this is what goes into `lgy setup`'s `discord_token`.
+4. Go to **OAuth2 > URL Generator** in the sidebar. Under **Scopes**, check **bot** and **applications.commands**. Under the **Bot Permissions** box that appears below, check:
+    - Send Messages, Send Messages in Threads, Create Public Threads
+    - Read Message History, Attach Files, Embed Links, Add Reactions
+    - Connect, Speak (for voice channel support)
+5. Copy the **Generated URL** at the bottom of that page, open it in a browser, and invite the bot to your server.
+
+### Creating the Telegram bot
 
-- Under **Bot**, enable the **Message Content** privileged intent - required, since the bot reads message text/attachments.
-- Under **OAuth2 → URL Generator**, select the **bot** and **applications.commands** scopes, then these bot permissions:
-  - Send Messages, Send Messages in Threads, Create Public Threads
-  - Read Message History, Attach Files, Embed Links, Add Reactions
-  - Connect, Speak - for voice channel support
-- Use the generated URL to invite the bot to your server.
+Message [@BotFather](https://t.me/BotFather) on Telegram, send `/newbot`, and follow the prompts to get a bot token. No further permission setup is needed - Telegram sessions are 1 chat = 1 session, so just message your bot directly (or add it to a group) and run `/new`.
+
+### Creating the Slack app
+
+Slack has more moving parts than the others - two separate tokens, and a few settings pages that gate each other. Going in this order avoids re-doing steps:
+
+1. Go to [api.slack.com/apps](https://api.slack.com/apps) > **Create New App** > **From scratch**, name it, and pick your workspace.
+2. **Socket Mode** (left sidebar) > toggle it on. This avoids needing a public HTTP endpoint. Slack will prompt you to generate an app-level token here - name it anything, add the `connections:write` scope, and **Generate**. Copy this token (starts with `xapp-`) - this is `slack_app_token`.
+    - If it doesn't prompt you, go to **Basic Information > App-Level Tokens > Generate Token and Scopes** instead.
+3. **OAuth & Permissions** (left sidebar) > scroll to **Scopes > Bot Token Scopes** (not **User Token Scopes** - that's a different section further up the page, for a different token, and is not used here). **Add an OAuth Scope** for each of: `chat:write`, `channels:history`, `groups:history`, `im:history`, `mpim:history`, `reactions:write`, `files:read`, `files:write`.
+4. Scroll to the top of that same page > **Install to Workspace** > **Allow**. This generates the token under **OAuth Tokens > Bot User OAuth Token**, starting with `xoxb-`. Copy that one - this is `slack_bot_token`.
+    - It's easy to grab the wrong token here - the page also shows a **User OAuth Token** (`xoxp-...`) further down, which is a different thing and won't work for this bot.
+5. **App Home** (left sidebar) > under **Show Tabs**, turn on **Messages Tab**, then check **Allow users to send Slash commands and messages from the messages tab** - this is what lets you DM the bot at all. (If this section looks greyed out, it's because step 3 hasn't been saved/installed yet - go back and do that first.)
+6. **Event Subscriptions** (left sidebar) > toggle **Enable Events** on > under **Subscribe to bot events**, add `message.channels`, `message.groups`, `message.im`, and `message.mpim` > **Save Changes**.
+7. **Slash Commands** (left sidebar) > **Create New Command**, three times, for `/new`, `/model`, and `/credit` (any description/hint text is fine - only the command name matters).
+8. Back on **OAuth & Permissions**, since scopes/events changed after the initial install, click **Reinstall to Workspace** to push those changes live. Any time you change scopes or events later, you'll need to repeat this step.
+9. In Slack itself, for any **channel** (not DM) you want the bot usable in, run `/invite @<your bot's name>` there first - the bot can't post in a channel it hasn't been added to.
 
 ## Installation
 
@@ -39,20 +72,22 @@ Sets up its own Python environment automatically - no manual `pip install` neede
 
 ## Setup
 
-Run the configuration wizard once to set your bot token, allowed servers/channels, and other settings:
+Run the configuration wizard once to pick which platform(s) to enable and set their tokens, allowed users, and other settings:
 
 ```bash
 lgy setup
 ```
 
-This writes to `~/.gemini/linkgravity/lgy.json`, outside the package directory, so `npm update`/reinstall never touches it. You can re-run `lgy setup` any time to change settings later - each field keeps its current value if you leave it empty.
+This writes to `~/.gemini/linkgravity/lgy.json`, outside the package directory, so `npm update`/reinstall never touches it. You can re-run `lgy setup` any time to change settings later - each field keeps its current value if you leave it empty. Discord, Telegram, and Slack can all be turned on independently; the bot runs whichever ones are enabled in a single shared process.
 
-During setup you'll be asked for one or more Discord servers to allow, and optionally specific channels within each:
+For Discord, during setup you'll be asked for one or more servers to allow, and optionally specific channels within each:
 
 - Leave the channel list empty for a server → **the whole server** is allowed - any channel can start a session.
 - List specific channel IDs for a server → **only those channels** in that server are allowed.
 
-A new session is only ever started with the **`/new`** slash command in Discord - never just by typing a message. `/new` works both in a regular channel and from inside an existing thread.
+Telegram and Slack have no server/channel gating yet - every chat/channel you message the bot from can start a session, subject to the allowed-users list you set during setup.
+
+A new session is started with the **`/new`** slash command - never just by typing a message. On Discord and Slack, `/new` works both in a regular channel and from inside an existing thread; on Telegram, it applies to whichever chat you send it in.
 
 ## Usage
 
@@ -86,6 +121,6 @@ Use `lgy logs -t` to include timestamps.
 
 This bot gives an AI agent broad access to the machine it runs on - **that's inherent to what it does, so don't expose it publicly or run it somewhere you don't fully trust its users.**
 
-- `allowed_user_ids`, set via `lgy setup`, is your primary access control - always set it.
-- Tool calls, including shell commands, go through an approval flow in Discord by default; treat anyone in `allowed_user_ids` as having effectively full control of this machine.
-- Your Discord token and other settings live in `~/.gemini/linkgravity/lgy.json`, outside this repo/package directory - never commit or share that file.
+- The allowed-users list for each platform, set via `lgy setup`, is your primary access control - always set it.
+- Tool calls, including shell commands, go through an approval flow by default; treat anyone on an allowed-users list as having effectively full control of this machine.
+- Your bot tokens and other settings live in `~/.gemini/linkgravity/lgy.json`, outside this repo/package directory - never commit or share that file.

package/bin/cli.js

@@ -8,6 +8,7 @@ const {
     getSettings,
     platformState,
     getSessions,
+    getPlatformHealth,
     LGY_PM2_NAME,
     LGY_SCRIPT_PATH,
 } = require('./platforms');
@@ -289,6 +290,7 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
 } else if (cmd === 'status') {
     const settings = getSettings();
     const sessions = getSessions();
+    const health = getPlatformHealth();
 
     let pm2Procs = [];
     const jlist = spawnSync('npx', ['-y', 'pm2', 'jlist'], { stdio: 'pipe' });
@@ -304,19 +306,41 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     } else {
         const mem = proc.monit ? `${Math.round(proc.monit.memory / 1024 / 1024)}mb` : '?';
         const cpu = proc.monit ? `${proc.monit.cpu}%` : '?';
+        const uptimeMs = proc.pm2_env.status === 'online' ? Date.now() - proc.pm2_env.pm_uptime : 0;
         const uptime =
             proc.pm2_env.status === 'online' ? formatUptime(proc.pm2_env.pm_uptime) : '-';
+        const restarts = proc.pm2_env.restart_time;
         console.log(
-            `\n${color.cyan}▶${color.reset} daemon: ${proc.pm2_env.status} (uptime: ${uptime}, restarts: ${proc.pm2_env.restart_time}, cpu: ${cpu}, mem: ${mem})\n`,
+            `\n${color.cyan}▶${color.reset} daemon: ${proc.pm2_env.status} (uptime: ${uptime}, restarts: ${restarts}, cpu: ${cpu}, mem: ${mem})\n`,
         );
+        // Flag "many restarts" only alongside a short current uptime - restart_time alone is cumulative, not live.
+        if (
+            proc.pm2_env.status === 'online' &&
+            restarts > 5 &&
+            uptimeMs > 0 &&
+            uptimeMs < 5 * 60 * 1000
+        ) {
+            console.log(
+                `${color.yellow}⚠${color.reset}  ${restarts} restarts and only ${uptime} of uptime - looks like it's crash-looping. Run ${color.cyan}lgy logs${color.reset} to see why.\n`,
+            );
+        }
     }
 
     const rows = Object.entries(PLATFORMS).map(([key, def]) => {
         const { enabled } = platformState(key, settings);
         const sessionCount = Object.values(sessions).filter((s) => s.platform === key).length;
-        return [def.label, enabled ? 'yes' : 'no', String(sessionCount)];
+        const h = health[key];
+        let connection = '-';
+        if (enabled) {
+            if (!h) connection = 'unknown';
+            else if (h.status === 'running') connection = 'connected';
+            else if (h.status === 'connecting') connection = 'connecting...';
+            else if (h.status === 'error') connection = `error: ${h.detail || '?'}`;
+            else if (h.status === 'stopped') connection = 'stopped';
+        }
+        return [def.label, enabled ? 'yes' : 'no', connection, String(sessionCount)];
     });
-    console.log(renderTable(['platform', 'enabled', 'sessions'], rows));
+    console.log(renderTable(['platform', 'enabled', 'connection', 'sessions'], rows));
     console.log();
 } else if (cmd === 'enable') {
     if (isWin) {

package/bin/platforms.js

@@ -5,6 +5,7 @@ const os = require('os');
 const workspaceDir = path.join(os.homedir(), '.gemini', 'linkgravity');
 const settingsPath = path.join(workspaceDir, 'lgy.json');
 const sessionsPath = path.join(workspaceDir, 'data', 'sessions.json');
+const healthPath = path.join(workspaceDir, 'data', 'platform_health.json');
 
 if (!fs.existsSync(workspaceDir)) fs.mkdirSync(workspaceDir, { recursive: true });
 
@@ -34,6 +35,16 @@ function getSessions() {
     return {};
 }
 
+// Written live by main.py - distinct from `enabled`, which is just the static config flag.
+function getPlatformHealth() {
+    if (fs.existsSync(healthPath)) {
+        try {
+            return JSON.parse(fs.readFileSync(healthPath, 'utf8'));
+        } catch (e) {}
+    }
+    return {};
+}
+
 // Both platforms now run in one shared pm2 process - main.py checks discord_enabled/telegram_enabled at startup.
 const LGY_PM2_NAME = 'lgy';
 const LGY_SCRIPT_PATH = path.join(__dirname, '..', 'src', 'main.py');
@@ -41,10 +52,15 @@ const LGY_SCRIPT_PATH = path.join(__dirname, '..', 'src', 'main.py');
 const PLATFORMS = {
     discord: { label: 'Discord' },
     telegram: { label: 'Telegram' },
+    slack: { label: 'Slack' },
 };
 
 function platformState(key, settings) {
-    const configured = !!settings[`${key}_token`];
+    // Slack needs two tokens (bot + app-level, for Socket Mode) instead of the single `${key}_token` the others use.
+    const configured =
+        key === 'slack'
+            ? !!(settings.slack_bot_token && settings.slack_app_token)
+            : !!settings[`${key}_token`];
     const enabled = settings[`${key}_enabled`] ?? (key === 'discord' && configured);
     return { configured, enabled };
 }
@@ -56,6 +72,7 @@ module.exports = {
     getSettings,
     updateSettings,
     getSessions,
+    getPlatformHealth,
     LGY_PM2_NAME,
     LGY_SCRIPT_PATH,
     PLATFORMS,

package/bin/setup.js

@@ -317,9 +317,52 @@ async function configureTelegram(existingSettings) {
     return updates;
 }
 
+async function configureSlack(existingSettings) {
+    p.note(
+        'Create a Slack app at api.slack.com/apps, enable Socket Mode, and add an app-level token with the ' +
+            '`connections:write` scope (Basic Information → App-Level Tokens). The bot token (starts with xoxb-) ' +
+            'is under OAuth & Permissions.',
+        'Slack App Setup',
+    );
+
+    const slackBotToken = await p.password({
+        message: 'Slack Bot Token (xoxb-..., leave empty to keep current):',
+    });
+    if (p.isCancel(slackBotToken)) {
+        p.cancel('Setup cancelled.');
+        process.exit(0);
+    }
+
+    const slackAppToken = await p.password({
+        message: 'Slack App-Level Token (xapp-..., leave empty to keep current):',
+    });
+    if (p.isCancel(slackAppToken)) {
+        p.cancel('Setup cancelled.');
+        process.exit(0);
+    }
+
+    p.note(
+        'Slack has no channel/server gating yet, and threads have no title surface (same as Telegram) - ' +
+            'there is no voice support yet either.',
+        'Slack Access',
+    );
+
+    const existingSlackUserIds = existingSettings.slack_allowed_user_ids
+        ? splitIds(existingSettings.slack_allowed_user_ids)
+        : [];
+    const slackUserIds = await collectUserIds(existingSlackUserIds, 'Slack');
+
+    const updates = {};
+    if (slackBotToken) updates.slack_bot_token = slackBotToken;
+    if (slackAppToken) updates.slack_app_token = slackAppToken;
+    if (slackUserIds !== null) updates.slack_allowed_user_ids = slackUserIds.join(',');
+    return updates;
+}
+
 const CONFIGURERS = {
     discord: configureDiscord,
     telegram: configureTelegram,
+    slack: configureSlack,
 };
 
 function applyDaemonState() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "linkgravity",
-  "version": "1.4.0",
-  "description": "Discord bot bridge for the Antigravity (agy) CLI, with voice interaction support",
+  "version": "1.5.0",
+  "description": "Discord/Telegram bot bridge for the Antigravity (agy) CLI, with voice interaction support",
   "scripts": {
     "postinstall": "node npm-scripts/postinstall.js",
     "start": "node npm-scripts/run-dev.js",
@@ -23,6 +23,8 @@
   "keywords": [
     "discord",
     "discord-bot",
+    "telegram",
+    "telegram-bot",
     "antigravity",
     "agy",
     "cli",

package/requirements.txt

@@ -1,5 +1,6 @@
 discord.py[voice]>=2.4.0
 python-telegram-bot>=21.0
+slack-bolt>=1.20.0
 PyNaCl>=1.5.0
 numpy>=1.24.0
 edge-tts

package/src/cogs/general_cog.py

@@ -11,7 +11,6 @@ from discord.ext import commands
 from config import (
     DATA_DIR,
     EMBED_COLOR,
-    MODEL_CHOICES,
     allowed,
     bot_settings,
     is_allowed_session_channel,
@@ -285,23 +284,3 @@ class GeneralCog(commands.Cog):
             await interaction.response.send_message("🛑 Process stopped natively.", ephemeral=True)
         else:
             await interaction.response.send_message("🛑 Process stopped.", ephemeral=True)
-
-    @app_commands.command(name="list", description="Active session list")
-    async def cmd_sessions(self, interaction: discord.Interaction):
-        if not allowed(interaction.user.id):
-            return await interaction.response.send_message("❌ Denied", ephemeral=True)
-        all_sessions = session_manager.get_all_sessions()
-        if not all_sessions:
-            return await interaction.response.send_message("No active sessions.", ephemeral=True)
-
-        embed = discord.Embed(title="📋 Session List", color=EMBED_COLOR)
-        from utils.utils import get_current_model
-
-        for thread_id, sess in list(all_sessions.items())[-10:]:
-            ch = self.bot.get_channel(int(thread_id))
-            embed.add_field(
-                name=f"#{getattr(ch, 'name', f'ID:{thread_id}')}",
-                value=f"🤖 {MODEL_CHOICES.get(sess.get('model'), sess.get('model')) or get_current_model()}",
-                inline=False,
-            )
-        await interaction.response.send_message(embed=embed, ephemeral=True)

package/src/cogs/voice_cog.py

@@ -57,6 +57,9 @@ class VoiceCog(commands.Cog):
         self.cleanup_old_voice_files.cancel()
         self.enrollment.stop()
 
+    def _wake_word_required(self, user_id) -> bool:
+        return (self.bot_settings.get("wake_word_required") or {}).get(str(user_id), True)
+
     async def handle_voice_service_down(self):
         await self.enrollment.handle_voice_service_down()
 
@@ -178,6 +181,7 @@ class VoiceCog(commands.Cog):
         wake_word_map = self.bot_settings.get("wake_words") or {}
         own_word = wake_word_map.get(str(interaction.user.id))
         active_timer = self.bot_settings.get("active_timer", 60)
+        required = self._wake_word_required(interaction.user.id)
 
         if own_word:
             msg = (
@@ -185,11 +189,16 @@ class VoiceCog(commands.Cog):
                 f"💡 Say `{own_word}` to activate me. Once awake, I'll keep listening for {active_timer} seconds after each interaction.\n"
                 f"⚙️ You can customize settings using `/sound`."
             )
+        elif not required:
+            msg = f"🎤 Connected to `{vc_chan.name}`.\n💡 Wake word is off for you - just talk, I'm listening."
         else:
             msg = (
                 f"🎤 Connected to `{vc_chan.name}`.\n"
                 f"🎙️ You haven't set up a wake word yet, so I can't hear you - run `/sound wake_word:<word>` "
-                f"and say your chosen word a few times to register it in your voice."
+                f"and say your chosen word a few times to register it in your voice.\n"
+                f"💡 A wake word keeps everyone else's side conversation from triggering me by accident, and "
+                f"avoids running speech recognition on audio that isn't meant for me. If you use push-to-talk, "
+                f"turning it off with `/sound require_wake_word:off` is recommended instead."
             )
         await interaction.response.send_message(msg)
 
@@ -205,11 +214,17 @@ class VoiceCog(commands.Cog):
                 resp = await session.post(
                     f"{NODE_VOICE_API}/join", json={"guild_id": str(guild_id), "channel_id": str(vc_chan.id)}
                 )
+                if not required:
+                    # Node's opt-out set is in-memory and won't survive a Node restart, unlike our own bot_settings.
+                    await session.post(
+                        f"{NODE_VOICE_API}/set_wake_word_required",
+                        json={"user_id": str(interaction.user.id), "required": False},
+                    )
                 data = await resp.json()
                 if data.get("success"):
                     self._voice_state[str(guild_id)] = interaction.channel_id
 
-                    if own_word:
+                    if own_word or not required:
                         if self.bot_settings.get("tts_enabled", True):
                             welcome_audio = await self.tts("Voice connected.")
                             if welcome_audio:
@@ -236,7 +251,8 @@ class VoiceCog(commands.Cog):
             await interaction.channel.send("⚠️ Timeout connecting to voice backend.")
 
     @app_commands.command(
-        name="sound", description="Configure voice settings (Wake word, active time, threshold, TTS voice, TTS on/off)"
+        name="sound",
+        description="Configure voice settings (Wake word, active time, threshold, TTS voice/speed, TTS on/off)",
     )
     @app_commands.describe(
         wake_word="The single word/phrase that wakes the bot (recorded in your voice)",
@@ -244,6 +260,8 @@ class VoiceCog(commands.Cog):
         threshold="Voice volume sensitivity (1000~10000)",
         tts_voice="Select the AI TTS voice",
         tts_enabled="Turn Text-to-Speech ON or OFF",
+        tts_speed="TTS playback speed multiplier, e.g. 1.3 for 1.3x (0.5~2.0)",
+        require_wake_word="Require your wake word before I listen (default ON) - turn OFF if you use push-to-talk",
     )
     @app_commands.autocomplete(
         active_times=active_times_autocomplete,
@@ -259,6 +277,8 @@ class VoiceCog(commands.Cog):
         threshold: int = None,
         tts_voice: str = None,
         tts_enabled: str = None,
+        tts_speed: float = None,
+        require_wake_word: str = None,
     ):
         import aiohttp
 
@@ -272,19 +292,25 @@ class VoiceCog(commands.Cog):
             and threshold is None
             and tts_voice is None
             and tts_enabled is None
+            and tts_speed is None
+            and require_wake_word is None
         ):
             curr_wake = (self.bot_settings.get("wake_words") or {}).get(str(interaction.user.id), "None")
             curr_timer = self.bot_settings.get("active_timer", 60)
             curr_thresh = self.bot_settings.get("voice_threshold", 3000)
             curr_tts = self.bot_settings.get("tts_voice", "en-US-AriaNeural")
             curr_tts_on = "ON" if self.bot_settings.get("tts_enabled", True) else "OFF"
+            curr_tts_speed = self.bot_settings.get("tts_speed", 1.0)
+            curr_required = self._wake_word_required(interaction.user.id)
 
             embed = discord.Embed(title="⚙️ Current Voice Settings", color=0x3498DB)
             embed.add_field(name="🎙️ Wake Word", value=f"`{curr_wake}`", inline=False)
+            embed.add_field(name="🔒 Wake Word Required", value=f"`{'ON' if curr_required else 'OFF'}`", inline=False)
             embed.add_field(name="⏱️ Active Time", value=f"`{curr_timer}s`", inline=False)
             embed.add_field(name="🔊 Threshold", value=f"`{curr_thresh}`", inline=False)
             embed.add_field(name="🗣️ TTS Voice", value=f"`{curr_tts}`", inline=False)
             embed.add_field(name="🔊 TTS Enabled", value=f"`{curr_tts_on}`", inline=False)
+            embed.add_field(name="⏩ TTS Speed", value=f"`{curr_tts_speed}x`", inline=False)
             return await interaction.response.send_message(embed=embed)
 
         updated = []
@@ -314,6 +340,24 @@ class VoiceCog(commands.Cog):
             is_on = tts_enabled.lower() == "on"
             self.bot_settings["tts_enabled"] = is_on
             updated.append(f"🔊 TTS Enabled: `{'ON' if is_on else 'OFF'}`")
+        if tts_speed is not None:
+            clamped = max(0.5, min(2.0, tts_speed))
+            self.bot_settings["tts_speed"] = clamped
+            updated.append(f"⏩ TTS Speed: `{clamped}x`")
+        if require_wake_word is not None:
+            is_required = require_wake_word.lower() != "off"
+            required_map = self.bot_settings.setdefault("wake_word_required", {})
+            required_map[str(interaction.user.id)] = is_required
+            updated.append(f"🔒 Wake Word Required: `{'ON' if is_required else 'OFF'}`")
+            try:
+                async with aiohttp.ClientSession(timeout=NODE_REQUEST_TIMEOUT) as session:
+                    await session.post(
+                        f"{NODE_VOICE_API}/set_wake_word_required",
+                        json={"user_id": str(interaction.user.id), "required": is_required},
+                    )
+            except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+                self.logger.warning(f"Node.js wake-word-required sync failed for {interaction.user.id}: {e}")
+                updated.append(f"(⚠️ Node.js Sync Failed: {e})")
 
         self.save_bot_settings(self.bot_settings)
 
@@ -408,7 +452,7 @@ class VoiceCog(commands.Cog):
             matched_wake_word = data.get("matched_wake_word")
             is_active = self.stt_session.is_active(str(guild_id))
 
-            if not is_active and not is_waking_up:
+            if not is_active and not is_waking_up and self._wake_word_required(user_id):
                 self.logger.debug(f"STT: ignored (sleeping): {text}")
                 await self.stt_session.clear_partial_msg(str(guild_id))
                 return

package/src/config.py

@@ -17,6 +17,9 @@ DEFAULT_LGY_CONFIG = {
     "discord_token": "",
     "telegram_token": "",
     "telegram_allowed_user_ids": "",
+    "slack_bot_token": "",
+    "slack_app_token": "",
+    "slack_allowed_user_ids": "",
     "session_scopes": [],
     "allowed_user_ids": "",
     # user_id (str) -> registered word, one per person (see EnrollmentManager._commit_enrollment).
@@ -76,6 +79,8 @@ logger = init_logger(WORKSPACE_DIR)
 
 DISCORD_TOKEN = bot_settings.get("discord_token", "")
 TELEGRAM_TOKEN = bot_settings.get("telegram_token", "")
+SLACK_BOT_TOKEN = bot_settings.get("slack_bot_token", "")
+SLACK_APP_TOKEN = bot_settings.get("slack_app_token", "")
 
 
 def _parse_session_scopes(raw_scopes) -> dict:
@@ -100,6 +105,8 @@ def _parse_session_scopes(raw_scopes) -> dict:
 SESSION_SCOPES = _parse_session_scopes(bot_settings.get("session_scopes"))
 ALLOWED_IDS = set(int(x) for x in bot_settings.get("allowed_user_ids", "").split(",") if x.strip())
 TELEGRAM_ALLOWED_IDS = set(int(x) for x in bot_settings.get("telegram_allowed_user_ids", "").split(",") if x.strip())
+# Slack user IDs are strings (e.g. "U0123ABC"), unlike Discord/Telegram's numeric IDs.
+SLACK_ALLOWED_IDS = set(x.strip() for x in bot_settings.get("slack_allowed_user_ids", "").split(",") if x.strip())
 TTS_VOICE = bot_settings.get("tts_voice", "ko-KR-SunHiNeural")
 
 
@@ -140,6 +147,12 @@ AGY_BIN = os.getenv("AGY_BIN_PATH", str(Path.home() / ".local/bin/agy"))
 session_manager = SessionManager(DATA_DIR)
 
 
-def allowed(user_id: int, platform: str = "discord") -> bool:
-    ids = TELEGRAM_ALLOWED_IDS if platform == "telegram" else ALLOWED_IDS
+def allowed(user_id, platform: str = "discord") -> bool:
+    if platform == "telegram":
+        ids = TELEGRAM_ALLOWED_IDS
+    elif platform == "slack":
+        ids = SLACK_ALLOWED_IDS
+        user_id = str(user_id)  # Slack IDs are strings, not ints like Discord/Telegram
+    else:
+        ids = ALLOWED_IDS
     return not ids or user_id in ids

package/src/core/logger.py

@@ -8,6 +8,12 @@ from loguru import logger
 
 def init_logger(workspace_dir: Path):
     logging.getLogger("discord").setLevel(logging.WARNING)
+    # httpx is what python-telegram-bot uses under the hood for every getUpdates
+    # long-poll request - left unset, it logs each one at INFO, which floods
+    # `lgy logs` with a line every poll cycle. httpcore is httpx's own transport
+    # layer and is just as noisy at DEBUG, so it's included pre-emptively too.
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("httpcore").setLevel(logging.WARNING)
     LOG_DIR = workspace_dir / "logs"
     LOG_DIR.mkdir(parents=True, exist_ok=True)
     logger.remove()

package/src/core/platform_health.py

@@ -0,0 +1,28 @@
+"""Tracks each platform's live connection health, separately from the static "enabled" config flag."""
+
+from datetime import datetime
+from pathlib import Path
+
+from core.atomic_io import atomic_write_json, safe_load_json
+
+
+def _path() -> Path:
+    from config import DATA_DIR
+
+    return DATA_DIR / "platform_health.json"
+
+
+def set_status(platform: str, status: str, detail: str = "") -> None:
+    """status: 'connecting' | 'running' | 'error'"""
+    path = _path()
+    data = safe_load_json(path, {})
+    data[platform] = {
+        "status": status,
+        "detail": detail,
+        "at": datetime.now().isoformat(),
+    }
+    atomic_write_json(path, data)
+
+
+def get_all() -> dict:
+    return safe_load_json(_path(), {})

package/src/handlers/thread_reply.py

@@ -74,7 +74,7 @@ async def handle_pending_session(
             await stream_task
 
             response_text = result_text
-            if adapter.supports_renaming:
+            if adapter.can_rename(thread):
                 new_title = await generate_thread_title(content, response_text)
                 await adapter.rename_conversation(thread, new_title)
                 await update_agy_conversation_title(new_conv_id, new_title)

package/src/main.py

@@ -1,11 +1,29 @@
-"""Top-level entrypoint. Starts whichever platforms are enabled
-(main_discord.run_discord / main_telegram.run_telegram) concurrently in
-one process, sharing a single webhook server and exception handler."""
+"""Top-level entrypoint - starts whichever platforms are enabled, concurrently in one process."""
 
 import asyncio
 
 from api import server
-from config import DISCORD_TOKEN, SESSION_SCOPES, bot_settings, logger, session_manager
+from config import (
+    DISCORD_TOKEN,
+    SESSION_SCOPES,
+    SLACK_APP_TOKEN,
+    SLACK_BOT_TOKEN,
+    bot_settings,
+    logger,
+    session_manager,
+)
+from core import platform_health
+
+
+async def _run_platform_isolated(platform: str, coro) -> None:
+    """Catches exceptions so one platform crashing can't take the others down via asyncio.gather."""
+    platform_health.set_status(platform, "connecting")
+    try:
+        await coro
+        platform_health.set_status(platform, "stopped")
+    except Exception as e:
+        logger.opt(exception=e).error(f"{platform} platform crashed - other platforms will keep running")
+        platform_health.set_status(platform, "error", detail=str(e))
 
 
 async def main():
@@ -15,14 +33,18 @@ async def main():
 
     discord_enabled = bot_settings.get("discord_enabled", bool(DISCORD_TOKEN))
     telegram_enabled = bot_settings.get("telegram_enabled", False)
+    slack_enabled = bot_settings.get("slack_enabled", False)
 
     if discord_enabled and not SESSION_SCOPES:
         logger.warning("Discord enabled but no server/channel configured (session_scopes) - run `lgy setup`")
     if discord_enabled and not DISCORD_TOKEN:
         logger.critical("Discord enabled but missing DISCORD_TOKEN - run `lgy setup`")
         discord_enabled = False
+    if slack_enabled and not (SLACK_BOT_TOKEN and SLACK_APP_TOKEN):
+        logger.critical("Slack enabled but missing SLACK_BOT_TOKEN/SLACK_APP_TOKEN - run `lgy setup`")
+        slack_enabled = False
 
-    if not discord_enabled and not telegram_enabled:
+    if not discord_enabled and not telegram_enabled and not slack_enabled:
         logger.critical("No messenger platform is enabled - run `lgy setup`")
         return
 
@@ -59,11 +81,15 @@ async def main():
     if discord_enabled:
         from main_discord import run_discord
 
-        tasks.append(asyncio.create_task(run_discord(stop_event)))
+        tasks.append(asyncio.create_task(_run_platform_isolated("discord", run_discord(stop_event))))
     if telegram_enabled:
         from main_telegram import run_telegram
 
-        tasks.append(asyncio.create_task(run_telegram(stop_event)))
+        tasks.append(asyncio.create_task(_run_platform_isolated("telegram", run_telegram(stop_event))))
+    if slack_enabled:
+        from main_slack import run_slack
+
+        tasks.append(asyncio.create_task(_run_platform_isolated("slack", run_slack(stop_event))))
 
     await asyncio.gather(*tasks)