linkgravity 1.2.2 → 1.4.0

package/bin/setup.js

@@ -1,9 +1,14 @@
 const p = require('@clack/prompts');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
 const { spawnSync } = require('child_process');
 const { python: pythonExe } = require('../npm-scripts/venv-paths');
+const {
+    getSettings,
+    updateSettings,
+    PLATFORMS,
+    platformState,
+    LGY_PM2_NAME,
+    LGY_SCRIPT_PATH,
+} = require('./platforms');
 
 const color = {
     reset: '\x1b[0m',
@@ -12,28 +17,6 @@ const color = {
     yellow: '\x1b[33m',
 };
 
-const workspaceDir = path.join(os.homedir(), '.gemini', 'linkgravity');
-const settingsPath = path.join(workspaceDir, 'lgy.json');
-
-if (!fs.existsSync(workspaceDir)) fs.mkdirSync(workspaceDir, { recursive: true });
-
-function getSettings() {
-    if (fs.existsSync(settingsPath)) {
-        try {
-            return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-        } catch (e) {}
-    }
-    return {};
-}
-
-function updateSettings(updates) {
-    const settings = getSettings();
-    for (const [key, value] of Object.entries(updates)) {
-        settings[key] = value;
-    }
-    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 4));
-}
-
 function splitIds(raw) {
     return raw.split(/[\s,;]+/).filter(Boolean);
 }
@@ -115,14 +98,14 @@ async function collectSessionScopes(existingScopes) {
     return scopes;
 }
 
