@nordbyte/nordrelay 0.6.0 → 0.8.0

package/dist/adapter-conformance.js

@@ -0,0 +1,61 @@
+import { listAgentAdapterDescriptors } from "./agent-adapter.js";
+import { agentFeatureStates } from "./agent-feature-matrix.js";
+import { listChannelDescriptors, } from "./channel-adapter.js";
+import { channelCatalogCommandNames, } from "./channel-command-core.js";
+export const CHANNEL_FEATURES = [
+    { key: "text", label: "Text", description: "Send and receive plain text prompts and replies." },
+    { key: "streaming-edits", label: "Streaming edits", description: "Update an in-flight answer instead of sending only a final message." },
+    { key: "typing", label: "Typing/status", description: "Show activity while an agent turn is still running." },
+    { key: "inline-buttons", label: "Buttons", description: "Expose interactive choices for sessions, queue items, updates, artifacts, and aborts." },
+    { key: "files", label: "Files", description: "Receive or send generic files." },
+    { key: "photos", label: "Photos", description: "Receive image inputs for multimodal-capable agents." },
+    { key: "voice", label: "Voice", description: "Receive audio and run transcription before prompting." },
+    { key: "topics", label: "Threads/topics", description: "Keep independent contexts per topic, thread, forum topic, or equivalent channel scope." },
+    { key: "webhooks", label: "Webhooks", description: "Support inbound HTTP webhook/event delivery where the platform provides it." },
+];
+export function channelFeatureStates(capabilities) {
+    const supported = new Set(capabilities);
+    return CHANNEL_FEATURES.map((feature) => ({
+        ...feature,
+        supported: supported.has(feature.key),
+    }));
+}
+export function buildAdapterConformanceMatrix(input = {}) {
+    const agents = input.agents ?? listAgentAdapterDescriptors();
+    const channels = input.channels ?? listChannelDescriptors();
+    return {
+        generatedAt: new Date().toISOString(),
+        agents: agents.map((adapter) => {
+            const features = agentFeatureStates(adapter.capabilities);
+            return {
+                id: adapter.id,
+                label: adapter.label,
+                status: adapter.status,
+                features,
+                supported: features.filter((feature) => feature.supported).map((feature) => feature.key),
+                unsupported: features.filter((feature) => !feature.supported).map((feature) => feature.key),
+                notes: adapter.notes,
+            };
+        }),
+        channels: channels.map((adapter) => {
+            const features = channelFeatureStates(adapter.capabilities);
+            return {
+                id: adapter.id,
+                label: adapter.label,
+                status: adapter.status,
+                enabled: adapter.enabled,
+                features,
+                supported: features.filter((feature) => feature.supported).map((feature) => feature.key),
+                unsupported: features.filter((feature) => !feature.supported).map((feature) => feature.key),
+                commands: commandNamesForChannel(adapter.id),
+                notes: adapter.notes,
+            };
+        }),
+    };
+}
+function commandNamesForChannel(id) {
+    if (id === "telegram" || id === "discord" || id === "slack") {
+        return channelCatalogCommandNames(id);
+    }
+    return [];
+}

package/dist/bot-preferences.js

@@ -117,6 +117,7 @@ function normalizePreferences(value) {
         voiceBackend: isVoiceBackendPreference(candidate.voiceBackend) ? candidate.voiceBackend : undefined,
         voiceLanguage: typeof candidate.voiceLanguage === "string" ? candidate.voiceLanguage : candidate.voiceLanguage === null ? null : undefined,
         voiceTranscribeOnly: typeof candidate.voiceTranscribeOnly === "boolean" ? candidate.voiceTranscribeOnly : undefined,
+        targetPeerId: typeof candidate.targetPeerId === "string" ? candidate.targetPeerId : candidate.targetPeerId === null ? null : undefined,
     });
 }
 function pruneEmptyPreferences(preferences) {

package/dist/bot.js

@@ -12,7 +12,9 @@ import { formatSessionLabel } from "./bot-ui.js";
 import { BotPreferencesStore, isQuietNow, } from "./bot-preferences.js";
 import { renderAgentUpdateJobAction } from "./channel-actions.js";
 import { ChannelCommandService } from "./channel-command-service.js";
+import { runChannelPeerPrompt } from "./channel-peer-prompt.js";
 import { deliverChannelAction } from "./channel-runtime.js";
+import { createChannelTurnLifecycle, createChannelTypingLoop } from "./channel-turn-lifecycle.js";
 import { agentLabel, agentReasoningLabel, agentReasoningOptions, } from "./agent.js";
 import { getExternalActivityForSession, getExternalSnapshotForSession, } from "./agent-activity.js";
 import { checkAuthStatus, clearAuthCache, startLogin as startCodexLogin, startLogout as startCodexLogout } from "./codex-auth.js";
@@ -24,6 +26,7 @@ import { escapeHTML } from "./format.js";
 import { PromptStore, toPromptEnvelope } from "./prompt-store.js";
 import { checkHermesAuthStatus, startHermesLogin, startHermesLogout } from "./hermes-auth.js";
 import { checkOpenClawAuthStatus } from "./openclaw-auth.js";
+import { RemoteRelayClient } from "./peer-client.js";
 import { checkPiAuthStatus } from "./pi-auth.js";
 import { configureRedaction, redactText } from "./redaction.js";
 import { canWriteWithLock, SessionLockStore } from "./session-locks.js";
@@ -984,6 +987,76 @@ export function createBot(config, registry) {
         ].join("\n");
         await safeReply(ctx, html, { fallbackText: plain, replyMarkup: keyboard });
     };
