linkgravity 1.5.8 → 1.5.10

package/README.md

@@ -2,13 +2,15 @@
 
 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.
 
+![Tool approval buttons and session threads in Discord](https://raw.githubusercontent.com/dev-sseul/linkgravity/main/docs/images/approval-flow.png)
+
 ## 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.
+- **Sessions as Threads:** Each `agy` conversation lives in its own thread, so several can run side by side and stay readable later. Threads get named from what you actually talked about instead of staying `Session-XXXX`.
 - **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.
+- **Voice Interaction:** Talk to the agent from a Discord voice channel and hear its replies. Say your wake word to get its attention, so side conversation in the channel doesn't set it off.
 - **Multi-Modal Input:** Attach files for the AI to read, including audio, which gets transcribed to text automatically.
+- **Same Agent as Your Terminal:** Reads the `agy` setup already on the machine, so sessions started from chat use the same models and settings you use locally.
 
 ## Supported Platforms
 
@@ -58,7 +60,7 @@ Slack has more moving parts than the others - two separate tokens, and a few set
     - 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).
+7. **Slash Commands** (left sidebar) > **Create New Command**, four times, for `/new`, `/model`, `/credit`, and `/permissions` (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.
 

package/bin/cli.js

@@ -376,11 +376,8 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     }
 
     if (!isEnvironmentReady()) {
-        console.log(
-            `\n${color.yellow}⚠${color.reset} Python environment isn't set up yet - ` +
-                `run ${color.cyan}lgy setup${color.reset} first (it installs everything on its first run).\n`,
-        );
-        process.exit(1);
+        info('Some dependencies are missing - installing them first...');
+        require('../npm-scripts/ensure-env').ensureEnvironment();
     }
 
     info('Starting LinkGravity daemon...');
@@ -602,6 +599,12 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     }
     success(`Installed v${latestVersion}.`);
 