-async function collectUserIds(existingIds) {
+async function collectUserIds(existingIds, platformLabel) {
     const ids = [];
     const hasExisting = existingIds && existingIds.length > 0;
 
     p.note(
         'ONLY these users can use the bot (leave completely empty on first setup to allow EVERYONE). ' +
             'Not related to DMs - this only gates the channel/threads configured above.',
-        'Allowed Discord Users',
+        `Allowed ${platformLabel} Users`,
     );
 
     let isFirst = true;
@@ -133,7 +116,7 @@ async function collectUserIds(existingIds) {
                 : ' (leave empty if you have no more users to add)';
 
         const userId = await p.text({
-            message: `Discord User ID to allow${promptSuffix}:`,
+            message: `${platformLabel} User ID to allow${promptSuffix}:`,
         });
         if (p.isCancel(userId)) {
             p.cancel('Setup cancelled.');
@@ -159,19 +142,64 @@ async function collectUserIds(existingIds) {
     return ids;
 }
 
-async function runSetup() {
-    console.log();
-    p.intro(`${color.cyan}▶ LinkGravity Setup Wizard${color.reset}`);
+function stopDaemon(pm2Name, label) {
+    console.log(`${color.cyan}▶${color.reset} Stopping ${label} daemon...`);
+    spawnSync('npx', ['-y', 'pm2', 'delete', pm2Name], { stdio: 'pipe' });
+
+    const jlist = spawnSync('npx', ['-y', 'pm2', 'jlist'], { stdio: 'pipe' });
+    let stillRunning = false;
+    if (jlist.status === 0) {
+        try {
+            stillRunning = JSON.parse(jlist.stdout.toString()).some((p) => p.name === pm2Name);
+        } catch (e) {}
+    }
+
+    if (!stillRunning) {
+        p.outro(`${label} daemon stopped.`);
+    } else {
+        p.outro(
+            `${color.yellow}⚠${color.reset} ${label} daemon is still running - run \`npx pm2 delete ${pm2Name}\` manually and check \`npx pm2 list\`.`,
+        );
+    }
+}
 
-    const platform = await p.select({
-        message: 'Which messenger platform would you like to configure?',
-        options: [{ label: 'Discord', value: 'discord', hint: 'Configure Discord bot settings' }],
+function startOrRestartDaemon(pm2Name, scriptPath, label) {
+    console.log(`${color.cyan}▶${color.reset} Restarting ${label} daemon to apply changes...`);
+    const restartResult = spawnSync('npx', ['-y', 'pm2', 'restart', pm2Name, '--update-env'], {
+        stdio: 'pipe',
+        env: { ...process.env, PYTHONUNBUFFERED: '1' },
     });
-    if (p.isCancel(platform)) {
-        p.cancel('Setup cancelled.');
-        process.exit(0);
+
+    if (restartResult.status === 0) {
+        p.outro(`${label} daemon restarted.`);
+        return;
+    }
+
+    const stderr = (restartResult.stderr || '').toString();
+    if (stderr.includes('not found')) {
+        // Nothing to restart yet - start it instead of a false "restarted".
+        const startResult = spawnSync(
+            'npx',
+            ['-y', 'pm2', 'start', scriptPath, '--interpreter', pythonExe, '--name', pm2Name],
+            { stdio: 'pipe', env: { ...process.env, PYTHONUNBUFFERED: '1' } },
+        );
+        if (startResult.status === 0) {
+            p.outro(`${label} daemon wasn't running yet - started it fresh instead.`);
+        } else {
+            console.error((startResult.stderr || '').toString().trim());
+            p.outro(
+                `${color.yellow}⚠${color.reset} Failed to start the ${label} daemon - run \`lgy start\` manually to see the full error.`,
+            );
+        }
+    } else {
+        console.error(stderr.trim());
+        p.outro(
+            `${color.yellow}⚠${color.reset} Failed to restart the ${label} daemon - run \`lgy restart\` manually to see the full error.`,
+        );
     }
+}
 
+async function configureDiscord(existingSettings) {
     const discordToken = await p.password({
         message: 'Discord Bot Token (Leave empty to keep current):',
     });
@@ -180,13 +208,17 @@ async function runSetup() {
         process.exit(0);
     }
 
-    const existingSettings = getSettings();
     const sessionScopes = await collectSessionScopes(existingSettings.session_scopes);
 
     const existingUserIds = existingSettings.allowed_user_ids
         ? splitIds(existingSettings.allowed_user_ids)
         : [];
-    const userIds = await collectUserIds(existingUserIds);
+    const userIds = await collectUserIds(existingUserIds, 'Discord');
+
+    const updates = {};
+    if (discordToken) updates.discord_token = discordToken;
+    if (sessionScopes !== null) updates.session_scopes = sessionScopes;
+    if (userIds !== null) updates.allowed_user_ids = userIds.join(',');
 
     p.note(
         "Wake words aren't set here anymore - they need a voice recording to register " +
@@ -255,51 +287,115 @@ async function runSetup() {
         },
     );
 
-    const settingsUpdates = {};
-    if (discordToken) settingsUpdates.discord_token = discordToken;
-    if (sessionScopes !== null) settingsUpdates.session_scopes = sessionScopes;
-    if (userIds !== null) settingsUpdates.allowed_user_ids = userIds.join(',');
-    if (group.tts_voice) settingsUpdates.tts_voice = group.tts_voice;
+    if (group.tts_voice) updates.tts_voice = group.tts_voice;
+    return updates;
+}
 
-    if (Object.keys(settingsUpdates).length > 0) {
-        updateSettings(settingsUpdates);
+async function configureTelegram(existingSettings) {
+    const telegramToken = await p.password({
+        message: 'Telegram Bot Token (from @BotFather, leave empty to keep current):',
+    });
+    if (p.isCancel(telegramToken)) {
+        p.cancel('Setup cancelled.');
+        process.exit(0);
     }
 
-    p.note('Configuration saved to lgy.json successfully!', 'Success');
+    p.note(
+        'Telegram has no channel/server gating yet - every chat you DM (or add) the bot to becomes ' +
+            'its own session, and there is no voice support yet.',
+        'Telegram Access',
+    );
 
-    console.log(`${color.cyan}▶${color.reset} Restarting daemon to apply changes...`);
-    const restartResult = spawnSync('npx', ['-y', 'pm2', 'restart', 'lgy', '--update-env'], {
-        stdio: 'pipe',
-        env: { ...process.env, PYTHONUNBUFFERED: '1' },
-    });
+    const existingTelegramUserIds = existingSettings.telegram_allowed_user_ids
+        ? splitIds(existingSettings.telegram_allowed_user_ids)
+        : [];
+    const telegramUserIds = await collectUserIds(existingTelegramUserIds, 'Telegram');
 
-    if (restartResult.status === 0) {
-        p.outro('Daemon restarted.');
+    const updates = {};
+    if (telegramToken) updates.telegram_token = telegramToken;
+    if (telegramUserIds !== null) updates.telegram_allowed_user_ids = telegramUserIds.join(',');
+    return updates;
+}
+
+const CONFIGURERS = {
+    discord: configureDiscord,
+    telegram: configureTelegram,
+};
+
+function applyDaemonState() {
+    const settings = getSettings();
+    const anyEnabled = Object.keys(PLATFORMS).some((k) => platformState(k, settings).enabled);
+    if (anyEnabled) {
+        startOrRestartDaemon(LGY_PM2_NAME, LGY_SCRIPT_PATH, 'LinkGravity');
     } else {
-        const stderr = (restartResult.stderr || '').toString();
-        if (stderr.includes('not found')) {
-            // Nothing to restart yet - start it instead of a false "restarted".
-            const botPath = path.join(__dirname, '..', 'src', 'main.py');
-            const startResult = spawnSync(
-                'npx',
-                ['-y', 'pm2', 'start', botPath, '--interpreter', pythonExe, '--name', 'lgy'],
-                { stdio: 'pipe', env: { ...process.env, PYTHONUNBUFFERED: '1' } },
-            );
-            if (startResult.status === 0) {
-                p.outro("Daemon wasn't running yet - started it fresh instead.");
-            } else {
-                console.error((startResult.stderr || '').toString().trim());
-                p.outro(
-                    `${color.yellow}⚠${color.reset} Failed to start the daemon - run \`lgy start\` manually to see the full error.`,
-                );
-            }
-        } else {
-            console.error(stderr.trim());
-            p.outro(
-                `${color.yellow}⚠${color.reset} Failed to restart the daemon - run \`lgy restart\` manually to see the full error.`,
-            );
+        stopDaemon(LGY_PM2_NAME, 'LinkGravity');
+    }
+}
+
+async function platformMenu(key) {
+    const def = PLATFORMS[key];
+
+    while (true) {
+        const settings = getSettings();
+        const { configured, enabled } = platformState(key, settings);
+
+        const options = [];
+        options.push(
+            enabled
+                ? { value: 'off', label: 'Turn OFF' }
+                : { value: 'on', label: configured ? 'Turn ON' : 'Configure & turn ON' },
+        );
+        if (configured)
+            options.push({ value: 'edit', label: 'Edit settings (token, access, etc.)' });
+        options.push({ value: 'back', label: '← Back' });
+
+        const action = await p.select({
+            message: `${def.label} — currently ${enabled ? 'ON' : 'OFF'}${configured ? '' : ' (not configured)'}`,
+            options,
+        });
+        if (p.isCancel(action) || action === 'back') return;
+
+        if (action === 'off') {
+            updateSettings({ [`${key}_enabled`]: false });
+            applyDaemonState();
+            continue;
         }
+
+        if (action === 'on' && configured) {
+            updateSettings({ [`${key}_enabled`]: true });
+            applyDaemonState();
+            continue;
+        }
+
+        // action === 'edit', or first-time 'on' (not configured yet) - both need the full wizard.
+        const updates = await CONFIGURERS[key](settings);
+        updates[`${key}_enabled`] = true;
+        updateSettings(updates);
+        applyDaemonState();
     }
 }
 
+async function runSetup() {
+    console.log();
+    p.intro(`${color.cyan}▶ LinkGravity Setup Wizard${color.reset}`);
+
+    while (true) {
+        const settings = getSettings();
+        const options = Object.entries(PLATFORMS).map(([key, def]) => {
+            const { configured, enabled } = platformState(key, settings);
+            return {
+                value: key,
+                label: `${def.label} — ${enabled ? 'ON' : 'OFF'}`,
+                hint: configured ? undefined : 'not configured yet',
+            };
+        });
+        const choice = await p.select({ message: 'LinkGravity Setup (Esc to finish)', options });
+        if (p.isCancel(choice)) break;
+
+        await platformMenu(choice);
+    }
+
+    p.outro('Setup complete.');
+}
+
 module.exports = runSetup;

package/hooks/hook.py

@@ -7,7 +7,7 @@ import urllib.request
 
 
 def main():
-    if os.environ.get("AGY_DISCORD_BOT") != "1":
+    if os.environ.get("LGY_APPROVAL_HOOK") != "1":
         print(json.dumps({"decision": "allow"}))
         return
 
@@ -29,7 +29,7 @@ def main():
             "conversation_id": conv_id,
             "tool_name": tool_name,
             "tool_input": tool_input_data,
-            "thread_id": os.environ.get("DISCORD_THREAD_ID"),
+            "thread_id": os.environ.get("LGY_THREAD_ID"),
         }
     ).encode("utf-8")
 
@@ -43,8 +43,7 @@ def main():
             decision = res_data.get("decision", "allow")
             if decision == "allow":
                 out = {"decision": "allow"}
-                # Print mode requires a matching allow rule even when this
-                # hook says "allow", or it soft-denies the tool call anyway.
+                # Print mode requires a matching allow rule even when this hook says "allow", or it soft-denies anyway.
                 if res_data.get("permissionOverrides"):
                     out["permissionOverrides"] = res_data["permissionOverrides"]
                 print(json.dumps(out))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkgravity",
-  "version": "1.2.2",
+  "version": "1.4.0",
   "description": "Discord bot bridge for the Antigravity (agy) CLI, with voice interaction support",
   "scripts": {
     "postinstall": "node npm-scripts/postinstall.js",

package/requirements.txt

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

package/src/api/server.py

@@ -23,7 +23,7 @@ async def setup_webhook_server(bot):
     app = web.Application(client_max_size=50 * 1024 * 1024)
     app["bot"] = bot
 
-    from api.ui_routes import handle_approve_request, handle_mcp_ask, handle_mcp_send_channel
+    from api.ui_routes import handle_approve_request
     from api.voice_routes import (
         handle_enroll_sample,
         handle_stt_input,
@@ -33,8 +33,6 @@ async def setup_webhook_server(bot):
     )
 
     app.router.add_post("/approve", handle_approve_request)
-    app.router.add_post("/mcp_ask", handle_mcp_ask)
-    app.router.add_post("/mcp_send_channel", handle_mcp_send_channel)
     app.router.add_post("/stt_input", handle_stt_input)
     app.router.add_post("/tts_finished", handle_tts_finished)
     app.router.add_post("/stt_partial", handle_stt_partial)
@@ -45,4 +43,4 @@ async def setup_webhook_server(bot):
     await runner.setup()
     site = web.TCPSite(runner, "0.0.0.0", 18080)
     await site.start()
-    logger.info("Webhook / MCP / STT Server started on port 18080")
+    logger.info("Webhook / STT Server started on port 18080")

package/src/api/ui_routes.py

@@ -6,9 +6,9 @@ import uuid
 
 from aiohttp import web
 
-from config import MAX_EMBED_LEN, logger, session_manager
+from config import APPROVAL_TIMEOUT_SEC, MAX_EMBED_LEN, logger, session_manager
 from messengers.base import ScopeOption
-from messengers.registry import get_adapter
+from messengers.registry import get_adapter_for_platform, get_adapter_for_thread
 
 
 def is_tool_allowed(tool_name, tool_input):
@@ -54,6 +54,13 @@ def allow_response(tool_name, tool_input):
     return web.json_response(body)
 
 
+async def _send_chunked(adapter, thread, text: str) -> None:
+    if not text:
+        return
+    for i in range(0, len(text), MAX_EMBED_LEN):
+        await adapter.send_message(thread, text[i : i + MAX_EMBED_LEN])
+
+
 def _persist_scope_if_granted(prompt_handle):
     """If the prompt was resolved via a persistent-allow button, records
     that scope. Scope persistence is business logic, so it lives here
@@ -84,18 +91,18 @@ async def handle_approve_request(request):
         # DEBUG-only (see logger.py's LOG_LEVEL). Silent by default.
         logger.debug(f"[APPROVE HOOK] tool_name={tool_name!r} conv_id={conv_id!r} tool_input={tool_input!r}")
 
-        adapter = get_adapter()
-
         target_thread = None
         target_thread_id = None
         for thread_id_str, sess in session_manager.get_all_sessions().items():
             if sess.get("conversation_id") == conv_id:
-                target_thread = adapter.resolve_conversation(thread_id_str)
+                candidate_adapter = get_adapter_for_platform(sess.get("platform", "discord"))
+                target_thread = candidate_adapter.resolve_conversation(thread_id_str)
                 target_thread_id = thread_id_str
                 break
 
         if not target_thread and payload_thread_id:
-            resolved_channel = adapter.resolve_conversation(payload_thread_id)
+            candidate_adapter = get_adapter_for_thread(payload_thread_id)
+            resolved_channel = candidate_adapter.resolve_conversation(payload_thread_id)
             if resolved_channel:
                 target_thread = resolved_channel
                 target_thread_id = payload_thread_id
@@ -106,16 +113,21 @@ async def handle_approve_request(request):
         if not target_thread:
             for thread_id_str, sess in reversed(list(session_manager.get_all_sessions().items())):
                 if sess.get("status") == "pending":
-                    target_thread = adapter.resolve_conversation(thread_id_str)
+                    candidate_adapter = get_adapter_for_platform(sess.get("platform", "discord"))
+                    target_thread = candidate_adapter.resolve_conversation(thread_id_str)
                     session_manager.update_session(thread_id_str, "conversation_id", conv_id)
                     session_manager.update_session(thread_id_str, "status", "active")
                     target_thread_id = thread_id_str
                     break
 
-        if target_thread_id and session_manager.get_session(target_thread_id):
-            session_manager.update_session(target_thread_id, "current_tool", tool_name)
+        def _set_tool_status(key: str):
+            if target_thread_id and session_manager.get_session(target_thread_id):
+                session_manager.update_session(target_thread_id, key, tool_name)
+
+        adapter = get_adapter_for_thread(target_thread_id) if target_thread_id else get_adapter_for_platform("discord")
 
         if "ask_question" in tool_name:
+            _set_tool_status("current_tool")  # no separate approval phase here - it's waiting on the user either way
             if not target_thread:
                 return web.json_response({"decision": "deny", "reason": "No target thread found."})
 
@@ -138,7 +150,15 @@ async def handle_approve_request(request):
             )
             await send_ordered(target_thread_id, lambda: prompt.send(target_thread))
 
-            chosen_opt = await future
+            try:
+                chosen_opt = await asyncio.wait_for(future, timeout=APPROVAL_TIMEOUT_SEC)
+            except asyncio.TimeoutError:
+                logger.warning(
+                    f"Question prompt timed out after {APPROVAL_TIMEOUT_SEC}s with no answer (conv_id={conv_id!r})"
+                )
+                session_manager.clear_pending_approval(approval_key)
+                await prompt.finalize()
+                return web.json_response({"decision": "deny", "reason": "User did not answer in time."})
             session_manager.clear_pending_approval(approval_key)
             await prompt.finalize()
 
@@ -219,12 +239,19 @@ async def handle_approve_request(request):
                 sub_cmd_formatted = f"```text\n{sub_cmd_display}\n```{sub_cmd_desc}"
 
                 async def _send_bash_prompt(sub_cmd_formatted=sub_cmd_formatted, prompt=prompt):
-                    await adapter.send_message(target_thread, sub_cmd_formatted)
+                    await _send_chunked(adapter, target_thread, sub_cmd_formatted)
                     return await prompt.send(target_thread)
 
                 await send_ordered(target_thread_id, _send_bash_prompt)
+                _set_tool_status("pending_approval_tool")
 
-                decision = await future
+                try:
+                    decision = await asyncio.wait_for(future, timeout=APPROVAL_TIMEOUT_SEC)
+                except asyncio.TimeoutError:
+                    logger.warning(
+                        f"Tool approval timed out after {APPROVAL_TIMEOUT_SEC}s with no response (conv_id={conv_id!r}, tool={tool_name!r})"
+                    )
+                    decision = "reject"
                 session_manager.clear_pending_approval(approval_key)
                 _persist_scope_if_granted(prompt)
                 await prompt.finalize()
@@ -232,8 +259,13 @@ async def handle_approve_request(request):
                 if decision == "reject":
                     return web.json_response({"decision": "reject"})
 
+                _set_tool_status("current_tool")
+
             if target_thread and tool_msg_text and not prompted:
-                await send_ordered(target_thread_id, lambda: adapter.send_message(target_thread, tool_msg_formatted))
+                await send_ordered(target_thread_id, lambda: _send_chunked(adapter, target_thread, tool_msg_formatted))
+
+            if not prompted:
+                _set_tool_status("current_tool")  # auto-allowed - runs immediately, no approval wait
 
             return allow_response(tool_name, tool_input)
 
@@ -248,8 +280,9 @@ async def handle_approve_request(request):
             if is_auto_allowed:
                 if target_thread and tool_msg_text:
                     await send_ordered(
-                        target_thread_id, lambda: adapter.send_message(target_thread, tool_msg_formatted)
+                        target_thread_id, lambda: _send_chunked(adapter, target_thread, tool_msg_formatted)
                     )
+                _set_tool_status("current_tool")  # auto-allowed - runs immediately, no approval wait
                 return allow_response(tool_name, tool_input)
 
             approval_key = f"{conv_id}:{uuid.uuid4().hex}"
@@ -263,12 +296,19 @@ async def handle_approve_request(request):
             )
 
             async def _send_prompt():
-                await adapter.send_message(target_thread, tool_msg_formatted)
+                await _send_chunked(adapter, target_thread, tool_msg_formatted)
                 return await prompt.send(target_thread)
 
             await send_ordered(target_thread_id, _send_prompt)
+            _set_tool_status("pending_approval_tool")
 
-            decision = await future
+            try:
+                decision = await asyncio.wait_for(future, timeout=APPROVAL_TIMEOUT_SEC)
+            except asyncio.TimeoutError:
+                logger.warning(
+                    f"Tool approval timed out after {APPROVAL_TIMEOUT_SEC}s with no response (conv_id={conv_id!r}, tool={tool_name!r})"
+                )
+                decision = "reject"
             session_manager.clear_pending_approval(approval_key)
             _persist_scope_if_granted(prompt)
             await prompt.finalize()
@@ -276,6 +316,7 @@ async def handle_approve_request(request):
             if decision == "reject":
                 return web.json_response({"decision": "reject"})
 
+            _set_tool_status("current_tool")
             return allow_response(tool_name, tool_input)
 
     except Exception as e:
@@ -293,7 +334,7 @@ async def handle_mcp_ask(request):
         question = _clean_inline(data.get("question", "No question provided."))
         options = [(_clean_inline(str(opt)) or "Option")[:80] for opt in data.get("options", [])]
 
-        adapter = get_adapter()
+        adapter = get_adapter_for_thread(thread_id)
         thread = adapter.resolve_conversation(thread_id)
         if not thread:
             return web.json_response({"answer": "Thread not found"}, status=400)
@@ -326,7 +367,7 @@ async def handle_mcp_send_channel(request):
         channel_id = data.get("channel_id")
         message = data.get("message", "")
 
-        adapter = get_adapter()
+        adapter = get_adapter_for_thread(channel_id)
         channel = adapter.resolve_conversation(channel_id)
         if not channel:
             return web.json_response({"error": "Channel not found"}, status=400)

package/src/api/voice_routes.py

@@ -14,10 +14,7 @@ async def handle_stt_input(request):
             asyncio.create_task(cog.handle_stt_input(data))
         return web.json_response({"success": True})
     except Exception as e:
-        import traceback
-
-        logger.error(f"STT API error: {e}")
-        traceback.print_exc()
+        logger.exception(f"STT API error: {e}")
         return web.json_response({"error": str(e)}, status=500)
 
 
@@ -36,7 +33,7 @@ async def handle_tts_finished(request):
             cog.mark_tts_finished(str(guild_id))
         return web.json_response({"success": True})
     except Exception as e:
-        logger.error(f"tts_finished API error: {e}")
+        logger.exception(f"tts_finished API error: {e}")
         return web.json_response({"error": str(e)}, status=500)
 
 
@@ -53,7 +50,7 @@ async def handle_stt_partial(request):
             asyncio.create_task(cog.handle_stt_partial(data))
         return web.json_response({"success": True})
     except Exception as e:
-        logger.error(f"stt_partial API error: {e}")
+        logger.exception(f"stt_partial API error: {e}")
         return web.json_response({"error": str(e)}, status=500)
 
 
@@ -71,7 +68,7 @@ async def handle_stt_partial_cancel(request):
             asyncio.create_task(cog.cancel_stt_partial(str(guild_id)))
         return web.json_response({"success": True})
     except Exception as e:
-        logger.error(f"stt_partial_cancel API error: {e}")
+        logger.exception(f"stt_partial_cancel API error: {e}")
         return web.json_response({"error": str(e)}, status=500)
 
 
@@ -90,5 +87,5 @@ async def handle_enroll_sample(request):
             asyncio.create_task(cog.handle_enroll_sample(user_id, audio_bytes))
         return web.json_response({"success": True})
     except Exception as e:
-        logger.error(f"enroll_sample API error: {e}")
+        logger.exception(f"enroll_sample API error: {e}")
         return web.json_response({"error": str(e)}, status=500)

package/src/cogs/general_cog.py

@@ -1,6 +1,7 @@
 import asyncio
 import glob
 import os
+from datetime import datetime
 from pathlib import Path
 
 import discord
@@ -53,7 +54,7 @@ async def fetch_models_background():
 
         logger.debug(f"Starting fetch_models_background using AGY_BIN: {AGY_BIN}")
         env = os.environ.copy()
-        env["AGY_DISCORD_BOT"] = "1"
+        env["LGY_APPROVAL_HOOK"] = "1"
         p = await asyncio.create_subprocess_exec(
             AGY_BIN,
             "models",
@@ -178,10 +179,12 @@ class GeneralCog(commands.Cog):
             str(thread.id),
             {
                 "status": "pending",
+                "platform": "discord",
                 "user_id": interaction.user.id,
                 "cwd": cwd or get_default_cwd(),
                 "model": model,
                 "conversation_id": None,
+                "created_at": datetime.now().isoformat(),
             },
         )
         await thread.send("✅ **Ready for new session!**")

package/src/cogs/voice/enrollment.py

@@ -263,7 +263,7 @@ class EnrollmentManager:
         session["pending_sample"] = audio_bytes
         session["awaiting_confirmation"] = True
 
-        await self._play_audio(session["guild_id"], audio_bytes, suppress_active_window=True)
+        await self._play_audio(session["guild_id"], self._trim_silence_wav(audio_bytes), suppress_active_window=True)
         await self._update_status(
             session,
             f"🔊 **{step}/{session['needed']}** captured - keep it, or re-record if it's noisy?",