+    const remoteClient = new RemoteRelayClient();
+    const handleRemoteUserPrompt = async (ctx, contextKey, chatId, prompt) => {
+        const targetPeerId = preferencesStore.get(contextKey).targetPeerId ?? undefined;
+        const parsed = parseContextKey(contextKey);
+        const messageThreadId = parsed.messageThreadId;
+        return runChannelPeerPrompt({
+            targetPeerId,
+            contextKey,
+            prompt,
+            remoteClient,
+            editMinIntervalMs: config.telegramEditMinIntervalMs,
+            typingIntervalMs: TYPING_INTERVAL_MS,
+            sendTyping: () => sendChatActionSafe(ctx.api, chatId, "typing", messageThreadId),
+            sendResponse: async (text) => {
+                const message = await sendTextMessage(ctx.api, chatId, escapeHTML(text), {
+                    fallbackText: text,
+                    messageThreadId,
+                });
+                return message.message_id;
+            },
+            editResponse: (messageId, text) => safeEditMessage(bot, chatId, messageId, escapeHTML(text), {
+                fallbackText: text,
+            }),
+            sendTurnStart: (remotePrompt) => safeReply(ctx, `<b>Remote peer working on:</b>\n${escapeHTML(remotePrompt)}`, {
+                fallbackText: `Remote peer working on:\n${remotePrompt}`,
+            }),
+            sendToolStart: (toolName) => safeReply(ctx, `<b>Remote tool:</b> <code>${escapeHTML(toolName)}</code>`, {
+                fallbackText: `Remote tool: ${toolName}`,
+            }),
+            sendQueued: async (queueId) => {
+                const keyboard = queueId ? new InlineKeyboard().text("Cancel queued message", `peer_queue_cancel:${targetPeerId}:${queueId}`) : undefined;
+                await safeReply(ctx, escapeHTML(`Remote prompt queued${queueId ? `: ${queueId}` : ""}.`), {
+                    fallbackText: `Remote prompt queued${queueId ? `: ${queueId}` : ""}.`,
+                    replyMarkup: keyboard,
+                });
+            },
+            sendCompleted: () => safeReply(ctx, escapeHTML("Remote turn completed."), { fallbackText: "Remote turn completed." }),
+            sendFailure: (message) => safeReply(ctx, escapeHTML(`Remote peer failed: ${message}`), {
+                fallbackText: `Remote peer failed: ${message}`,
+            }),
+        });
+    };
+    bot.callbackQuery(/^peer_queue_cancel:([^:]+):([a-z0-9]+)$/, async (ctx) => {
+        const targetPeerId = ctx.match?.[1];
+        const queueId = ctx.match?.[2];
+        const contextKey = contextKeyFromCtx(ctx);
+        if (!targetPeerId || !queueId || !contextKey) {
+            await ctx.answerCallbackQuery();
+            return;
+        }
+        try {
+            await remoteClient.webProxy(targetPeerId, {
+                method: "POST",
+                path: "/api/queue",
+                body: { action: "cancel", id: queueId },
+                contextKey,
+            }, telegramActivityActor(ctx), contextKey);
+            await ctx.answerCallbackQuery({ text: `Cancelled remote queued prompt ${queueId}.` });
+            const chatId = ctx.chat?.id;
+            const messageId = ctx.callbackQuery.message?.message_id;
+            if (chatId && messageId) {
+                await safeEditMessage(bot, chatId, messageId, escapeHTML(`Cancelled remote queued prompt ${queueId}.`), {
+                    fallbackText: `Cancelled remote queued prompt ${queueId}.`,
+                });
+            }
+        }
+        catch (error) {
+            await ctx.answerCallbackQuery({ text: friendlyErrorText(error), show_alert: true });
+        }
+    });
     const handleUserPrompt = async (ctx, contextKey, chatId, session, prompt, options = {}) => {
         if (!canSendSystemMessagesToContext(contextKey)) {
             return;
@@ -995,6 +1068,9 @@ export function createBot(config, registry) {
             ...rawEnvelope,
             activityActor: rawEnvelope.activityActor ?? telegramActivityActor(ctx),
         };
+        if (!options.fromQueue && await handleRemoteUserPrompt(ctx, contextKey, chatId, envelope)) {
+            return;
+        }
         if (!options.fromQueue && await denyIfLocked(ctx, contextKey, session)) {
             return;
         }
@@ -1043,14 +1119,8 @@ export function createBot(config, registry) {
         }
         const busyState = getBusyState(contextKey);
         busyState.processing = true;
-        const progress = {
-            status: "running",
-            promptDescription: envelope.description,
-            startedAt: Date.now(),
-            updatedAt: Date.now(),
-            toolCounts: new Map(),
-            textCharacters: 0,
-        };
+        const turnLifecycle = createChannelTurnLifecycle(envelope.description);
+        const progress = turnLifecycle.progress;
         turnProgress.set(contextKey, progress);
         const abortKeyboard = new InlineKeyboard().text("⏹ Abort", `agent_abort:${contextKey}`);
         const toolVerbosity = config.toolVerbosity;
@@ -1072,12 +1142,13 @@ export function createBot(config, registry) {
         let promptStartedAt;
         const toolActivityNames = new Map();
         const toolActivityStartedAt = new Map();
-        const typingInterval = setInterval(() => {
-            void sendChatActionSafe(bot.api, chatId, "typing", messageThreadId).catch(() => { });
-        }, TYPING_INTERVAL_MS);
-        void sendChatActionSafe(bot.api, chatId, "typing", messageThreadId).catch(() => { });
+        const typingLoop = createChannelTypingLoop({
+            intervalMs: TYPING_INTERVAL_MS,
+            sendTyping: () => sendChatActionSafe(bot.api, chatId, "typing", messageThreadId),
+        });
+        typingLoop.start();
         const stopTyping = () => {
-            clearInterval(typingInterval);
+            typingLoop.stop();
         };
         const clearFlushTimer = () => {
             if (flushTimer) {
@@ -1228,6 +1299,7 @@ export function createBot(config, registry) {
                 return;
             }
             finalized = true;
+            turnLifecycle.recordCompleted();
             stopTyping();
             clearFlushTimer();
             if (responseMessagePromise) {
@@ -1256,8 +1328,7 @@ export function createBot(config, registry) {
         const callbacks = {
             onTextDelta: (delta) => {
                 accumulatedText += delta;
-                progress.textCharacters += delta.length;
-                progress.updatedAt = Date.now();
+                turnLifecycle.recordTextDelta(delta.length);
                 if (!responseMessageId) {
                     void ensureResponseMessage()
                         .then(() => {
@@ -1271,10 +1342,7 @@ export function createBot(config, registry) {
                 scheduleFlush();
             },
             onToolStart: (toolName, toolCallId) => {
-                progress.currentTool = toolName;
-                progress.lastTool = toolName;
-                progress.updatedAt = Date.now();
-                progress.toolCounts.set(toolName, (progress.toolCounts.get(toolName) ?? 0) + 1);
+                turnLifecycle.recordToolStart(toolName);
                 toolActivityNames.set(toolCallId, toolName);
                 toolActivityStartedAt.set(toolCallId, Date.now());
                 appendTelegramActivity(ctx, contextKey, session, {
@@ -1318,7 +1386,7 @@ export function createBot(config, registry) {
                 });
             },
             onToolUpdate: (toolCallId, partialResult) => {
-                progress.updatedAt = Date.now();
+                turnLifecycle.recordToolUpdate();
                 if (toolVerbosity === "none" || toolVerbosity === "summary") {
                     return;
                 }
@@ -1329,8 +1397,7 @@ export function createBot(config, registry) {
                 state.partialResult = appendWithCap(state.partialResult, partialResult, TOOL_OUTPUT_PREVIEW_LIMIT);
             },
             onToolEnd: (toolCallId, isError) => {
-                progress.currentTool = undefined;
-                progress.updatedAt = Date.now();
+                turnLifecycle.recordToolEnd();
                 const activityToolName = toolActivityNames.get(toolCallId) ?? "tool";
                 const activityStartedAt = toolActivityStartedAt.get(toolCallId);
                 appendTelegramActivity(ctx, contextKey, session, {
@@ -1375,7 +1442,7 @@ export function createBot(config, registry) {
                 });
             },
             onTodoUpdate: (items) => {
-                progress.updatedAt = Date.now();
+                turnLifecycle.touch();
                 if (toolVerbosity === "none") {
                     return;
                 }
@@ -1407,7 +1474,7 @@ export function createBot(config, registry) {
             },
             onTurnComplete: (usage) => {
                 lastTurnUsage = usage;
-                progress.updatedAt = Date.now();
+                turnLifecycle.touch();
             },
             onAgentEnd: () => {
                 void finalizeResponse().catch((error) => {
@@ -1522,9 +1589,7 @@ export function createBot(config, registry) {
                     await pruneArtifacts(session.getInfo().workspace);
                 }
             }
-            progress.status = "completed";
-            progress.completedAt = Date.now();
-            progress.updatedAt = progress.completedAt;
+            turnLifecycle.recordCompleted();
             auditContext(ctx, contextKey, session, {
                 action: "prompt_completed",
                 status: "ok",
@@ -1539,8 +1604,7 @@ export function createBot(config, registry) {
             });
         }
         catch (error) {
-            progress.status = "failed";
-            progress.error = friendlyErrorText(error);
+            turnLifecycle.recordFailed(friendlyErrorText(error));
             auditContext(ctx, contextKey, session, {
                 action: "prompt_failed",
                 status: "failed",
@@ -1557,8 +1621,6 @@ export function createBot(config, registry) {
                     durationMs: Date.now() - promptStartedAt,
                 });
             }
-            progress.completedAt = Date.now();
-            progress.updatedAt = progress.completedAt;
             stopTyping();
             clearFlushTimer();
             if (responseMessagePromise) {
@@ -1887,6 +1949,7 @@ export function createBot(config, registry) {
         isTopicContext,
         replyChannelAction,
         commandService,
+        preferencesStore,
     });
     registerTelegramAgentCommands({
         bot,
@@ -1914,14 +1977,9 @@ export function createBot(config, registry) {
     registerTelegramPreferenceCommands({
         bot,
         config,
+        commandService,
         preferencesStore,
         getContextSession,
-        getEffectiveMirrorMode,
-        getEffectiveNotifyMode,
-        getEffectiveQuietHours,
-        getEffectiveVoiceBackend,
-        getEffectiveVoiceLanguage,
-        isVoiceTranscribeOnly,
     });
     registerTelegramDiagnosticsCommands({
         bot,

package/dist/channel-adapter.js

@@ -19,6 +19,17 @@ const DISCORD_CAPABILITIES = [
     "voice",
     "topics",
 ];
+const SLACK_CAPABILITIES = [
+    "text",
+    "streaming-edits",
+    "typing",
+    "inline-buttons",
+    "files",
+    "photos",
+    "voice",
+    "topics",
+    "webhooks",
+];
 const PLANNED_CHANNELS = [
     {
         id: "whatsapp",
@@ -27,12 +38,6 @@ const PLANNED_CHANNELS = [
         status: "planned",
         notes: "Requires a WhatsApp Business provider integration.",
     },
-    {
-        id: "slack",
-        label: "Slack",
-        capabilities: ["text", "streaming-edits", "typing", "inline-buttons", "files"],
-        status: "planned",
-    },
     {
         id: "matrix",
         label: "Matrix",
@@ -45,7 +50,8 @@ export class TelegramChannelAdapter {
     label = "Telegram";
     capabilities = new Set(TELEGRAM_CAPABILITIES);
     describe() {
-        const enabled = process.env.TELEGRAM_ENABLED !== "false";
+        const requested = process.env.TELEGRAM_ENABLED !== "false";
+        const enabled = requested && Boolean(process.env.TELEGRAM_BOT_TOKEN);
         return {
             id: this.id,
             label: this.label,
@@ -53,8 +59,10 @@ export class TelegramChannelAdapter {
             status: "available",
             enabled,
             notes: enabled
-                ? "Telegram bot runtime is enabled by default."
-                : "Telegram bot runtime is disabled.",
+                ? "Telegram bot runtime is enabled."
+                : requested
+                    ? "Telegram bot runtime is disabled because TELEGRAM_BOT_TOKEN is missing."
+                    : "Telegram bot runtime is disabled.",
         };
     }
 }
@@ -63,7 +71,8 @@ export class DiscordChannelAdapter {
     label = "Discord";
     capabilities = new Set(DISCORD_CAPABILITIES);
     describe() {
-        const enabled = process.env.DISCORD_ENABLED === "true";
+        const requested = process.env.DISCORD_ENABLED === "true";
+        const enabled = requested && Boolean(process.env.DISCORD_BOT_TOKEN);
         return {
             id: this.id,
             label: this.label,
@@ -72,7 +81,30 @@ export class DiscordChannelAdapter {
             enabled,
             notes: enabled
                 ? "Discord bot runtime is enabled."
-                : "Enable with DISCORD_ENABLED=true and DISCORD_BOT_TOKEN.",
+                : requested
+                    ? "Discord bot runtime is disabled because DISCORD_BOT_TOKEN is missing."
+                    : "Enable with DISCORD_ENABLED=true and DISCORD_BOT_TOKEN.",
+        };
+    }
+}
+export class SlackChannelAdapter {
+    id = "slack";
+    label = "Slack";
+    capabilities = new Set(SLACK_CAPABILITIES);
+    describe() {
+        const requested = process.env.SLACK_ENABLED === "true";
+        const enabled = requested && Boolean(process.env.SLACK_BOT_TOKEN) && Boolean(process.env.SLACK_APP_TOKEN);
+        return {
+            id: this.id,
+            label: this.label,
+            capabilities: [...this.capabilities],
+            status: "available",
+            enabled,
+            notes: enabled
+                ? "Slack bot runtime is enabled."
+                : requested
+                    ? "Slack bot runtime is disabled because SLACK_BOT_TOKEN or SLACK_APP_TOKEN is missing."
+                    : "Enable with SLACK_ENABLED=true, SLACK_BOT_TOKEN, and SLACK_APP_TOKEN.",
         };
     }
 }
@@ -80,6 +112,7 @@ export function listChannelDescriptors() {
     return [
         new TelegramChannelAdapter().describe(),
         new DiscordChannelAdapter().describe(),
+        new SlackChannelAdapter().describe(),
         ...PLANNED_CHANNELS,
     ];
 }

package/dist/channel-command-catalog.js

@@ -0,0 +1,94 @@
+const textOption = (name = "value", description = "Value", required = false) => ({
+    type: 3,
+    name,
+    description,
+    required,
+});
+export const CHANNEL_COMMANDS = [
+    { name: "start", description: "Welcome and status", discordDescription: "Start or inspect the current NordRelay context" },
+    { name: "help", description: "Command reference", discordDescription: "Show Discord adapter help" },
+    { name: "prompt", description: "Send a prompt to the selected agent", telegram: false, discordOptions: [textOption("text", "Prompt text", true)] },
+    { name: "link", description: "Link account to NordRelay user", telegramDescription: "Link Telegram to NordRelay user", discordDescription: "Link this Discord account with a NordRelay code", discordOptions: [textOption("value", "Link code", true)] },
+    { name: "whoami", description: "Show your NordRelay user", discordDescription: "Show linked NordRelay user" },
+    { name: "register_chat", description: "Admin: enable this group chat", discord: false },
+    { name: "register_channel", description: "Enable this Discord channel for NordRelay", telegram: false },
+    { name: "channels", description: "Messaging adapter status", discordDescription: "Show channel adapters" },
+    { name: "peers", description: "NordRelay peer status", discordDescription: "Show paired NordRelay instances" },
+    { name: "target", description: "Select local or peer target", discordDescription: "Select local or peer target", discordOptions: [textOption("value", "local or peer id")] },
+    { name: "agents", description: "Agent adapter status", discordDescription: "Show agent adapters" },
+    { name: "agent", description: "Select agent", discordDescription: "Select or show the active agent", discordOptions: [textOption("value", "Agent id")] },
+    { name: "new", description: "Start a new thread", discordDescription: "Create a new session", discordOptions: [textOption("value", "Workspace path")] },
+    { name: "session", description: "Current thread details", discordDescription: "Show the active session" },
+    { name: "sessions", description: "Browse and switch threads", discordDescription: "Browse recent sessions", discordOptions: [textOption("query", "Search query")] },
+    { name: "switch", description: "Switch to a thread by ID", discordDescription: "Switch to a session", discordOptions: [textOption("thread_id", "Thread id", true)] },
+    { name: "attach", description: "Bind a session to this topic", discordDescription: "Attach a session", discordOptions: [textOption("thread_id", "Thread id", true)] },
+    { name: "handback", description: "Hand session back to CLI", discordDescription: "Hand the active session back to the native CLI" },
+    { name: "sync", description: "Sync active session from CLI state", discordDescription: "Sync from local agent state" },
+    { name: "pinned", description: "Show pinned threads" },
+    { name: "pin", description: "Pin current or given thread", discordOptions: [textOption("value", "Thread id")] },
+    { name: "unpin", description: "Unpin current or given thread", discordOptions: [textOption("value", "Thread id")] },
+    { name: "retry", description: "Resend the last prompt", discordDescription: "Retry the last prompt" },
+    { name: "queue", description: "Show queued prompts", discordDescription: "Show or manage queue", discordOptions: [textOption("action", "pause/resume/clear/run/cancel/top/up/down"), textOption("id", "Queue id")] },
+    { name: "cancel", description: "Cancel a queued prompt", discordOptions: [textOption("value", "Queue id", true)] },
+    { name: "clearqueue", description: "Clear queued prompts", discordDescription: "Clear queue" },
+    { name: "artifacts", description: "List or resend generated files", discordDescription: "List or send artifacts", discordOptions: [textOption("value", "zip <turn-id>")] },
+    { name: "workspaces", description: "List allowed workspaces" },
+    { name: "abort", description: "Cancel current operation", discordDescription: "Abort the active task" },
+    { name: "stop", description: "Cancel current operation", discordDescription: "Abort the active task" },
+    { name: "launch", description: "Select launch profile", discordOptions: [textOption("value", "Launch profile id")] },
+    { name: "launch_profiles", description: "Select launch profile", discordOptions: [textOption("value", "Launch profile id")] },
+    { name: "fast", description: "Toggle fast mode", discordOptions: [textOption("value", "on/off")] },
+    { name: "model", description: "View and change model", discordDescription: "Select or show models", discordOptions: [textOption("value", "Model id")] },
+    { name: "effort", description: "Set reasoning effort", discordDescription: "Select reasoning effort", discordOptions: [textOption("value", "Reasoning value")] },
+    { name: "reasoning", description: "Set reasoning effort", discordDescription: "Select reasoning effort", discordOptions: [textOption("value", "Reasoning value")] },
+    { name: "mirror", description: "Control CLI mirroring", discordDescription: "Set mirror mode", discordOptions: [textOption("value", "off/status/final/full")] },
+    { name: "notify", description: "Control notifications", discordDescription: "Set notification mode", discordOptions: [textOption("value", "off/minimal/all")] },
+    { name: "auth", description: "Check auth status", discordDescription: "Show selected agent auth status" },
+    { name: "login", description: "Start authentication", discordDescription: "Start selected agent login" },
+    { name: "logout", description: "Sign out", discordDescription: "Sign out of the selected agent" },
+    { name: "voice", description: "Voice transcription status", discordDescription: "Show or change voice settings", discordOptions: [textOption("value", "transcribe-only on/off")] },
+    { name: "tasks", description: "Current turn progress", discordDescription: "Show recent tasks", discordOptions: [textOption("value", "Limit")] },
+    { name: "progress", description: "Current turn progress", discordDescription: "Show current turn progress" },
+    { name: "activity", description: "Thread activity timeline", discordDescription: "Show recent activity", discordOptions: [textOption("value", "Limit")] },
+    { name: "audit", description: "Admin: recent audit events", discordDescription: "Show recent audit events", discordOptions: [textOption("value", "Limit")] },
+    { name: "status", description: "Connector runtime status", discordDescription: "Show status" },
+    { name: "health", description: "Connector health report", discordDescription: "Show health" },
+    { name: "version", description: "Connector version", discordDescription: "Show versions" },
+    { name: "logs", description: "Admin: show connector logs", discordDescription: "Show logs", discordOptions: [textOption("value", "Target and line count")] },
+    { name: "diagnostics", description: "Admin: connector diagnostics", discordDescription: "Show diagnostics" },
+    { name: "support", description: "Admin: export diagnostics bundle", discordDescription: "Show support diagnostics" },
+    { name: "lock", description: "Lock session writes to you", discordDescription: "Lock this context" },
+    { name: "unlock", description: "Release session write lock", discordDescription: "Unlock this context" },
+    { name: "locks", description: "List session write locks", discordDescription: "List locks" },
+    { name: "restart", description: "Admin: restart connector", discordDescription: "Restart NordRelay" },
+    { name: "update", description: "Admin: update connector or agents", discordDescription: "Update NordRelay or agents", discordOptions: [textOption("target", "jobs, install, log, cancel, input, or agent id"), textOption("agent", "Agent id or job id"), textOption("input", "Text for update input")] },
+];
+export function telegramCommandCatalog() {
+    return CHANNEL_COMMANDS
+        .filter((entry) => entry.telegram !== false)
+        .map((entry) => ({
+        command: entry.name,
+        description: entry.telegramDescription ?? entry.description,
+    }));
+}
+export function discordCommandCatalog() {
+    return CHANNEL_COMMANDS
+        .filter((entry) => entry.discord !== false)
+        .map((entry) => ({
+        name: entry.name,
+        description: entry.discordDescription ?? entry.description,
+        options: entry.discordOptions ?? [],
+    }));
+}
+export function discordHelpCommandList() {
+    return discordCommandCatalog()
+        .filter((entry) => !["start", "help", "prompt"].includes(entry.name))
+        .map((entry) => `/${entry.name}`)
+        .join(", ");
+}
+export function slackHelpCommandList() {
+    return CHANNEL_COMMANDS
+        .filter((entry) => entry.slack !== false && !["start", "help", "prompt"].includes(entry.name))
+        .map((entry) => `/${entry.name}`)
+        .join(", ");
+}

package/dist/channel-command-core.js

@@ -0,0 +1,60 @@
+import { CHANNEL_COMMANDS } from "./channel-command-catalog.js";
+import { normalizeChannelCommandName } from "./channel-runtime.js";
+export function createSharedChannelCommandDispatcher(input) {
+    const handlers = new Map();
+    for (const binding of input.bindings) {
+        for (const name of binding.names) {
+            const normalized = normalizeChannelCommandName(name);
+            if (!normalized) {
+                throw new Error("Channel command name is required.");
+            }
+            if (handlers.has(normalized)) {
+                throw new Error(`Duplicate ${input.transport} command binding: ${normalized}`);
+            }
+            handlers.set(normalized, binding.handler);
+        }
+    }
+    return {
+        transport: input.transport,
+        commandNames: [...handlers.keys()].sort(),
+        async dispatch(request, command, argument) {
+            const normalized = normalizeChannelCommandName(command);
+            const handler = handlers.get(normalized);
+            if (!handler) {
+                return { matched: false, command: normalized };
+            }
+            await handler(request, argument, normalized);
+            return { matched: true, command: normalized };
+        },
+    };
+}
+export function channelCatalogCommandNames(transport) {
+    return CHANNEL_COMMANDS
+        .filter((entry) => {
+        if (transport === "telegram")
+            return entry.telegram !== false;
+        if (transport === "discord")
+            return entry.discord !== false;
+        return entry.slack !== false;
+    })
+        .map((entry) => normalizeChannelCommandName(entry.name))
+        .sort();
+}
+export function channelCommandCoverage(input) {
+    const advertised = new Set(channelCatalogCommandNames(input.transport));
+    const implemented = new Set([...input.implemented].map(normalizeChannelCommandName));
+    for (const [canonical, aliases] of Object.entries(input.aliases ?? {})) {
+        if (!implemented.has(normalizeChannelCommandName(canonical)))
+            continue;
+        for (const alias of aliases) {
+            implemented.add(normalizeChannelCommandName(alias));
+        }
+    }
+    const aliasNames = new Set(Object.values(input.aliases ?? {}).flat().map(normalizeChannelCommandName));
+    return {
+        advertised: [...advertised].sort(),
+        implemented: [...implemented].sort(),
+        missing: [...advertised].filter((name) => !implemented.has(name)).sort(),
+        extra: [...implemented].filter((name) => !advertised.has(name) && !aliasNames.has(name)).sort(),
+    };
+}