@iletai/nzb 1.4.7 → 1.4.9

package/dist/config.js

@@ -30,7 +30,7 @@ if (parsedUserId !== undefined && (Number.isNaN(parsedUserId) || parsedUserId <=
 if (Number.isNaN(parsedPort) || parsedPort < 1 || parsedPort > 65535) {
     throw new Error(`API_PORT must be 1-65535, got: "${raw.API_PORT}"`);
 }
-const DEFAULT_WORKER_TIMEOUT_MS = 600_000; // 10 minutes
+const DEFAULT_WORKER_TIMEOUT_MS = 1_200_000; // 20 minutes
 const parsedWorkerTimeout = raw.WORKER_TIMEOUT ? Number(raw.WORKER_TIMEOUT) : DEFAULT_WORKER_TIMEOUT_MS;
 if (!Number.isInteger(parsedWorkerTimeout) || parsedWorkerTimeout <= 0) {
     throw new Error(`WORKER_TIMEOUT must be a positive integer (ms), got: "${raw.WORKER_TIMEOUT}"`);

package/dist/store/db.js

@@ -164,6 +164,14 @@ export function setConversationTelegramMsgId(rowId, telegramMsgId) {
     const db = getDb();
     db.prepare(`UPDATE conversation_log SET telegram_msg_id = ? WHERE id = ?`).run(telegramMsgId, rowId);
 }
+/** Look up conversation content by Telegram message ID. Returns the message content or undefined. */
+export function getConversationByTelegramMsgId(telegramMsgId) {
+    const db = getDb();
+    const row = db
+        .prepare(`SELECT content FROM conversation_log WHERE telegram_msg_id = ? LIMIT 1`)
+        .get(telegramMsgId);
+    return row?.content;
+}
 /** Get recent conversation history formatted for injection into system message. */
 export function getRecentConversation(limit = 20) {
     const db = getDb();

package/dist/telegram/bot.js

@@ -10,7 +10,10 @@ import { searchMemories } from "../store/db.js";
 import { chunkMessage, escapeHtml, formatToolSummaryExpandable, toTelegramHTML } from "./formatter.js";
 import { registerCallbackHandlers } from "./handlers/callbacks.js";
 import { sendFormattedReply } from "./handlers/helpers.js";
+import { registerInlineQueryHandler } from "./handlers/inline.js";
 import { registerMediaHandlers } from "./handlers/media.js";
+import { getReactionHelpText, registerReactionHandlers } from "./handlers/reactions.js";
+import { createSmartSuggestionsWithContext, registerSmartSuggestionHandlers } from "./handlers/suggestions.js";
 import { initLogChannel, logDebug, logError, logInfo } from "./log-channel.js";
 let bot;
 const startedAt = Date.now();
@@ -160,6 +163,12 @@ export function createBot() {
     bot.use(mainMenu);
     // Register callback + media handlers from extracted modules
     registerCallbackHandlers(bot);
+    // 🚀 Breakthrough: Inline Query Mode — @bot in any chat
+    registerInlineQueryHandler(bot);
+    // 🚀 Breakthrough: Smart Suggestion button callbacks
+    registerSmartSuggestionHandlers(bot);
+    // 🚀 Breakthrough: Reaction-based AI actions
+    registerReactionHandlers(bot);
     // Persistent reply keyboard — quick actions always visible below chat input
     const replyKeyboard = new Keyboard()
         .text("📊 Status")
@@ -186,7 +195,12 @@ export function createBot() {
         "/status — Show system status\n" +
         "/settings — Bot settings\n" +
         "/restart — Restart NZB\n" +
-        "/help — Show this help", { reply_markup: mainMenu }));
+        "/help — Show this help\n\n" +
+        "⚡ Breakthrough Features:\n" +
+        "• @bot query — Use me inline in any chat!\n" +
+        "• React to any message to trigger AI:\n" +
+        getReactionHelpText() + "\n" +
+        "• Smart suggestions appear after each response", { reply_markup: mainMenu }));
     bot.command("cancel", async (ctx) => {
         const cancelled = await cancelCurrentMessage();
         await ctx.reply(cancelled ? "Cancelled." : "Nothing to cancel.");
@@ -526,10 +540,15 @@ export function createBot() {
                     }
                     const chunks = chunkMessage(fullFormatted);
                     const fallbackChunks = chunkMessage(textWithMeta);
+                    // 🚀 Breakthrough: Build smart suggestion buttons based on response content
+                    const smartKb = createSmartSuggestionsWithContext(text, ctx.message.text, 4);
                     // Single chunk: edit placeholder in place
                     if (placeholderMsgId && chunks.length === 1) {
                         try {
-                            await bot.api.editMessageText(chatId, placeholderMsgId, chunks[0], { parse_mode: "HTML" });
+                            await bot.api.editMessageText(chatId, placeholderMsgId, chunks[0], {
+                                parse_mode: "HTML",
+                                reply_markup: smartKb,
+                            });
                             try {
                                 await bot.api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
                             }
@@ -545,7 +564,9 @@ export function createBot() {
                         }
                         catch {
                             try {
-                                await bot.api.editMessageText(chatId, placeholderMsgId, fallbackChunks[0]);
+                                await bot.api.editMessageText(chatId, placeholderMsgId, fallbackChunks[0], {
+                                    reply_markup: smartKb,
+                                });
                                 try {
                                     await bot.api.setMessageReaction(chatId, userMessageId, [{ type: "emoji", emoji: "👍" }]);
                                 }
@@ -569,14 +590,21 @@ export function createBot() {
                     let firstSentMsgId;
                     const sendChunk = async (chunk, fallback, index) => {
                         const isFirst = index === 0 && !placeholderMsgId;
+                        const isLast = index === totalChunks - 1;
                         // Pagination header for multi-chunk messages
                         const pageTag = totalChunks > 1 ? `📄 ${index + 1}/${totalChunks}\n` : "";
-                        const opts = isFirst
-                            ? { parse_mode: "HTML", reply_parameters: replyParams }
-                            : { parse_mode: "HTML" };
+                        const opts = {
+                            parse_mode: "HTML",
+                            ...(isFirst ? { reply_parameters: replyParams } : {}),
+                            ...(isLast && smartKb ? { reply_markup: smartKb } : {}),
+                        };
+                        const fallbackOpts = {
+                            ...(isFirst ? { reply_parameters: replyParams } : {}),
+                            ...(isLast && smartKb ? { reply_markup: smartKb } : {}),
+                        };
                         const sent = await ctx
                             .reply(pageTag + chunk, opts)
-                            .catch(() => ctx.reply(pageTag + fallback, isFirst ? { reply_parameters: replyParams } : {}));
+                            .catch(() => ctx.reply(pageTag + fallback, fallbackOpts));
                         if (index === 0 && sent)
                             firstSentMsgId = sent.message_id;
                     };
@@ -689,6 +717,14 @@ export async function startBot() {
     }
     bot
         .start({
+        allowed_updates: [
+            "message",
+            "edited_message",
+            "callback_query",
+            "inline_query",
+            "message_reaction",
+            "my_chat_member",
+        ],
         onStart: () => {
             console.log("[nzb] Telegram bot connected");
             void logInfo(`🚀 NZB v${process.env.npm_package_version || "?"} started (model: ${config.copilotModel})`);

package/dist/telegram/handlers/inline.js

@@ -0,0 +1,83 @@
+import { InlineKeyboard, InlineQueryResultBuilder } from "grammy";
+import { sendToOrchestrator } from "../../copilot/orchestrator.js";
+import { escapeHtml } from "../formatter.js";
+/**
+ * Register inline query handler — allows users to @mention the bot in ANY chat
+ * and get AI-generated responses as inline results.
+ *
+ * Uses grammY's InlineQueryResultBuilder for type-safe result construction.
+ */
+export function registerInlineQueryHandler(bot) {
+    bot.on("inline_query", async (ctx) => {
+        const query = ctx.inlineQuery.query.trim();
+        // Empty query → show usage hint
+        if (!query) {
+            const helpResult = InlineQueryResultBuilder.article("help", "💡 Type your question…", {
+                description: "Ask me anything — I'll respond with AI-powered answers",
+            }).text("💡 <b>NZB AI Assistant</b>\n\nType <code>@bot your question</code> in any chat to get instant AI answers.", { parse_mode: "HTML" });
+            await ctx.answerInlineQuery([helpResult], { cache_time: 10 });
+            return;
+        }
+        // Short query → wait for more input
+        if (query.length < 3) {
+            await ctx.answerInlineQuery([], { cache_time: 5 });
+            return;
+        }
+        // Generate AI response for the inline query — non-blocking with timeout
+        const responsePromise = new Promise((resolve) => {
+            const timeout = setTimeout(() => resolve(""), 8000);
+            sendToOrchestrator(`[inline query — respond concisely in 2-3 sentences max] ${query}`, { type: "background" }, (text, done) => {
+                if (done) {
+                    clearTimeout(timeout);
+                    resolve(text);
+                }
+            });
+        });
+        const aiResponse = await responsePromise;
+        const results = [];
+        // AI answer (if we got one in time)
+        if (aiResponse && !aiResponse.startsWith("Error:")) {
+            const preview = aiResponse.length > 200 ? aiResponse.slice(0, 200) + "…" : aiResponse;
+            const fullText = aiResponse.length > 4000 ? aiResponse.slice(0, 4000) + "\n\n⋯ (truncated)" : aiResponse;
+            const moreDetailKb = new InlineKeyboard().text("🔄 More detail", `inline_detail:${query.slice(0, 50)}`);
+            results.push(InlineQueryResultBuilder.article(`ai-${Date.now()}`, "🤖 AI Answer", {
+                description: preview.replace(/\n/g, " "),
+                reply_markup: moreDetailKb,
+            }).text(`🤖 <b>NZB AI:</b>\n\n${escapeHtml(fullText)}`, { parse_mode: "HTML" }));
+        }
+        // Quick action templates — always available
+        results.push(InlineQueryResultBuilder.article(`ask-${Date.now()}`, `❓ Ask NZB: "${query.slice(0, 50)}"`, {
+            description: "Send this question to NZB for a detailed answer",
+        }).text(`❓ <b>Question for NZB:</b>\n\n${escapeHtml(query)}`, { parse_mode: "HTML" }), InlineQueryResultBuilder.article(`code-${Date.now()}`, `💻 Code: "${query.slice(0, 50)}"`, {
+            description: "Generate code for this request",
+        }).text(`💻 <b>Code Request:</b>\n\n<code>${escapeHtml(query)}</code>`, { parse_mode: "HTML" }), InlineQueryResultBuilder.article(`explain-${Date.now()}`, `📖 Explain: "${query.slice(0, 50)}"`, {
+            description: "Get a detailed explanation",
+        }).text(`📖 <b>Explanation Request:</b>\n\n${escapeHtml(query)}`, { parse_mode: "HTML" }));
+        await ctx.answerInlineQuery(results.slice(0, 50), {
+            cache_time: 30,
+            is_personal: true,
+        });
+    });
+    // Handle "More detail" button from inline results
+    bot.callbackQuery(/^inline_detail:(.+)$/, async (ctx) => {
+        const query = ctx.match[1];
+        await ctx.answerCallbackQuery({ text: "Generating detailed response…" });
+        sendToOrchestrator(`[Give a comprehensive, detailed answer] ${query}`, { type: "background" }, async (text, done) => {
+            if (done && !text.startsWith("Error:")) {
+                try {
+                    const chatId = ctx.chat?.id;
+                    if (chatId) {
+                        const truncated = text.length > 4000 ? text.slice(0, 4000) + "\n\n⋯" : text;
+                        await bot.api.sendMessage(chatId, `🔍 <b>Detailed Answer:</b>\n\n${escapeHtml(truncated)}`, {
+                            parse_mode: "HTML",
+                        });
+                    }
+                }
+                catch {
+                    // Can't send to inline result chats we're not in
+                }
+            }
+        });
+    });
+}
+//# sourceMappingURL=inline.js.map

package/dist/telegram/handlers/reactions.js

@@ -0,0 +1,97 @@
+import { sendToOrchestrator } from "../../copilot/orchestrator.js";
+import { logDebug, logInfo } from "../log-channel.js";
+import { sendFormattedReply } from "./helpers.js";
+const REACTION_ACTIONS = [
+    {
+        emoji: "🤔",
+        prompt: (text) => `Explain and analyze the following message in detail. Be thorough but concise:\n\n"${text}"`,
+        label: "Explaining",
+        ackEmoji: "👀",
+    },
+    {
+        emoji: "✍",
+        prompt: (text) => `Rewrite and improve the following text for clarity, grammar, and impact. Provide the improved version only:\n\n"${text}"`,
+        label: "Rewriting",
+        ackEmoji: "✍",
+    },
+    {
+        emoji: "👀",
+        prompt: (text) => `Translate the following text. If it's in English, translate to Vietnamese. If it's in any other language, translate to English. Provide only the translation:\n\n"${text}"`,
+        label: "Translating",
+        ackEmoji: "👀",
+    },
+    {
+        emoji: "🤓",
+        prompt: (text) => `Summarize the following message in 2-3 concise bullet points:\n\n"${text}"`,
+        label: "Summarizing",
+        ackEmoji: "🤓",
+    },
+    {
+        emoji: "👨‍💻",
+        prompt: (text) => `Analyze this code for bugs, issues, and potential improvements. Be specific about what's wrong and how to fix it:\n\n\`\`\`\n${text}\n\`\`\``,
+        label: "Debugging",
+        ackEmoji: "👨‍💻",
+    },
+    {
+        emoji: "🤩",
+        prompt: (text) => `Suggest improvements and alternatives for the following. Be creative and practical:\n\n"${text}"`,
+        label: "Suggesting",
+        ackEmoji: "🤩",
+    },
+    {
+        emoji: "⚡",
+        prompt: (text) => `Extract the key points and action items from the following message. Format as a numbered list:\n\n"${text}"`,
+        label: "Extracting",
+        ackEmoji: "⚡",
+    },
+];
+// Build a lookup map for O(1) access
+const REACTION_MAP = new Map(REACTION_ACTIONS.map((a) => [a.emoji, a]));
+export function registerReactionHandlers(bot) {
+    // Use grammY's ctx.reactions() for cleaner reaction diff handling
+    bot.on("message_reaction", async (ctx) => {
+        const { emojiAdded } = ctx.reactions();
+        if (emojiAdded.length === 0)
+            return;
+        // Find the first emoji that matches our action map
+        const matchedEmoji = emojiAdded.find((e) => REACTION_MAP.has(e));
+        if (!matchedEmoji)
+            return;
+        const action = REACTION_MAP.get(matchedEmoji);
+        const chatId = ctx.messageReaction.chat.id;
+        const messageId = ctx.messageReaction.message_id;
+        void logInfo(`⚡ Reaction action: ${action.emoji} ${action.label} on message ${messageId}`);
+        try {
+            await bot.api.sendChatAction(chatId, "typing");
+        }
+        catch {
+            /* best-effort */
+        }
+        try {
+            const { getConversationByTelegramMsgId } = await import("../../store/db.js");
+            const msgContent = getConversationByTelegramMsgId(messageId);
+            if (msgContent) {
+                void logDebug(`📋 Found message content for reaction: ${msgContent.slice(0, 80)}`);
+                const prompt = action.prompt(msgContent);
+                sendToOrchestrator(prompt, { type: "telegram", chatId, messageId }, (text, done) => {
+                    if (done) {
+                        void sendFormattedReply(bot, chatId, `${action.emoji} <b>${action.label}:</b>\n\n${text}`, {
+                            replyTo: messageId,
+                        });
+                    }
+                });
+            }
+            else {
+                await bot.api.sendMessage(chatId, `${action.emoji} I can see your reaction, but I need the message text. Reply to the message and I'll ${action.label.toLowerCase()} it for you.`, { reply_parameters: { message_id: messageId } });
+            }
+        }
+        catch (err) {
+            void logDebug(`Reaction handler error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+}
+/** Get the list of supported reaction actions for help text. */
+export function getReactionHelpText() {
+    return REACTION_ACTIONS.map((a) => `${a.emoji} — ${a.label}`).join("\n");
+}
+//# sourceMappingURL=reactions.js.map

package/dist/telegram/handlers/suggestions.js

@@ -0,0 +1,156 @@
+import { InlineKeyboard } from "grammy";
+import { sendToOrchestrator } from "../../copilot/orchestrator.js";
+import { sendFormattedReply } from "./helpers.js";
+const SUGGESTION_RULES = [
+    {
+        test: (resp) => /```[\s\S]*```/.test(resp),
+        label: "🧪 Test this code",
+        callbackPrefix: "smart_test",
+        promptTemplate: (_p, resp) => `Write comprehensive unit tests for the code you just provided. Include edge cases:\n\n${resp.slice(0, 2000)}`,
+    },
+    {
+        test: (resp) => /```[\s\S]*```/.test(resp),
+        label: "📖 Explain code",
+        callbackPrefix: "smart_explain_code",
+        promptTemplate: (_p, resp) => `Explain the code you just provided step by step, as if teaching a junior developer:\n\n${resp.slice(0, 2000)}`,
+    },
+    {
+        test: (resp) => /```[\s\S]*```/.test(resp),
+        label: "⚡ Optimize",
+        callbackPrefix: "smart_optimize",
+        promptTemplate: (_p, resp) => `Analyze the code you just provided for performance improvements and optimizations. Show the optimized version:\n\n${resp.slice(0, 2000)}`,
+    },
+    {
+        test: (resp) => /error|bug|issue|problem|fix|wrong/i.test(resp),
+        label: "🔧 Fix it",
+        callbackPrefix: "smart_fix",
+        promptTemplate: (p) => `Based on the error/issue you identified, provide the complete fix with corrected code. Original question: ${p.slice(0, 500)}`,
+    },
+    {
+        test: (resp) => /step|first|then|next|finally/i.test(resp) && resp.length > 500,
+        label: "📋 Checklist",
+        callbackPrefix: "smart_checklist",
+        promptTemplate: (_p, resp) => `Convert the steps you described into a clear, actionable checklist with checkboxes:\n\n${resp.slice(0, 2000)}`,
+    },
+    {
+        test: (_resp, prompt) => /how|what|why|explain|difference/i.test(prompt),
+        label: "🔬 Go deeper",
+        callbackPrefix: "smart_deeper",
+        promptTemplate: (p) => `Provide a much more detailed and in-depth explanation of: ${p.slice(0, 500)}. Include examples, edge cases, and advanced considerations.`,
+    },
+    {
+        test: (resp) => resp.length > 800,
+        label: "📝 TL;DR",
+        callbackPrefix: "smart_tldr",
+        promptTemplate: (_p, resp) => `Provide a very concise TL;DR summary (3-5 bullet points max) of your previous response:\n\n${resp.slice(0, 2000)}`,
+    },
+    {
+        test: (resp) => /alternative|option|approach|instead/i.test(resp) || resp.length > 500,
+        label: "🔀 Alternatives",
+        callbackPrefix: "smart_alt",
+        promptTemplate: (p) => `Suggest 3 alternative approaches or solutions for: ${p.slice(0, 500)}. Compare their pros and cons.`,
+    },
+    {
+        test: () => true, // Always available
+        label: "🔄 Continue",
+        callbackPrefix: "smart_continue",
+        promptTemplate: () => "Continue from where you left off. Provide more detail or the next steps.",
+    },
+];
+/**
+ * Build smart suggestion keyboard based on the AI response content.
+ * Returns an InlineKeyboard with up to 4 relevant action buttons.
+ */
+export function buildSmartSuggestions(response, prompt, maxButtons = 4) {
+    const matching = SUGGESTION_RULES.filter((rule) => rule.test(response, prompt));
+    if (matching.length === 0)
+        return undefined;
+    // Take top suggestions (most relevant first, since rules are ordered by specificity)
+    const selected = matching.slice(0, maxButtons);
+    const keyboard = new InlineKeyboard();
+    // Arrange buttons in 2-column layout
+    for (let i = 0; i < selected.length; i++) {
+        const rule = selected[i];
+        // Store a truncated version of the prompt as callback data (max 64 bytes for Telegram)
+        const callbackData = `${rule.callbackPrefix}:${Date.now().toString(36)}`;
+        keyboard.text(rule.label, callbackData);
+        if (i % 2 === 1 || i === selected.length - 1) {
+            keyboard.row();
+        }
+    }
+    return keyboard;
+}
+// In-memory store for pending smart suggestion prompts (TTL: 5 minutes)
+const pendingPrompts = new Map();
+/** Store the context for smart suggestion callbacks. */
+export function storeSuggestionContext(callbackPrefix, timeKey, prompt, response) {
+    const key = `${callbackPrefix}:${timeKey}`;
+    pendingPrompts.set(key, { prompt, response, timestamp: Date.now() });
+    // Cleanup old entries (older than 5 minutes)
+    const cutoff = Date.now() - 5 * 60_000;
+    for (const [k, v] of pendingPrompts) {
+        if (v.timestamp < cutoff)
+            pendingPrompts.delete(k);
+    }
+}
+/** Register callback handlers for smart suggestion buttons. */
+export function registerSmartSuggestionHandlers(bot) {
+    // Match all smart_ prefixed callbacks
+    bot.callbackQuery(/^smart_(\w+):(.+)$/, async (ctx) => {
+        const prefix = `smart_${ctx.match[1]}`;
+        const timeKey = ctx.match[2];
+        const fullKey = `${prefix}:${timeKey}`;
+        const context = pendingPrompts.get(fullKey);
+        if (!context) {
+            await ctx.answerCallbackQuery({ text: "Context expired — please ask again", show_alert: true });
+            return;
+        }
+        // Find the matching rule
+        const rule = SUGGESTION_RULES.find((r) => r.callbackPrefix === prefix);
+        if (!rule) {
+            await ctx.answerCallbackQuery({ text: "Unknown action" });
+            return;
+        }
+        await ctx.answerCallbackQuery({ text: `${rule.label}…` });
+        const chatId = ctx.chat.id;
+        const msgId = ctx.callbackQuery.message?.message_id;
+        // Send typing indicator
+        try {
+            await bot.api.sendChatAction(chatId, "typing");
+        }
+        catch {
+            /* best-effort */
+        }
+        const followUpPrompt = rule.promptTemplate(context.prompt, context.response);
+        sendToOrchestrator(followUpPrompt, { type: "telegram", chatId, messageId: msgId || 0 }, (text, done) => {
+            if (done) {
+                void sendFormattedReply(bot, chatId, text, { replyTo: msgId });
+            }
+        });
+        // Clean up used context
+        pendingPrompts.delete(fullKey);
+    });
+}
+/**
+ * Build the full smart suggestion keyboard AND store the context for callbacks.
+ * Returns undefined if no suggestions are applicable.
+ */
+export function createSmartSuggestionsWithContext(response, prompt, maxButtons = 4) {
+    const matching = SUGGESTION_RULES.filter((rule) => rule.test(response, prompt));
+    if (matching.length === 0)
+        return undefined;
+    const selected = matching.slice(0, maxButtons);
+    const keyboard = new InlineKeyboard();
+    for (let i = 0; i < selected.length; i++) {
+        const rule = selected[i];
+        const timeKey = Date.now().toString(36) + i.toString(36);
+        const callbackData = `${rule.callbackPrefix}:${timeKey}`;
+        storeSuggestionContext(rule.callbackPrefix, timeKey, prompt, response);
+        keyboard.text(rule.label, callbackData);
+        if (i % 2 === 1 || i === selected.length - 1) {
+            keyboard.row();
+        }
+    }
+    return keyboard;
+}
+//# sourceMappingURL=suggestions.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@iletai/nzb",
-    "version": "1.4.7",
+    "version": "1.4.9",
     "description": "NZB — a personal AI assistant for developers, built on the GitHub Copilot SDK",
     "bin": {
         "nzb": "dist/cli.js"

package/skills/find-skills/SKILL.md

@@ -5,7 +5,7 @@ description: Helps users discover agent skills when they ask questions like "how
 
 # Find Skills
 
-Discover and install skills from the open agent skills ecosystem at https://skills.sh/.
+Discover and install skills from the open agent skills ecosystem at <https://skills.sh/>.
 
 ## When to Use
 
@@ -51,7 +51,7 @@ Replace `QUERY` with a URL-encoded search term (e.g., `react`, `email`, `pr+revi
 web_fetch url="https://skills.sh/audits"
 ```
 
-If `web_fetch` fails or returns unexpected content, still present the search results but show "⚠️ Audit unavailable" for all security columns and include a link to https://skills.sh/audits so the user can check manually.
+If `web_fetch` fails or returns unexpected content, still present the search results but show "⚠️ Audit unavailable" for all security columns and include a link to <https://skills.sh/audits> so the user can check manually.
 
 This returns markdown where each skill has a heading (`### skill-name`) followed by its source, then three security scores:
 
@@ -76,6 +76,7 @@ Cross-reference the search results with the audit data and format as a numbered
 ```
 
 **Formatting:**
+
 - Sort by installs descending
 - Format counts: 1000+ → "1.0K", 1000000+ → "1.0M"
 - ✅ for Safe / Low Risk / 0 alerts, ⚠️ for Med Risk, 🔴 for High Risk / Critical / 1+ alerts
@@ -122,9 +123,9 @@ curl -fsSL "https://raw.githubusercontent.com/{source}/master/{skillId}/SKILL.md
 
 If both fail, tell the user and link to `https://github.com/{source}`.
 
-2. **Validate** the fetched content: it must not be empty and should contain meaningful instructions (more than just a title). If the content is empty, an HTML error page, or clearly not a SKILL.md, do NOT install — tell the user it couldn't be fetched properly.
+1. **Validate** the fetched content: it must not be empty and should contain meaningful instructions (more than just a title). If the content is empty, an HTML error page, or clearly not a SKILL.md, do NOT install — tell the user it couldn't be fetched properly.
 
-3. **Install** using the `learn_skill` tool:
+2. **Install** using the `learn_skill` tool:
    - `slug`: the `skillId` from the API
    - `name`: from the SKILL.md frontmatter `name:` field (between `---` markers). If no frontmatter, use `skillId`.
    - `description`: from the SKILL.md frontmatter `description:` field. If none, use the first sentence.