+    // The new install ships without voice-service/node_modules, so restore anything the
+    // directory swap dropped. Loaded here rather than at the top of the file: by now npm has
+    // replaced this package on disk, and the copy required at startup is the pre-update one.
+    delete require.cache[require.resolve('../npm-scripts/ensure-env')];
+    require('../npm-scripts/ensure-env').ensureEnvironment();
+
     if (!procBeforeUpdate) {
         info("Daemon wasn't running - starting it fresh...");
         runPm2(['start', LGY_SCRIPT_PATH, '--interpreter', pythonExe, '--name', LGY_PM2_NAME]);

package/npm-scripts/ensure-env.js

@@ -8,31 +8,40 @@ const { pip: venvPip, python: venvPython, workspaceDir, repoRoot } = require('./
 const isWin = os.platform() === 'win32';
 const pyCmd = isWin ? 'python' : 'python3';
 
-function isEnvironmentReady() {
+const voiceServiceDir = path.join(repoRoot, 'voice-service');
+
+function isVenvReady() {
     return fs.existsSync(venvPython);
 }
 
+function isVoiceServiceReady() {
+    return fs.existsSync(path.join(voiceServiceDir, 'node_modules'));
+}
+
+function isEnvironmentReady() {
+    return isVenvReady() && isVoiceServiceReady();
+}
+
 function ensureEnvironment() {
-    if (isEnvironmentReady()) return;
-
-    console.log('⚙️  Setting up Python Virtual Environment...');
-    console.log(
-        `   (in ${path.join(workspaceDir, 'venv')} - not inside this install, so it survives`,
-    );
-    console.log('    package updates/reinstalls and works the same whether this is a global');
-    console.log('    `npm install -g linkgravity` or a local dev clone.)');
-
-    fs.mkdirSync(workspaceDir, { recursive: true });
-    execSync(`${pyCmd} -m venv "${path.join(workspaceDir, 'venv')}"`, { stdio: 'inherit' });
-
-    console.log('📦 Installing Python dependencies...');
-    execSync(`"${venvPip}" install -r requirements.txt`, { stdio: 'inherit', cwd: repoRoot });
-
-    console.log('🎙️  Installing Voice Service dependencies...');
-    execSync('npm install', {
-        stdio: 'inherit',
-        cwd: path.join(repoRoot, 'voice-service'),
-    });
+    if (!isVenvReady()) {
+        console.log('⚙️  Setting up Python Virtual Environment...');
+        console.log(
+            `   (in ${path.join(workspaceDir, 'venv')} - not inside this install, so it survives`,
+        );
+        console.log('    package updates/reinstalls and works the same whether this is a global');
+        console.log('    `npm install -g linkgravity` or a local dev clone.)');
+
+        fs.mkdirSync(workspaceDir, { recursive: true });
+        execSync(`${pyCmd} -m venv "${path.join(workspaceDir, 'venv')}"`, { stdio: 'inherit' });
+
+        console.log('📦 Installing Python dependencies...');
+        execSync(`"${venvPip}" install -r requirements.txt`, { stdio: 'inherit', cwd: repoRoot });
+    }
+
+    if (!isVoiceServiceReady()) {
+        console.log('🎙️  Installing Voice Service dependencies...');
+        execSync('npm install', { stdio: 'inherit', cwd: voiceServiceDir });
+    }
 
     console.log('✅ Environment ready.');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkgravity",
-  "version": "1.5.8",
+  "version": "1.5.10",
   "description": "Discord/Telegram bot bridge for the Antigravity (agy) CLI, with voice interaction support",
   "scripts": {
     "start": "node npm-scripts/run-dev.js",

package/src/api/ui_routes.py

@@ -197,10 +197,7 @@ async def handle_approve_request(request):
                                 break
                     except ValueError:
                         pass
-                elif is_tool_allowed(tool_name, {"CommandLine": sub_cmd}) or (
-                    conv_id in session_manager.session_allowed_tools
-                    and tool_name in session_manager.session_allowed_tools[conv_id]
-                ):
+                elif is_tool_allowed(tool_name, {"CommandLine": sub_cmd}):
                     is_auto_allowed = True
 
                 if is_auto_allowed:
@@ -271,14 +268,7 @@ async def handle_approve_request(request):
             return allow_response(tool_name, tool_input)
 
         else:
-            is_auto_allowed = False
-            if is_tool_allowed(tool_name, tool_input) or (
-                conv_id in session_manager.session_allowed_tools
-                and tool_name in session_manager.session_allowed_tools[conv_id]
-            ):
-                is_auto_allowed = True
-
-            if is_auto_allowed:
+            if is_tool_allowed(tool_name, tool_input):
                 if target_thread and tool_msg_text:
                     await send_ordered(
                         target_thread_id, lambda: _send_chunked(adapter, target_thread, tool_msg_formatted)

package/src/cogs/general_cog.py

@@ -255,6 +255,23 @@ class GeneralCog(commands.Cog):
         except Exception as e:
             await interaction.response.send_message(f"⚠️ Failed to update settings: {e}", ephemeral=True)
 
+    @app_commands.command(name="permissions", description="View and remove previously allowed tools and commands")
+    async def cmd_permissions(self, interaction: discord.Interaction):
+        if not allowed(interaction.user.id):
+            return await interaction.response.send_message("❌ Denied", ephemeral=True)
+
+        from messengers.registry import get_adapter_for_platform
+        from services import permissions
+
+        adapter = get_adapter_for_platform("discord")
+
+        async def on_revoke(entry):
+            permissions.revoke(entry)
+
+        handle = adapter.create_permission_list(on_revoke)
+        await handle.send(interaction.channel)
+        await interaction.response.send_message("🔐 Permission list posted above.", ephemeral=True)
+
     @app_commands.command(
         name="stop", description="Stop the currently generating response or task (Equivalent to ESC in CLI)"
     )
@@ -278,9 +295,21 @@ class GeneralCog(commands.Cog):
             # Must clear conversation_id too, not just status - pending requires both unset.
             session_manager.set_session(thread_id, {**session, "status": "pending", "conversation_id": None})
 
+        # The typing indicator only clears when the handler leaves its `async with adapter.typing()`
+        # block, and that block outlives the agy process (title generation, final send), so killing
+        # the process alone can leave the thread stuck showing "is thinking...".
+        handler = session_manager.get_handler_task(thread_id)
+        cancelled = bool(handler and handler is not asyncio.current_task() and not handler.done())
+        if cancelled:
+            handler.cancel()
+            session_manager.remove_handler_task(thread_id)
+
         from core.agy_runner import stop_active_process
 
         if stop_active_process(thread_id):
-            await interaction.response.send_message("🛑 Process stopped natively.", ephemeral=True)
+            msg = "🛑 Process stopped natively."
+        elif cancelled:
+            msg = "🛑 Stopped."
         else:
-            await interaction.response.send_message("🛑 Process stopped.", ephemeral=True)
+            msg = "🛑 Nothing was running."
+        await interaction.response.send_message(msg, ephemeral=True)

package/src/core/session_manager.py

@@ -24,7 +24,6 @@ class SessionManager:
         self.active_approval_by_conv: dict[str, str] = {}
 
         self.persistent_allowed: dict = self._load_persistent()
-        self.session_allowed_tools: dict[str, set] = {}
 
     def _load_sessions(self) -> dict:
         from config import logger

package/src/main_slack.py

@@ -14,7 +14,12 @@ from config import SLACK_APP_TOKEN, SLACK_BOT_TOKEN, allowed, bot_settings, logg
 from core import platform_health
 from handlers.message_router import handle_message
 from messengers.registry import register_adapter
-from messengers.slack_adapter import SlackAdapter, encode_conversation_id, latest_channel_session
+from messengers.slack_adapter import (
+    SlackAdapter,
+    SlackConversationRef,
+    encode_conversation_id,
+    latest_channel_session,
+)
 from utils.utils import get_default_cwd
 
 
@@ -129,6 +134,25 @@ async def cmd_model(ack, body, respond, context) -> None:
     await respond(f"🤖 Model changed: *{final_model}*\n💾 Also set as the default for new sessions.")
 
 
+async def cmd_permissions(ack, body, respond, context) -> None:
+    await ack()
+    adapter: SlackAdapter = context["adapter"]
+    user_id = body["user_id"]
+    channel = body["channel_id"]
+
+    if not allowed(user_id, "slack"):
+        await respond("❌ Denied")
+        return
+
+    from services import permissions
+
+    async def on_revoke(entry):
+        permissions.revoke(entry)
+
+    handle = adapter.create_permission_list(on_revoke)
+    await handle.send(SlackConversationRef(channel=channel, thread_ts=None))
+
+
 async def cmd_credit(ack, body, respond, context) -> None:
     await ack()
     adapter: SlackAdapter = context["adapter"]
@@ -212,6 +236,7 @@ def build_app() -> tuple[AsyncApp, SlackAdapter]:
     app.command("/new")(cmd_new)
     app.command("/model")(cmd_model)
     app.command("/credit")(cmd_credit)
+    app.command("/permissions")(cmd_permissions)
     app.event("message")(on_message)
     app.action(re.compile(".*"))(on_action)
     app.view(re.compile(".*"))(on_view_submission)

package/src/main_telegram.py

@@ -135,6 +135,23 @@ async def cmd_model(update: Update, context) -> None:
     )
 
 
+async def cmd_permissions(update: Update, context) -> None:
+    user = update.effective_user
+    adapter: TelegramAdapter = context.bot_data["adapter"]
+
+    if not allowed(user.id, "telegram"):
+        await update.message.reply_text("❌ Denied")
+        return
+
+    from services import permissions
+
+    async def on_revoke(entry):
+        permissions.revoke(entry)
+
+    handle = adapter.create_permission_list(on_revoke)
+    await handle.send(update.effective_chat.id)
+
+
 async def cmd_credit(update: Update, context) -> None:
     user = update.effective_user
     adapter: TelegramAdapter = context.bot_data["adapter"]
@@ -207,6 +224,7 @@ async def on_ready(app: Application) -> None:
             BotCommand("new", "Start a new session (or /start)"),
             BotCommand("model", "Change the AI model for this session"),
             BotCommand("credit", "Turn AI Credits on/off"),
+            BotCommand("permissions", "View and remove allowed tools and commands"),
         ]
     )
     logger.info(f"✅ Bot is fully online and ready! Logged in as @{app.bot.username}")
@@ -221,6 +239,7 @@ def build_application() -> Application:
     app.add_handler(CommandHandler(["new", "start"], cmd_new))
     app.add_handler(CommandHandler("model", cmd_model))
     app.add_handler(CommandHandler("credit", cmd_credit))
+    app.add_handler(CommandHandler("permissions", cmd_permissions))
     app.add_handler(CallbackQueryHandler(adapter.handle_callback_query))
     app.add_handler(MessageHandler(filters.ALL & ~filters.COMMAND, on_message))
     app.add_error_handler(on_error)

package/src/messengers/base.py

@@ -54,6 +54,18 @@ class ToolApprovalOutcome:
     scope: ScopeOption | None = None
 
 
+@dataclass
+class PermissionEntry:
+    kind: str
+    scope: str
+
+
+class PermissionListHandle(ABC):
+    @abstractmethod
+    async def send(self, conversation_ref: Any) -> Any:
+        raise NotImplementedError
+
+
 class PromptHandle(ABC):
     outcome: ToolApprovalOutcome | None = None
 
@@ -117,6 +129,10 @@ class MessengerAdapter(ABC):
     ) -> PromptHandle:
         raise NotImplementedError
 
+    @abstractmethod
+    def create_permission_list(self, on_revoke: Callable[[PermissionEntry], Awaitable[None]]) -> PermissionListHandle:
+        raise NotImplementedError
+
     @abstractmethod
     def create_question_prompt(
         self,

package/src/messengers/discord_adapter.py

@@ -12,6 +12,7 @@ from messengers.base import (
     IncomingAttachment,
     IncomingMessage,
     MessengerAdapter,
+    PermissionListHandle,
     PromptHandle,
     ScopeOption,
     ToolApprovalOutcome,
@@ -32,6 +33,58 @@ class _ErrorLoggingView(discord.ui.View):
             pass
 
 
+class _DiscordPermissionList(PermissionListHandle):
+    def __init__(self, on_revoke):
+        self.on_revoke = on_revoke
+        self.page = 0
+        self.message: discord.Message | None = None
+
+    def _build(self):
+        from services import permissions
+
+        entries = permissions.list_entries()
+        page_entries, self.page, total_pages = permissions.page_of(entries, self.page)
+        embed = discord.Embed(
+            title="🔐 Allowed Permissions",
+            description=permissions.render_body(page_entries, self.page, total_pages),
+            color=discord.Color.blurple(),
+        )
+        view = _ErrorLoggingView(timeout=None)
+
+        for entry in page_entries:
+            label = f"🗑️ {permissions.entry_label(entry)}"
+            button = discord.ui.Button(label=label[:80], style=discord.ButtonStyle.gray)
+
+            async def revoke_callback(interaction: discord.Interaction, entry=entry):
+                await self.on_revoke(entry)
+                await self._refresh(interaction)
+
+            button.callback = revoke_callback
+            view.add_item(button)
+
+        if total_pages > 1:
+            for label, delta in (("◀ Prev", -1), ("Next ▶", 1)):
+                nav = discord.ui.Button(label=label, style=discord.ButtonStyle.blurple)
+
+                async def nav_callback(interaction: discord.Interaction, delta=delta):
+                    self.page += delta
+                    await self._refresh(interaction)
+
+                nav.callback = nav_callback
+                view.add_item(nav)
+
+        return embed, view
+
+    async def _refresh(self, interaction: discord.Interaction) -> None:
+        embed, view = self._build()
+        await interaction.response.edit_message(embed=embed, view=view)
+
+    async def send(self, conversation_ref: discord.abc.Messageable) -> discord.Message:
+        embed, view = self._build()
+        self.message = await conversation_ref.send(embed=embed, view=view)
+        return self.message
+
+
 class _DiscordPromptHandle(PromptHandle):
     def __init__(self, embed: discord.Embed, view: discord.ui.View):
         self.embed = embed
@@ -215,6 +268,9 @@ class DiscordAdapter(MessengerAdapter):
 
         return handle
 
+    def create_permission_list(self, on_revoke) -> PermissionListHandle:
+        return _DiscordPermissionList(on_revoke)
+
     def create_question_prompt(
         self,
         answer_future: asyncio.Future,

package/src/messengers/slack_adapter.py

@@ -17,6 +17,7 @@ from messengers.base import (
     IncomingAttachment,
     IncomingMessage,
     MessengerAdapter,
+    PermissionListHandle,
     PromptHandle,
     ScopeOption,
     ToolApprovalOutcome,
@@ -85,6 +86,77 @@ class SlackMessageRef:
         self.ts = ts
 
 
+class _SlackPermissionList(PermissionListHandle):
+    def __init__(self, client: AsyncWebClient, callbacks: dict, on_revoke):
+        self.client = client
+        self._callbacks = callbacks
+        self.on_revoke = on_revoke
+        self.page = 0
+        self.list_id = uuid.uuid4().hex[:12]
+        self._keys: list[str] = []
+        self.channel: str | None = None
+        self.ts: str | None = None
+
+    def _build(self):
+        from services import permissions
+
+        for key in self._keys:
+            self._callbacks.pop(key, None)
+        self._keys = []
+
+        entries = permissions.list_entries()
+        page_entries, self.page, total_pages = permissions.page_of(entries, self.page)
+        body = permissions.render_body(page_entries, self.page, total_pages)
+        text = f"*🔐 Allowed Permissions*\n\n{body}"
+        blocks = [{"type": "section", "text": {"type": "mrkdwn", "text": text[:2990]}}]
+        elements = []
+
+        for i, entry in enumerate(page_entries):
+            key = f"{self.list_id}:revoke:{i}"
+            self._callbacks[key] = lambda b, c, entry=entry: self._revoke(entry)
+            self._keys.append(key)
+            label = f"🗑️ {permissions.entry_label(entry)}"
+            elements.append({"type": "button", "text": {"type": "plain_text", "text": label[:75]}, "action_id": key})
+
+        if total_pages > 1:
+            for label, delta in (("◀ Prev", -1), ("Next ▶", 1)):
+                key = f"{self.list_id}:page:{delta}"
+                self._callbacks[key] = lambda b, c, delta=delta: self._turn(delta)
+                self._keys.append(key)
+                elements.append({"type": "button", "text": {"type": "plain_text", "text": label}, "action_id": key})
+
+        # 25 is Slack's hard per-block limit on action elements.
+        for chunk_start in range(0, len(elements), 25):
+            blocks.append({"type": "actions", "elements": elements[chunk_start : chunk_start + 25]})
+
+        return text, blocks
+
+    async def _redraw(self) -> None:
+        text, blocks = self._build()
+        if self.channel and self.ts:
+            await self.client.chat_update(channel=self.channel, ts=self.ts, text=text, blocks=blocks)
+
+    async def _revoke(self, entry) -> None:
+        await self.on_revoke(entry)
+        await self._redraw()
+
+    async def _turn(self, delta: int) -> None:
+        self.page += delta
+        await self._redraw()
+
+    async def send(self, conversation_ref: SlackConversationRef) -> dict:
+        text, blocks = self._build()
+        resp = await self.client.chat_postMessage(
+            channel=conversation_ref.channel,
+            thread_ts=conversation_ref.api_thread_ts,
+            text=text,
+            blocks=blocks,
+        )
+        self.channel = resp["channel"]
+        self.ts = resp["ts"]
+        return resp
+
+
 class _SlackPromptHandle(PromptHandle):
     def __init__(
         self, client: AsyncWebClient, text: str, blocks: list[dict], cleanup: Callable[[], None] | None = None
@@ -358,6 +430,9 @@ class SlackAdapter(MessengerAdapter):
         )
         return handle
 
+    def create_permission_list(self, on_revoke) -> PermissionListHandle:
+        return _SlackPermissionList(self.client, self._callbacks, on_revoke)
+
     def create_question_prompt(
         self,
         answer_future: asyncio.Future,

package/src/messengers/telegram_adapter.py

@@ -19,6 +19,7 @@ from messengers.base import (
     IncomingAttachment,
     IncomingMessage,
     MessengerAdapter,
+    PermissionListHandle,
     PromptHandle,
     ScopeOption,
     ToolApprovalOutcome,
@@ -52,6 +53,63 @@ async def safe_query_edit(query, **kwargs) -> None:
         raise
 
 
+class _TelegramPermissionList(PermissionListHandle):
+    def __init__(self, bot, callbacks: dict, on_revoke):
+        self.bot = bot
+        self._callbacks = callbacks
+        self.on_revoke = on_revoke
+        self.page = 0
+        self.list_id = uuid.uuid4().hex[:12]
+        self._keys: list[str] = []
+
+    def _build(self):
+        from services import permissions
+
+        for key in self._keys:
+            self._callbacks.pop(key, None)
+        self._keys = []
+
+        entries = permissions.list_entries()
+        page_entries, self.page, total_pages = permissions.page_of(entries, self.page)
+        body = permissions.render_body(page_entries, self.page, total_pages)
+        text = f"<b>🔐 Allowed Permissions</b>\n\n{html.escape(body)}"
+        keyboard: list[list[InlineKeyboardButton]] = []
+
+        for i, entry in enumerate(page_entries):
+            key = f"{self.list_id}:revoke:{i}"
+            self._callbacks[key] = lambda query, entry=entry: self._revoke(entry, query)
+            self._keys.append(key)
+            keyboard.append([InlineKeyboardButton(f"🗑️ {permissions.entry_label(entry)}"[:64], callback_data=key)])
+
+        if total_pages > 1:
+            row = []
+            for label, delta in (("◀ Prev", -1), ("Next ▶", 1)):
+                key = f"{self.list_id}:page:{delta}"
+                self._callbacks[key] = lambda query, delta=delta: self._turn(delta, query)
+                self._keys.append(key)
+                row.append(InlineKeyboardButton(label, callback_data=key))
+            keyboard.append(row)
+
+        return text, InlineKeyboardMarkup(keyboard)
+
+    async def _redraw(self, query) -> None:
+        text, markup = self._build()
+        await query.answer()
+        await safe_query_edit(query, text=text, parse_mode="HTML", reply_markup=markup)
+
+    async def _revoke(self, entry, query) -> None:
+        await self.on_revoke(entry)
+        await self._redraw(query)
+
+    async def _turn(self, delta: int, query) -> None:
+        self.page += delta
+        await self._redraw(query)
+
+    async def send(self, conversation_ref: int) -> Message:
+        text, markup = self._build()
+        return await self.bot.send_message(chat_id=conversation_ref, text=text, reply_markup=markup, parse_mode="HTML")
+
+
 class _TelegramPromptHandle(PromptHandle):
     def __init__(self, bot, text: str, reply_markup, cleanup: Callable[[], None] | None = None):
         self.bot = bot
@@ -285,6 +343,9 @@ class TelegramAdapter(MessengerAdapter):
         )
         return handle
 
+    def create_permission_list(self, on_revoke) -> PermissionListHandle:
+        return _TelegramPermissionList(self.bot, self._callbacks, on_revoke)
+
     def create_question_prompt(
         self,
         answer_future: asyncio.Future,

package/src/services/permissions.py

@@ -0,0 +1,42 @@
+from config import session_manager
+from messengers.base import PermissionEntry
+
+# Discord allows 25 components per message; the rest is headroom for paging buttons.
+PAGE_SIZE = 20
+
+
+def list_entries() -> list[PermissionEntry]:
+    allowed = session_manager.persistent_allowed
+    return [
+        PermissionEntry(kind=kind, scope=scope) for kind in ("tools", "commands") for scope in allowed.get(kind) or []
+    ]
+
+
+def revoke(entry: PermissionEntry) -> bool:
+    bucket = session_manager.persistent_allowed.get(entry.kind) or []
+    if entry.scope not in bucket:
+        return False
+    bucket.remove(entry.scope)
+    session_manager.save_persistent()
+    return True
+
+
+def page_of(entries: list[PermissionEntry], page: int) -> tuple[list[PermissionEntry], int, int]:
+    total_pages = max(1, -(-len(entries) // PAGE_SIZE))
+    page = max(0, min(page, total_pages - 1))
+    start = page * PAGE_SIZE
+    return entries[start : start + PAGE_SIZE], page, total_pages
+
+
+def entry_label(entry: PermissionEntry) -> str:
+    suffix = " (tool)" if entry.kind == "tools" else ""
+    return f"{entry.scope}{suffix}"
+
+
+def render_body(entries: list[PermissionEntry], page: int, total_pages: int) -> str:
+    if not entries:
+        return "No permissions have been allowed yet."
+    lines = [f"• {entry_label(e)}" for e in entries]
+    if total_pages > 1:
+        lines.append(f"\nPage {page + 1} of {total_pages}")
+    return "\n".join(lines)