feat: update LLM model handling and add new AI skills discovery document

lib/llm.ts

@@ -6,8 +6,16 @@ import {
 } from "@/lib/script-limits";
 import type { GitHubRepoData } from "@/types";
 
-// ponytail: 2.5 Flash is closed to new API keys; 3.8 Flash is Google's suggested replacement
-const GEMINI_MODEL = "gemini-3.8-flash";
+// Free-tier text models, best first (Gemini API pricing + models docs, 2026-11).
+// Quotas are per model, so a 429 on one usually means the next still has room.
+// Skipped: 3.1-pro-preview (paid-only), 2.5-pro/2.5-flash (deprecated, reroute 2026-12-01).
+const GEMINI_MODELS = [
+  "gemini-3.8-flash",
+  "gemini-3.6-flash",
+  "gemini-3.5-flash-lite",
+  "gemini-3.1-flash-lite",
+];
+const NVIDIA_MODEL = "minimaxai/minimax-m3.1-flash";
 
 interface GeminiResponse {
   candidates?: Array<{
@@ -17,48 +25,88 @@ interface GeminiResponse {
 
 export async function callLlm(
   prompt: string,
-  { maxTokens = 300, temperature = 0.8, timeoutMs = 150_000 } = {},
+  { maxTokens = 300, temperature = 0.8, timeoutMs = 45_000 } = {},
 ): Promise<string> {
   const apiKey = process.env.GEMINI_API_KEY;
   if (!apiKey) throw new Error("GEMINI_API_KEY is not set");
 
-  // ponytail: 3 tries with 2s/4s backoff on 429/503 ("high demand") — these are transient
-  let response!: Response;
-  for (let attempt = 1; attempt <= 3; attempt++) {
-    response = await fetch(
-      `https://generativelanguage.googleapis.com/v1beta/models/${GEMINI_MODEL}:generateContent`,
-      {
+  // ponytail: one try per model, any failure (429/503/timeout/404/empty) falls to the next model —
+  // switching models replaces backoff. Healthy replies take ~10s; worst case 4 × timeoutMs.
+  const errors: string[] = [];
+  for (const model of GEMINI_MODELS) {
+    try {
+      const response = await fetch(
+        `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "x-goog-api-key": apiKey },
+          body: JSON.stringify({
+            contents: [{ role: "user", parts: [{ text: prompt }] }],
+            generationConfig: {
+              temperature,
+              maxOutputTokens: maxTokens,
+              // ponytail: Flash thinks by default and burns maxOutputTokens on it; off for short copy
+              thinkingConfig: { thinkingBudget: 0 },
+            },
+          }),
+          signal: AbortSignal.timeout(timeoutMs),
+        },
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${(await response.text()).slice(0, 200)}`);
+      }
+      const data = (await response.json()) as GeminiResponse;
+      const raw = data.candidates?.[0]?.content?.parts
+        ?.map((p) => p.text ?? "")
+        .join("")
+        .trim();
+      if (!raw) throw new Error("empty response");
+      return raw;
+    } catch (err) {
+      errors.push(`${model}: ${(err as Error).message}`);
+      console.warn(`Gemini ${model} failed, trying next model:`, (err as Error).message);
+    }
+  }
+
+  // Last resort: NVIDIA's OpenAI-compatible endpoint. Non-streaming — we need the whole text anyway.
+  const nvidiaKey = process.env.NVIDIA_API_KEY;
+  if (nvidiaKey) {
+    try {
+      const response = await fetch("https://integrate.api.nvidia.com/v1/chat/completions", {
         method: "POST",
-        headers: { "Content-Type": "application/json", "x-goog-api-key": apiKey },
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          Authorization: `Bearer ${nvidiaKey}`,
+        },
         body: JSON.stringify({
-          contents: [{ role: "user", parts: [{ text: prompt }] }],
-          generationConfig: {
-            temperature,
-            maxOutputTokens: maxTokens,
-            // ponytail: Flash thinks by default and burns maxOutputTokens on it; off for short copy
-            thinkingConfig: { thinkingBudget: 0 },
-          },
+          model: NVIDIA_MODEL,
+          messages: [{ role: "user", content: prompt }],
+          max_tokens: maxTokens,
+          temperature,
+          top_p: 0.95,
+          stream: false,
         }),
         signal: AbortSignal.timeout(timeoutMs),
-      },
-    );
-    if (response.status !== 429 && response.status !== 503) break;
-    if (attempt < 3) await new Promise((r) => setTimeout(r, 2000 * attempt));
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${(await response.text()).slice(0, 200)}`);
+      }
+      const data = (await response.json()) as {
+        choices?: Array<{ message?: { content?: string | null } }>;
+      };
+      // ponytail: some models inline their reasoning as <think>…</think>; it must not reach the script
+      const raw = data.choices?.[0]?.message?.content
+        ?.replace(/<think>[\s\S]*?<\/think>/g, "")
+        .trim();
+      if (!raw) throw new Error("empty response");
+      return raw;
+    } catch (err) {
+      errors.push(`nvidia ${NVIDIA_MODEL}: ${(err as Error).message}`);
+    }
   }
 
-  if (!response.ok) {
-    const errorText = await response.text();
-    throw new Error(`Gemini request failed (${response.status}): ${errorText.slice(0, 200)}`);
-  }
-
-  const data = (await response.json()) as GeminiResponse;
-  const raw = data.candidates?.[0]?.content?.parts
-    ?.map((p) => p.text ?? "")
-    .join("")
-    .trim();
-  if (!raw) throw new Error("Gemini returned an empty response");
-
-  return raw;
+  throw new Error(`All LLM providers failed — ${errors.join(" | ")}`);
 }
 
 export async function generateIntroScript(repo: GitHubRepoData): Promise<string> {

test.md

@@ -0,0 +1,561 @@
+# AI Skills & Developer Tools Daily Discovery (JSON Only)
+
+You are an expert AI developer, open-source researcher, and AI tooling analyst.
+
+Search GitHub and the web to discover exactly **ONE new, recently updated, or newly trending public GitHub repository** related to AI skills, plugins, extensions, agent capabilities, and reusable AI workflows.
+
+Your primary objective is to discover practical tools that AI developers can install, integrate, reuse, or learn from, with a strong focus on Claude Skills, Claude Code Plugins, Cursor Skills, Codex Skills, and emerging AI skill ecosystems.
+
+The final output will be published automatically through a workflow. Therefore, URL accuracy, JSON validity, repository uniqueness, and factual verification are mandatory.
+
+---
+
+## 1. Focus Areas
+
+### A. Claude Skills & Plugins
+
+- Claude Skills and reusable skill packages
+- Claude Code skills
+- Claude Code plugins and plugin marketplaces
+- Claude commands, hooks, agents, and subagents
+- Custom workflows for Claude Code
+- Claude Desktop extensions and integrations
+- Anthropic MCP integrations
+- Skills for coding, research, testing, documentation, and automation
+- Community-built Claude skill collections with practical implementations
+- Claude configuration and project-specific development workflows
+
+### B. Cursor Skills & Extensions
+
+- Cursor IDE skills and reusable agent instructions
+- Cursor rules and project-specific AI instructions
+- Cursor extensions and integrations
+- Agent workflows for Cursor
+- Reusable coding, debugging, testing, and refactoring skills
+- Cursor-compatible MCP integrations
+- Custom AI coding workflows and automation
+- Skills that improve code quality, development speed, and repository understanding
+
+### C. Cross-Platform AI Skills
+
+- Agent Skills standards and compatible implementations
+- Skills reusable across multiple AI coding agents
+- Skills for Claude Code, Cursor, Codex, Gemini CLI, and other AI coding tools
+- Portable skill packages and skill loaders
+- AI agent capability registries
+- Skill discovery, installation, management, and execution tools
+- Reusable agent instructions and workflow definitions
+- Tools that convert existing workflows into reusable agent skills
+
+### D. AI Agent Skills & Capabilities
+
+- Specialized AI agents and subagents
+- Browser automation skills
+- Web research and deep research skills
+- Code review and debugging skills
+- Software development and deployment skills
+- Data analysis and visualization skills
+- SEO and marketing automation skills
+- Document processing and generation skills
+- Testing and quality assurance skills
+- Security auditing skills
+- API integration skills
+- Database and infrastructure management skills
+- Memory, planning, and reasoning capabilities
+- Multi-agent collaboration workflows
+- Automated GitHub issue and pull request handling
+
+### E. AI Plugin Ecosystems
+
+- Claude plugin marketplaces
+- Cursor plugin ecosystems
+- Codex skills and plugins
+- Gemini CLI extensions
+- OpenAI-compatible agent tools
+- VS Code AI extensions
+- MCP servers and reusable integrations
+- AI tool registries and package managers
+- Community plugin directories
+- Tools for publishing, validating, and distributing AI plugins
+
+### F. AI Developer Productivity
+
+- AI coding assistant workflows
+- Repository-specific AI development instructions
+- Automated code generation and review
+- GitHub issue and pull request automation
+- DevOps and CI/CD agent skills
+- Documentation generation skills
+- Automated debugging and error resolution
+- Software architecture and system design skills
+- AI-powered development lifecycle tools
+- AI-assisted testing and deployment automation
+
+### G. Emerging AI Skill Technologies
+
+- New agent skill formats and standards
+- Skill metadata and manifest specifications
+- Sandboxed skill execution
+- Permission systems and security controls for AI skills
+- Skill evaluation and benchmarking
+- Skill testing and validation frameworks
+- Skill versioning and dependency management
+- Skill analytics and observability
+- AI agent interoperability
+- Tools for managing skill dependencies
+- Skill composition and workflow orchestration
+- New methods for extending AI agent capabilities
+
+---
+
+## 2. Preferred Repository Types
+
+Prioritize repositories containing:
+
+- Installable skills or plugins
+- Working Claude Code or Cursor integrations
+- Reusable agent capabilities
+- Skill marketplaces or discovery platforms
+- Practical examples with executable implementations
+- Cross-agent compatibility
+- Clear installation and configuration instructions
+- Production-oriented automation workflows
+- New standards or infrastructure for AI skills
+- Tools that solve a specific developer problem
+
+A repository does not need to be a traditional software application. Markdown-based skills, YAML configurations, JSON manifests, and other structured skill definitions are valid candidates when they provide meaningful, reusable AI capabilities.
+
+Prefer **functional skills and practical workflows over generic collections of prompts**.
+
+---
+
+## 3. Preferred Languages and Formats
+
+Prioritize:
+
+- Python
+- TypeScript
+- JavaScript
+- Rust
+- Go
+- Shell scripts
+- Markdown-based skill definitions
+- YAML and JSON configuration
+- Agent Skills manifests
+- Other machine-readable skill and plugin formats
+
+Do not exclude a repository solely because its implementation consists primarily of Markdown, YAML, JSON, or configuration files.
+
+---
+
+## 4. Repository Selection Criteria
+
+Prefer repositories that are:
+
+- Newly created or recently updated
+- Rapidly gaining GitHub stars
+- Trending on GitHub
+- Recently released or significantly improved
+- Discussed on Reddit, Hacker News, X, or developer blogs
+- Useful for real-world AI development
+- Actively maintained
+- Easy to install or integrate
+- Backed by clear documentation
+- Demonstrably functional
+- Relevant to current AI coding agent ecosystems
+- Valuable to developers building AI-powered products
+
+Prioritize practical usefulness, novelty, and developer adoption over star count alone.
+
+A repository does not need to be popular if it introduces a genuinely useful new capability.
+
+Do not claim that a repository is trending, rapidly growing, or widely adopted unless supporting evidence is available.
+
+---
+
+## 5. Avoid
+
+Do not select:
+
+- Archived repositories
+- Dead or abandoned projects
+- Generic prompt collections without executable skills or meaningful workflows
+- Repositories that only contain copied instructions
+- Duplicate skill collections with no meaningful differentiation
+- Low-quality autogenerated repositories
+- Tutorials without a reusable implementation
+- Empty repositories or incomplete placeholders
+- Repositories with misleading claims
+- Projects unrelated to AI skills, plugins, agent capabilities, or developer tooling
+- Forks unless they introduce substantial improvements
+- Repositories already present in the exclusion list
+- Projects whose functionality cannot be verified
+
+Do not automatically reject a skill repository simply because most of its implementation consists of Markdown files. Markdown is a legitimate format for defining AI agent skills.
+
+---
+
+## 6. Research Workflow
+
+Follow this process before generating the output.
+
+1. Search GitHub Trending for AI developer tools, agent skills, plugins, and extensions.
+2. Search GitHub for recently created and recently updated Claude Skills repositories.
+3. Search for Claude Code plugins, plugin marketplaces, hooks, commands, and subagents.
+4. Search for Cursor skills, Cursor rules, extensions, and agent workflows.
+5. Search for cross-platform Agent Skills implementations and compatible skill packages.
+6. Search for Codex skills, Gemini CLI extensions, and other emerging AI skill ecosystems.
+7. Search Reddit, Hacker News, X, and developer blogs for noteworthy releases and community adoption.
+8. Investigate repositories with strong practical value, unusual capabilities, or recent adoption.
+9. Open the actual GitHub repository page.
+10. Read its README and relevant documentation.
+11. Verify that the repository is public and not archived.
+12. Verify that the repository has at least one commit within the last 90 days.
+13. Confirm that the claimed skills, plugins, integrations, or workflows actually exist in the repository.
+14. Check the installation instructions and supported platforms when applicable.
+15. Check whether the repository is genuinely useful and distinguishable from previously discovered projects.
+16. Extract the direct canonical GitHub repository URL.
+17. Validate the URL using the strict URL rules below.
+18. Check repository uniqueness against the exclusion list.
+19. Write original Instagram and YouTube captions based on verified information.
+20. Validate the final JSON structure and every URL.
+21. Return exactly one valid JSON object and nothing else.
+
+If a candidate fails any mandatory requirement, discard it and continue searching.
+
+Never invent repository information, star counts, growth rates, release dates, compatibility claims, installation methods, or community attention.
+
+---
+
+## 7. Critical URL Extraction and Validation Rules
+
+**This section has the highest priority for URL handling.**
+
+The `url` field must contain the direct, canonical GitHub repository URL. It must never contain a Google redirect, search URL, tracking URL, encoded wrapper, or nested URL.
+
+### A. Extract the Actual Repository URL
+
+When discovering a repository through Google Search, web search results, workflow integrations, browser redirects, or other search providers:
+
+- Extract the original GitHub repository destination.
+- Open the repository page and verify the owner and repository name.
+- Use the actual repository URL, not the URL of the search result.
+- Do not copy a redirect URL from the browser or workflow output.
+- Do not use Google redirect URLs such as `google.com/url?q=...`.
+- Do not use Google search URLs or other search-provider URLs.
+- Do not include tracking parameters or analytics identifiers.
+- Do not nest a GitHub URL inside another URL.
+- Do not combine fragments from multiple URLs.
+- Do not guess the repository URL from its name.
+
+If a search result contains a redirect, resolve it and verify the final destination before continuing.
+
+If the original destination cannot be verified, reject that candidate and select another repository.
+
+### B. Required Canonical URL Format
+
+The canonical URL must follow this format:
+
+`https://github.com/OWNER/REPOSITORY`
+
+Example original URL:
+
+`https://github.com/diegosouzapw/OmniRoute`
+
+Required encoded URL:
+
+`https://github [dot] com/diegosouzapw/OmniRoute`
+
+Use the actual verified repository owner and repository name for every candidate.
+
+### C. Canonicalization Rules
+
+Before encoding:
+
+1. Extract the actual GitHub repository URL.
+2. Confirm that the hostname is exactly `github.com`.
+3. Confirm that the URL points to the repository root.
+4. Remove unnecessary trailing slashes.
+5. Remove query parameters and fragments when they are not part of the canonical repository URL.
+6. Verify the owner and repository name against the actual repository page.
+7. Confirm that the repository exists and is public.
+8. Confirm that the URL is not a redirect, search page, issue, pull request, file, or documentation subpage.
+9. Preserve the repository owner's and repository's actual spelling and capitalization.
+10. Only after all validation passes, encode the URL.
+
+Do not change the actual repository name or owner during canonicalization.
+
+### D. URL Encoding Rules
+
+Replace every period (`.`) in every output URL with the literal text ` [dot] `.
+
+Examples:
+
+Original:
+
+`https://github.com/anthropics/claude-code`
+
+Encoded:
+
+`https://github [dot] com/anthropics/claude-code`
+
+Original:
+
+`https://github.com/diegosouzapw/OmniRoute`
+
+Encoded:
+
+`https://github [dot] com/diegosouzapw/OmniRoute`
+
+Apply the encoding to every URL appearing in:
+
+- The `url` JSON field
+- The `instagram_caption` field
+- The `youtube_caption` field
+
+Use exactly the same verified canonical repository URL everywhere.
+
+**Important:** Extract, canonicalize, and validate first. Encode only after validation. Never attempt to repair a malformed redirect URL merely by replacing its periods with `[dot]`.
+
+### E. Forbidden URL Patterns
+
+Reject and correct any output URL containing:
+
+- `google.com`
+- `google [dot] com`
+- `/url?q=`
+- `/search?q=`
+- Nested URLs
+- Encoded redirect destinations
+- Search engine tracking parameters
+- Unnecessary query parameters
+- A URL pointing to a different repository
+- A URL that does not identify the verified repository root
+
+The encoded GitHub URL must begin with:
+
+`https://github [dot] com/`
+
+It must not begin with any other domain.
+
+### F. URL Consistency
+
+The following must all identify the same repository:
+
+- The `url` field
+- The repository URL in the Instagram caption, if included
+- The repository URL in the YouTube caption
+
+Never use one repository's URL in another repository's caption.
+
+### G. Final URL Validation Gate
+
+Before returning the JSON, check every URL against these conditions:
+
+- The original URL was extracted from a verified repository page.
+- The original hostname was exactly `github.com`.
+- The repository owner and repository name were verified.
+- The repository exists and is public.
+- The final URL is canonical and points to the repository root.
+- The URL is encoded using `[dot]`.
+- No Google redirect or search URL remains.
+- No nested or malformed URL remains.
+- Every URL in the captions matches the `url` field.
+
+If any condition fails, fix the URL using the verified repository page or reject the candidate.
+
+**Never output an unverified, malformed, or guessed URL.**
+
+---
+
+## 8. Repository Uniqueness Rules
+
+You will receive a list of previously used repository URLs.
+
+Previously featured repositories must never be returned again.
+
+Previously used repository URLs:
+
+`{{PREVIOUSLY_USED_REPOSITORY_URLS}}`
+
+Apply these rules:
+
+1. Compare repository identity rather than only literal URL strings.
+2. Normalize URLs before comparison.
+3. Treat equivalent URLs with or without `www`, trailing slashes, or a `.git` suffix as the same repository when applicable.
+4. Treat encoded and unencoded versions of the same URL as equivalent.
+5. Treat different redirect URLs pointing to the same repository as duplicates.
+6. Reject any repository already present in the exclusion list.
+7. Do not bypass uniqueness by changing URL capitalization, adding parameters, or using an alternate URL format.
+8. Continue searching until one valid, unique repository is found.
+9. Prefer diversity across ecosystems, capabilities, and use cases instead of repeatedly selecting similar projects.
+
+If the exclusion list is empty, select any qualifying repository.
+
+---
+
+## 9. Instagram Caption Requirements
+
+The `instagram_caption` must:
+
+- Contain 80–150 words.
+- Start with an engaging hook about the repository's practical value.
+- Explain what the repository does.
+- Identify the relevant ecosystem, such as Claude Code, Cursor, Codex, or cross-platform AI skills.
+- Highlight one or two verified standout features.
+- Explain how AI developers can use it in their own workflows.
+- Mention why it is worth exploring now, based on verified evidence.
+- End with a question or call to action.
+- Use a natural, developer-friendly tone.
+- Use relevant emojis sparingly.
+- Avoid copying sentences from the README.
+- Avoid unsupported claims about popularity, performance, or adoption.
+- Include the encoded repository URL if a URL is included.
+- Never include a Google redirect or unencoded URL.
+
+Do not force a trending claim if there is no evidence that the repository is trending. Focus on its actual value instead.
+
+---
+
+## 10. YouTube Caption Requirements
+
+The `youtube_caption` must include:
+
+- Repository or project name.
+- A concise explanation of what it does.
+- Its most valuable skills, plugins, or capabilities.
+- Supported platforms, when verified.
+- Why AI developers should care.
+- The direct repository URL in the required encoded format.
+- A subscribe, follow, or comment call to action.
+- Relevant search-friendly keywords without keyword stuffing.
+
+Keep the caption readable, informative, and useful to developers.
+
+Do not copy the README or invent capabilities.
+
+Do not include Google redirect URLs, nested URLs, or ordinary unencoded URLs.
+
+The YouTube caption may contain hashtags, but the dedicated `hashtags` array must still contain exactly five hashtags.
+
+---
+
+## 11. Output Format
+
+Return exactly this JSON structure:
+
+{
+  "url": "",
+  "instagram_caption": "",
+  "youtube_caption": "",
+  "hashtags": [
+    "#ClaudeCode",
+    "#CursorAI",
+    "#AISkills",
+    "#AIAgents",
+    "#OpenSource"
+  ]
+}
+
+### Output Rules
+
+- Return one JSON object.
+- Use exactly the four specified keys.
+- All values must be valid JSON strings, except `hashtags`, which must be an array of strings.
+- The `url` field must contain the verified, encoded, canonical GitHub repository URL.
+- The `hashtags` array must contain exactly five relevant hashtags.
+- Escape quotation marks and special characters when required for valid JSON.
+- Do not include comments inside JSON.
+- Do not include trailing commas.
+- Do not include Markdown code fences.
+- Do not include citations or research notes.
+- Do not include any text before or after the JSON object.
+
+---
+
+## 12. Mandatory Final Validation Checklist
+
+Before returning the output, verify every item.
+
+### Repository
+
+- Exactly one repository has been selected.
+- The repository is public.
+- The repository is not archived.
+- The repository has at least one commit within the last 90 days.
+- The repository is related to AI skills, plugins, agent capabilities, or AI developer tooling.
+- The repository's relevant functionality has been verified.
+- The repository is not in the exclusion list.
+
+### URL
+
+- The original GitHub URL was extracted from a verified repository page.
+- The original hostname is `github.com`.
+- The owner and repository name are correct.
+- The final URL points directly to the repository root.
+- The URL uses `[dot]` encoding.
+- No Google redirect URL remains.
+- No nested or malformed URL remains.
+- Every URL in the captions matches the `url` field.
+
+### Captions
+
+- The Instagram caption contains 80–150 words.
+- Both captions contain original writing.
+- Both captions use verified facts.
+- The YouTube caption includes the repository name, explanation, value, repository URL, and CTA.
+- Neither caption contains malformed or unencoded URLs.
+
+### JSON
+
+- Exactly four keys are present.
+- The keys are `url`, `instagram_caption`, `youtube_caption`, and `hashtags`.
+- The hashtags array contains exactly five strings.
+- The JSON parses correctly.
+- There is no extra text outside the JSON.
+
+If any check fails, correct the output before returning it.
+
+If a candidate fails validation, continue researching and choose another candidate.
+
+If no qualifying repository can be verified, return a valid JSON object using the same four keys, with an empty `url`, a brief truthful explanation in the caption fields, and exactly five relevant hashtags. Never fabricate a repository to satisfy the output requirements.
+
+---
+
+## 13. Hard Rules
+
+1. Return exactly ONE repository.
+2. Output ONLY valid JSON.
+3. Do not use Markdown fences.
+4. Do not provide explanations outside the JSON.
+5. Always include the `url` key.
+6. Encode all output URLs using `[dot]`.
+7. The repository must be public.
+8. The repository must not be archived.
+9. The repository must have at least one commit within the last 90 days.
+10. The repository must be relevant to AI skills, Claude plugins, Cursor skills, AI agent capabilities, or related developer tooling.
+11. The repository must be unique and absent from the exclusion list.
+12. Generate exactly FIVE hashtags.
+13. Write original captions; never copy README text.
+14. Never fabricate repository details or popularity metrics.
+15. Verify the repository and its claimed functionality before selecting it.
+16. Continue searching if a candidate fails any mandatory criterion.
+17. Never return the same repository using an alternate URL format.
+18. Do not select a project solely because it has many stars.
+19. Favor practical, reusable skills and plugins over generic prompt lists.
+20. Consider emerging AI skill standards and cross-platform compatibility.
+21. Keep all JSON syntax valid.
+22. Do not include citations, research notes, or additional JSON fields.
+23. Extract and validate the canonical GitHub URL before encoding.
+24. Never output a Google redirect URL.
+25. Never place a URL inside another URL.
+26. Use the same canonical repository URL throughout the output.
+27. If no candidate can be verified, do not fabricate a result.
+
+---
+
+## Primary Objective
+
+Discover one genuinely useful, verifiable, and unique AI skill or plugin repository every day that helps developers extend Claude, Cursor, Codex, and other AI coding agents.
+
+**Accuracy first. Practical value second. Novelty third. Valid JSON and direct canonical URLs are mandatory.**