@minhpnq1807/contextos 0.5.42 → 0.5.45

package/plugins/ctx/lib/shell-runner.js

@@ -0,0 +1,88 @@
+import fs from "node:fs";
+import { spawn } from "node:child_process";
+
+export function shellInvocation(command, { platform = process.platform, env = process.env } = {}) {
+  if (platform === "win32") {
+    return {
+      command: env.ComSpec || env.COMSPEC || "cmd.exe",
+      args: ["/d", "/s", "/c", command]
+    };
+  }
+  return {
+    command: fs.existsSync("/bin/sh") ? "/bin/sh" : "sh",
+    args: ["-c", command]
+  };
+}
+
+export function runPrefixedCommand(commandText, {
+  spawnFn = spawn,
+  stdout = process.stdout,
+  stderr = process.stderr,
+  stdin = "inherit",
+  platform = process.platform,
+  env = process.env,
+  prefix = "\x1B[2m│\x1B[0m  "
+} = {}) {
+  const shell = shellInvocation(commandText, { platform, env });
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    };
+
+    let child;
+    try {
+      child = spawnFn(shell.command, shell.args, {
+        stdio: [stdin, "pipe", "pipe"],
+        windowsHide: true
+      });
+    } catch (error) {
+      fail(error);
+      return;
+    }
+
+    pipePrefixed(child.stdout, stdout, prefix);
+    pipePrefixed(child.stderr, stderr, prefix);
+
+    child.on("error", (error) => {
+      if (error?.code === "ENOENT") {
+        fail(new Error([
+          `Unable to start shell '${shell.command}' for installer command.`,
+          `Original command: ${commandText}`,
+          platform === "win32"
+            ? "Fix: ensure cmd.exe is available through ComSpec/COMSPEC, or run ContextOS from a normal Command Prompt, PowerShell, or Windows Terminal session."
+            : "Fix: ensure /bin/sh exists, or install a POSIX shell before running ContextOS installers."
+        ].join("\n")));
+        return;
+      }
+      fail(error);
+    });
+
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      if (code === 0) resolve();
+      else reject(new Error(`Installer command exited with code ${code}: ${commandText}`));
+    });
+  });
+}
+
+function pipePrefixed(stream, target, prefix) {
+  if (!stream) return;
+  let needPrefix = true;
+  stream.on("data", (buf) => {
+    const str = buf.toString();
+    let out = "";
+    for (const ch of str) {
+      if (needPrefix) {
+        out += prefix;
+        needPrefix = false;
+      }
+      out += ch;
+      if (ch === "\n") needPrefix = true;
+    }
+    target.write(out);
+  });
+}

package/plugins/ctx/lib/skill-discoverer.js

@@ -10,6 +10,20 @@ const DEFAULT_EMBEDDING_CANDIDATES = 120;
 const DEFAULT_SEMANTIC_CATALOG_LIMIT = 300;
 const SCAN_CACHE_TTL_MS = 5 * 60 * 1000;
 const MAX_DESCRIPTION_CHARS = 500;
+const GENERIC_SKILL_TOKENS = new Set([
+  "active", "agent", "agents", "code", "config", "configuration", "create", "development",
+  "environment", "file", "files", "graph", "install", "integration", "local", "node", "package",
+  "project", "refresh", "rebuild", "setup", "skill", "skills", "sync", "tool", "tools", "using",
+  "build", "can", "not", "production", "show", "something", "https", "http", "com", "www",
+  "a", "an", "and", "are", "as", "at", "be", "before", "after", "both", "by", "from", "for",
+  "if", "in", "into", "is", "must", "of", "on", "or", "the", "then", "this", "to", "user",
+  "users", "when", "where", "whether", "with"
+]);
+const SPECIALIZED_SKILL_TOKENS = new Set([
+  "android", "authorization", "cicd", "eas", "expo", "frontend", "ios", "next", "nextjs",
+  "mcp", "modelcontextprotocol", "postgres", "postgresql", "react", "react-native", "tailwind",
+  "typescript", "ui"
+]);
 
 const scanCache = new Map();
 
@@ -20,9 +34,9 @@ export function skillSearchRoots({ cwd = process.cwd(), home = os.homedir() } =
     path.join(cwd, ".gemini", "skills"),
     path.join(cwd, ".gemini", "antigravity", "skills"),
     path.join(cwd, ".gemini", "antigravity-cli", "skills"),
-    path.join(home, ".config", "skillshare", "skills"),
     path.join(home, ".codex", "skills"),
     path.join(home, ".claude", "skills"),
+    path.join(home, ".config", "skillshare", "skills"),
     path.join(home, ".gemini", "skills"),
     path.join(home, ".gemini", "antigravity", "skills"),
     path.join(home, ".gemini", "antigravity-cli", "skills")
@@ -154,13 +168,14 @@ export async function suggestSkills({
   prompt = "",
   skills = [],
   dataDir,
+  cwd = process.cwd(),
   limit = DEFAULT_LIMIT,
   timeoutMs = Number(process.env.CONTEXTOS_SKILL_EMBEDDING_TIMEOUT_MS || process.env.CONTEXTOS_EMBEDDING_TIMEOUT_MS || 800)
 } = {}) {
   if (!String(prompt || "").trim() || !skills.length) return [];
-  const base = scoreSkillsByKeyword({ prompt, skills });
+  const base = scoreSkillsByKeyword({ prompt, skills, projectHints: projectSkillHints({ cwd }) });
   if (skills.length > DEFAULT_SEMANTIC_CATALOG_LIMIT) {
-    return finalizeSkillScores(base, limit);
+    return finalizeSkillScores(base, limit, { minimumKeywordScore: 0.5 });
   }
 
   const embeddingCandidates = selectEmbeddingCandidates(base);
@@ -176,8 +191,9 @@ export async function suggestSkills({
   return finalizeSkillScores(embedding.rules, limit);
 }
 
-function finalizeSkillScores(skills, limit) {
-  return skills
+function finalizeSkillScores(skills, limit, { minimumKeywordScore = 0.35 } = {}) {
+  const ranked = skills
+    .filter((rule) => rule.domainEligible !== false)
     .map((rule) => ({
       name: rule.name,
       description: rule.description,
@@ -186,13 +202,33 @@ function finalizeSkillScores(skills, limit) {
       keywordScore: rule.keywordScore,
       score: Math.min(1, Number(rule.score || 0)),
       embeddingScore: rule.embeddingScore,
+      relevancePriority: Number(rule.relevancePriority || 0),
+      rankScore: Math.min(1, Number(rule.score || 0)) + Number(rule.relevancePriority || 0) / 100,
       reasons: rule.reasons || []
     }))
-    .filter((skill) => Number(skill.keywordScore || 0) >= 0.35 || Number(skill.embeddingScore || 0) >= 0.62)
-    .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))
+    .filter((skill) => Number(skill.keywordScore || 0) >= minimumKeywordScore
+      || Number(skill.embeddingScore || 0) >= 0.62
+      || Number(skill.relevancePriority || 0) >= 50)
+    .sort((a, b) => b.rankScore - a.rankScore
+      || b.relevancePriority - a.relevancePriority
+      || b.score - a.score
+      || scopePriority(b.scope) - scopePriority(a.scope)
+      || a.name.localeCompare(b.name));
+  const seen = new Set();
+  return ranked
+    .filter((skill) => {
+      const key = normalize(skill.name);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    })
     .slice(0, limit);
 }
 
+function scopePriority(scope) {
+  return scope === "project" ? 1 : 0;
+}
+
 function selectEmbeddingCandidates(skills) {
   if (skills.length <= DEFAULT_EMBEDDING_CANDIDATES) return skills;
   return [...skills]
@@ -217,21 +253,31 @@ export async function warmSkillEmbeddings({
   });
 }
 
-function scoreSkillsByKeyword({ prompt, skills }) {
-  const normalizedPrompt = normalize(prompt);
+function scoreSkillsByKeyword({ prompt, skills, projectHints = [] }) {
+  const normalizedPrompt = normalizePrompt(prompt);
   const promptTokens = new Set(normalizedPrompt.split(/\s+/).filter(Boolean));
+  const projectTokens = new Set(projectHints);
   return skills.map((skill, index) => {
     const enriched = skill.searchTokens ? skill : enrichSkill(skill);
     const name = String(enriched.name || "");
     const description = truncateDescription(enriched.description || "");
     const content = `${name} ${description}`;
-    const matches = enriched.searchTokens.filter((token) => promptTokens.has(token) && token.length > 2);
+    const matches = filterSkillMatches(
+      enriched.searchTokens.filter((token) => promptTokens.has(token) && token.length > 2 && !GENERIC_SKILL_TOKENS.has(token)),
+      { normalizedPrompt, enriched }
+    );
+    const projectMatches = enriched.searchTokens.filter((token) => projectTokens.has(token) && SPECIALIZED_SKILL_TOKENS.has(token));
     const normalizedName = enriched.normalizedName;
     const nameTokens = enriched.nameTokens;
     const nameHit = normalizedPrompt.includes(normalizedName);
     const nameTokenHit = nameTokens.length > 1 && nameTokens.every((token) => promptTokens.has(token));
     const scopeBonus = enriched.scope === "project" ? 0.08 : 0;
-    const score = Math.min(1, (matches.length ? 0.25 + matches.length * 0.08 : 0) + (nameHit ? 0.2 : 0) + (nameTokenHit ? 0.18 : 0) + scopeBonus);
+    const intentBonus = skillIntentBonus(normalizedPrompt, enriched, projectTokens);
+    const relevancePriority = skillRelevancePriority(normalizedPrompt, enriched, projectTokens);
+    const domainEligible = isSkillDomainEligible(normalizedPrompt, enriched, projectTokens);
+    const matchScore = matches.reduce((sum, token) => sum + (SPECIALIZED_SKILL_TOKENS.has(token) ? 0.2 : 0.08), 0);
+    const projectBonus = intentBonus ? Math.min(0.16, projectMatches.length * 0.04) : 0;
+    const score = Math.min(1, (matches.length ? 0.25 + matchScore : 0) + projectBonus + intentBonus + (nameHit ? 0.2 : 0) + (nameTokenHit ? 0.18 : 0) + scopeBonus);
     return {
       id: `skill-${index + 1}`,
       name,
@@ -241,8 +287,12 @@ function scoreSkillsByKeyword({ prompt, skills }) {
       content,
       score,
       keywordScore: score,
+      relevancePriority,
+      domainEligible,
       reasons: [
         ...(matches.length ? [`keyword:${matches.slice(0, 4).join(",")}`] : []),
+        ...(projectBonus ? [`project:${projectMatches.slice(0, 4).join(",")}`] : []),
+        ...(intentBonus ? ["intent-match"] : []),
         ...(nameHit || nameTokenHit ? ["name-match"] : [])
       ],
       originalOrder: index
@@ -250,6 +300,271 @@ function scoreSkillsByKeyword({ prompt, skills }) {
   });
 }
 
+function filterSkillMatches(matches, { normalizedPrompt, enriched }) {
+  if (!/\beas\b/.test(normalizedPrompt)) return matches;
+  const skillText = normalize(`${enriched.name} ${enriched.description}`);
+  if (/\b(eas|expo|cicd)\b/.test(skillText)) return matches;
+  return matches.filter((token) => token !== "android" && token !== "ios");
+}
+
+function isSkillDomainEligible(normalizedPrompt, enriched, projectTokens = new Set()) {
+  const skillText = normalize(`${enriched.name} ${enriched.description}`);
+  if (isMcpSkill(skillText) && !isMcpRelevantTask(normalizedPrompt, projectTokens)) return false;
+  if (isOffensiveSecuritySkill(skillText) && !isSecurityTask(normalizedPrompt)) return false;
+  if (isPlatformCommerceSkill(skillText) && !isPlatformCommerceTask(normalizedPrompt, skillText)) return false;
+  if (!/\beas\b/.test(normalizedPrompt)) return true;
+  if (!/\b(android|ios)\b/.test(skillText)) return true;
+  return /\b(eas|expo|cicd)\b/.test(skillText);
+}
+
+function skillIntentBonus(normalizedPrompt, enriched, projectTokens = new Set()) {
+  const skillText = normalize(`${enriched.name} ${enriched.description}`);
+  if (isMcpRelevantTask(normalizedPrompt, projectTokens)
+    && /\b(mcp|model context protocol|modelcontextprotocol|agent memory|tool developer|tool builder)\b/.test(skillText)) {
+    return 0.48;
+  }
+  if (isCommerceTask(normalizedPrompt)
+    && /\b(payment|payments|checkout|billing|bill|invoice|wallet|balance|stripe|paypal|commerce|monetization)\b/.test(skillText)) {
+    return 0.46;
+  }
+  if (isContentAccessTask(normalizedPrompt)
+    && /\b(api|endpoint|backend|service|services|auth|authorization|permission|permissions|access|rbac|frontend api)\b/.test(skillText)) {
+    return 0.34;
+  }
+  if (isNotificationTask(normalizedPrompt)
+    && /\b(notification|notifications|notify|message|sms|email|event|webhook)\b/.test(skillText)) {
+    return 0.3;
+  }
+  if (isFrontendCheckoutTask(normalizedPrompt)
+    && /\b(frontend|react|next|nextjs|ui|component|modal|api integration)\b/.test(skillText)) {
+    return 0.32;
+  }
+  if (isExpoRuntimeTask(normalizedPrompt, projectTokens)
+    && /\b(expo|eas|nativewind|react native|tailwind)\b/.test(skillText)) {
+    return 0.46;
+  }
+  if (isNextAppRouterTask(normalizedPrompt)
+    && /\b(next|nextjs)\b/.test(skillText)
+    && /\b(app router|router|routing|server components)\b/.test(skillText)) {
+    return 0.5;
+  }
+  if (/\beas\b/.test(normalizedPrompt)
+    && /\b(eas|expo)\b/.test(skillText)
+    && /\b(cicd|workflow|workflows|build|deploy|deployment|pipeline|pipelines)\b/.test(skillText)) {
+    return 0.28;
+  }
+  if (/\b(webapp|frontend|ui|dashboard|button|page|component|app|router)\b/.test(normalizedPrompt)
+    && /\b(frontend|react|next|nextjs|ui|component|tailwind|app router)\b/.test(skillText)) {
+    return 0.36;
+  }
+  if (/\b(role|admin|creator|permission|permissions|authorization|access)\b/.test(normalizedPrompt)
+    && /\b(auth|authentication|authorization|permission|permissions|access|rbac)\b/.test(skillText)) {
+    return 0.32;
+  }
+  return 0;
+}
+
+function skillRelevancePriority(normalizedPrompt, enriched, projectTokens = new Set()) {
+  const skillText = normalize(`${enriched.name} ${enriched.description}`);
+  const skillName = normalize(enriched.name);
+  let priority = 0;
+  if (isMcpRelevantTask(normalizedPrompt, projectTokens)) {
+    if (skillName === "mcp builder") priority += 760;
+    if (skillName === "mcp management") priority += 740;
+    if (skillName === "mcp tool developer") priority += 720;
+    if (skillName === "agent memory mcp") priority += 700;
+    if (skillName === "agent tool builder" || skillName === "context agent") priority += 260;
+    if (/\b(mcp|model context protocol|modelcontextprotocol)\b/.test(skillText)) priority += 160;
+  }
+  if (isCommerceTask(normalizedPrompt)) {
+    if (/\b(payment integration|stripe integration|paypal integration)\b/.test(skillText)) priority += 520;
+    if (/\bbilling automation\b/.test(skillText)) priority += 430;
+    if (/\b(payment|payments|checkout|billing|wallet|balance|stripe|paypal|commerce|monetization)\b/.test(skillText)) priority += 160;
+    if (!/\bstripe\b/.test(normalizedPrompt) && /\bstripe\b/.test(skillText)) priority -= 520;
+    if (!/\bpaypal\b/.test(normalizedPrompt) && /\bpaypal\b/.test(skillText)) priority -= 520;
+    if (!/\bsquare\b/.test(normalizedPrompt) && /\bsquare\b/.test(skillText)) priority -= 440;
+    if (/\b(mcp|metasploit|penetration|exploit|bug bounty)\b/.test(skillText)) priority -= 500;
+  }
+  if (isContentAccessTask(normalizedPrompt)) {
+    if (/\b(api endpoint builder|backend development|backend architect|frontend api integration patterns)\b/.test(skillText)) priority += 260;
+    if (/\b(auth implementation patterns|authorization|permission|permissions|access|rbac)\b/.test(skillText)) priority += 120;
+  }
+  if (isNotificationTask(normalizedPrompt)) {
+    if (/\bsendblue notify\b/.test(skillText)) priority += 140;
+    if (/\b(notification|notifications|notify|message|sms|email|event|webhook)\b/.test(skillText)) priority += 90;
+  }
+  if (isFrontendCheckoutTask(normalizedPrompt)) {
+    if (/\bfrontend api integration patterns\b/.test(skillText)) priority += 220;
+    if (/\breact nextjs development|nextjs best practices|nextjs app router patterns|frontend developer\b/.test(skillText)) priority += 90;
+  }
+  if (isExpoRuntimeTask(normalizedPrompt, projectTokens)) {
+    if (/\bexpo deployment\b/.test(skillText)) priority += 900;
+    if (/\bbuilding native ui\b/.test(skillText)) priority += 760;
+    if (/\bexpo tailwind setup\b/.test(skillText)) priority += 620;
+    if (/\bexpo\b/.test(skillText) && /\b(qr|expo go|run|running|start|connect|eas|deployment|build)\b/.test(skillText)) priority += 220;
+    if (/\bnativewind|tailwind\b/.test(skillText) && projectTokens.has("nativewind")) priority += 120;
+    if (/\b(next|nextjs|frontend designer|dark themed|glassmorphism|framer motion)\b/.test(skillText)) priority -= 160;
+  }
+  if (isNextAppRouterTask(normalizedPrompt)) {
+    if (/\bnextjs app router patterns\b/.test(skillText)) priority += 600;
+    if (/\bnextjs best practices\b/.test(skillText)) priority += 560;
+    if (/\breact nextjs development\b/.test(skillText)) priority += 420;
+    if (/\b(next|nextjs)\b/.test(skillText) && /\b(app router|router|routing|server components)\b/.test(skillText)) priority += 100;
+    if (/\b(next|nextjs)\b/.test(skillText) && /\breact\b/.test(skillText)) priority += 70;
+    if (/\b(glassmorphism|dark themed|dark theme|framer motion)\b/.test(skillText)) priority -= 40;
+  }
+  if (/\b(role|admin|creator|permission|permissions|authorization|access)\b/.test(normalizedPrompt)
+    && /\b(auth|authentication|authorization|permission|permissions|access|rbac)\b/.test(skillText)) {
+    priority += 55;
+  }
+  return priority;
+}
+
+function isNextAppRouterTask(normalizedPrompt) {
+  return /\bwebapp\b.*\bsrc\b.*\bapp\b/.test(normalizedPrompt)
+    || /\b(next|nextjs)\b.*\b(app router|router|routing)\b/.test(normalizedPrompt)
+    || /\bapp router\b/.test(normalizedPrompt);
+}
+
+function isExpoRuntimeTask(normalizedPrompt, projectTokens = new Set()) {
+  const expoProject = projectTokens.has("expo") || projectTokens.has("nativewind") || projectTokens.has("eas");
+  if (!expoProject) return false;
+  return /\b(qr|connect|run|start|expo go|device|metro|tunnel|lan)\b/.test(normalizedPrompt);
+}
+
+function isCommerceTask(normalizedPrompt) {
+  return /\b(purchase|purchased|buy|buyer|seller|payment|pay|checkout|wallet|balance|top up|topup|funded|billing|invoice)\b/.test(normalizedPrompt);
+}
+
+function isContentAccessTask(normalizedPrompt) {
+  return /\b(content access service|content access|access permissions|grant access|permissions|library|resources|tutorials|collections)\b/.test(normalizedPrompt);
+}
+
+function isNotificationTask(normalizedPrompt) {
+  return /\b(notification|notifications|notify|buyer|seller)\b/.test(normalizedPrompt);
+}
+
+function isFrontendCheckoutTask(normalizedPrompt) {
+  return /\b(modal|display|show|checkout|library|frontend|webapp|page|button)\b/.test(normalizedPrompt);
+}
+
+function isMcpTask(normalizedPrompt) {
+  return /\b(mcp|model context protocol|tool server|tools server|server tool|bridge|proxy)\b/.test(normalizedPrompt);
+}
+
+function isMcpRelevantTask(normalizedPrompt, projectTokens = new Set()) {
+  return isMcpTask(normalizedPrompt)
+    || (isMcpProject(projectTokens) && isContextRetrievalTask(normalizedPrompt));
+}
+
+function isMcpProject(projectTokens = new Set()) {
+  return projectTokens.has("mcp") || projectTokens.has("modelcontextprotocol");
+}
+
+function isContextRetrievalTask(normalizedPrompt) {
+  return /\b(suggest|suggested|suggestion|skills|files|context|retrieval|retrieve|scorer|scoring|match|matching|prompt|hook|inject|injection)\b/.test(normalizedPrompt);
+}
+
+function isSecurityTask(normalizedPrompt) {
+  return /\b(security|pentest|penetration|exploit|vulnerability|metasploit|bug bounty|owasp|xss|csrf|attack|audit)\b/.test(normalizedPrompt);
+}
+
+function isMcpSkill(skillText) {
+  return /\bmcp\b|\bmodel context protocol\b/.test(skillText);
+}
+
+function isOffensiveSecuritySkill(skillText) {
+  return /\b(metasploit|penetration testing|bug bounty|exploit|exploitation|privilege escalation|ethical hacking|web fuzzing|security assessment)\b/.test(skillText);
+}
+
+function isPlatformCommerceSkill(skillText) {
+  return /\b(wordpress|woocommerce|shopify|odoo)\b/.test(skillText);
+}
+
+function isPlatformCommerceTask(normalizedPrompt, skillText) {
+  if (/\bwordpress\b/.test(skillText)) return /\bwordpress\b/.test(normalizedPrompt);
+  if (/\bwoocommerce\b/.test(skillText)) return /\bwoocommerce\b/.test(normalizedPrompt);
+  if (/\bshopify\b/.test(skillText)) return /\bshopify\b/.test(normalizedPrompt);
+  if (/\bodoo\b/.test(skillText)) return /\bodoo\b/.test(normalizedPrompt);
+  return true;
+}
+
+export function projectSkillHints({ cwd = process.cwd() } = {}) {
+  const hints = new Set();
+  const packagePaths = workspacePackagePaths(cwd);
+
+  for (const packagePath of packagePaths) {
+    const packageDir = path.dirname(packagePath);
+    const packageJson = readJson(packagePath);
+    addHintText(hints, JSON.stringify({
+      name: packageJson?.name,
+      description: packageJson?.description,
+      keywords: packageJson?.keywords || [],
+      scripts: packageJson?.scripts || {},
+      dependencies: Object.keys(packageJson?.dependencies || {}),
+      devDependencies: Object.keys(packageJson?.devDependencies || {})
+    }));
+    for (const fileName of ["app.json", "app.config.js", "app.config.ts", "eas.json"]) {
+      if (fs.existsSync(path.join(packageDir, fileName))) addHintText(hints, fileName);
+    }
+  }
+  return [...hints];
+}
+
+function workspacePackagePaths(cwd) {
+  const rootPackagePath = path.join(cwd, "package.json");
+  const rootPackage = readJson(rootPackagePath);
+  const paths = new Set([rootPackagePath]);
+  for (const workspace of workspacePatterns(rootPackage?.workspaces)) {
+    for (const packagePath of expandWorkspacePattern({ cwd, pattern: workspace })) {
+      paths.add(packagePath);
+    }
+  }
+  return [...paths];
+}
+
+function workspacePatterns(workspaces) {
+  if (Array.isArray(workspaces)) return workspaces.filter((item) => typeof item === "string");
+  if (Array.isArray(workspaces?.packages)) return workspaces.packages.filter((item) => typeof item === "string");
+  return [];
+}
+
+function expandWorkspacePattern({ cwd, pattern }) {
+  const normalized = String(pattern || "").replace(/\\/g, "/").replace(/\/+$/g, "");
+  if (!normalized || normalized.startsWith("..") || path.isAbsolute(normalized)) return [];
+  if (!normalized.includes("*")) {
+    const packagePath = path.join(cwd, normalized, "package.json");
+    return fs.existsSync(packagePath) ? [packagePath] : [];
+  }
+  const parts = normalized.split("/");
+  const starIndex = parts.indexOf("*");
+  if (starIndex < 0 || parts.includes("**")) return [];
+  const baseDir = path.join(cwd, ...parts.slice(0, starIndex));
+  const suffix = parts.slice(starIndex + 1);
+  let entries = [];
+  try {
+    entries = fs.readdirSync(baseDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries
+    .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+    .map((entry) => path.join(baseDir, entry.name, ...suffix, "package.json"))
+    .filter((packagePath) => fs.existsSync(packagePath));
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function addHintText(hints, value) {
+  for (const token of normalize(value).split(/\s+/).filter(Boolean)) hints.add(token);
+}
+
 function enrichSkill(skill) {
   const name = String(skill.name || "");
   const description = truncateDescription(skill.description || "");
@@ -268,3 +583,10 @@ function enrichSkill(skill) {
 function normalize(value) {
   return String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
 }
+
+function normalizePrompt(value) {
+  return normalize(String(value || "")
+    .replace(/https?:\/\/\S+/gi, " ")
+    .replace(/giao\s+di[eệ]n/gi, "frontend ui")
+    .replace(/phan\s+quyen/gi, "authorization role"));
+}

package/plugins/ctx/lib/skillshare-sync.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import readline from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { execFileSync, execSync, spawn } from "node:child_process";
+import { shellInvocation } from "./shell-runner.js";
 
 const DEFAULT_AGENTS = ["codex", "claude", "antigravity", "copilot"];
 const INSTALL_SH_URL = "https://raw.githubusercontent.com/runkids/skillshare/main/install.sh";
@@ -141,7 +142,8 @@ export async function installSkillshare({
     if (osName === "windows") {
       await spawnShellStreaming("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", `irm ${INSTALL_PS_URL} | iex`]);
     } else {
-      await spawnShellStreaming("sh", ["-c", `curl -fsSL ${INSTALL_SH_URL} | sh`]);
+      const shell = shellInvocation(`curl -fsSL ${INSTALL_SH_URL} | sh`, { platform: process.platform });
+      await spawnShellStreaming(shell.command, shell.args);
     }
   }
 
@@ -206,14 +208,52 @@ export function detectExistingSkills({ cwd = process.cwd(), home = os.homedir()
     .filter((entry) => entry.count > 0);
 }
 
+export function repairSkillSymlinks({
+  cwd = process.cwd(),
+  home = os.homedir(),
+  roots = skillRoots({ cwd, home }),
+  dryRun = false
+} = {}) {
+  const repaired = [];
+  const removedBroken = [];
+  for (const root of roots) {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isSymbolicLink()) continue;
+      const linkPath = path.join(root, entry.name);
+      const real = safeRealpath(linkPath);
+      if (!real) {
+        if (!dryRun) fs.rmSync(linkPath, { force: true, recursive: true });
+        removedBroken.push(linkPath);
+        continue;
+      }
+      if (!dryRun) {
+        fs.rmSync(linkPath, { force: true, recursive: true });
+        const stat = fs.statSync(real);
+        if (stat.isDirectory()) copyDirectory(real, linkPath);
+        else if (stat.isFile()) fs.copyFileSync(real, linkPath);
+      }
+      repaired.push(linkPath);
+    }
+  }
+  return { repaired: [...new Set(repaired)], removedBroken: [...new Set(removedBroken)] };
+}
+
 function skillRoots({ cwd, home }) {
   return uniquePaths([
     path.join(home, ".claude", "skills"),
     path.join(home, ".codex", "skills"),
+    path.join(home, ".agents", "skills"),
     path.join(home, ".gemini", "antigravity", "skills"),
     path.join(home, ".gemini", "antigravity-cli", "skills"),
     path.join(cwd, ".claude", "skills"),
     path.join(cwd, ".codex", "skills"),
+    path.join(cwd, ".agents", "skills"),
     path.join(cwd, ".gemini", "antigravity", "skills"),
     path.join(cwd, ".gemini", "antigravity-cli", "skills"),
     ...discoverSkillRoots({ cwd, home })
@@ -236,9 +276,11 @@ export function discoverSkillRoots({ cwd = process.cwd(), home = os.homedir() }
     path.join(home, ".gemini"),
     path.join(home, ".codex"),
     path.join(home, ".claude"),
+    path.join(home, ".agents"),
     path.join(cwd, ".gemini"),
     path.join(cwd, ".codex"),
-    path.join(cwd, ".claude")
+    path.join(cwd, ".claude"),
+    path.join(cwd, ".agents")
   ]) {
     findSkillRoots(base, 0, roots);
   }
@@ -436,6 +478,13 @@ export async function syncSkills({
   }
 
   if (!options.noCollect) {
+    const repaired = repairSkillSymlinks({ cwd, home, dryRun: options.dryRun });
+    if (repaired.repaired.length || repaired.removedBroken.length) {
+      logger(statusLine("Repairing skill symlinks...", options.dryRun
+        ? `dry-run (${repaired.repaired.length} would copy, ${repaired.removedBroken.length} broken)`
+        : `✓ ${repaired.repaired.length} copied, ${repaired.removedBroken.length} broken removed`));
+    }
+
     const legacy = collectAntigravityLegacySkills({ cwd, home, dryRun: options.dryRun });
     if (legacy.copied.length || legacy.skipped.length) {
       const value = options.dryRun

package/plugins/ctx/lib/stop-hook.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 
 import { appendJsonLine, readJsonFile, writeJsonFile } from "./fs-utils.js";
 import { readGitSnapshot, checkCompliance } from "./measure.js";
-import { buildReport, formatReport } from "./reporter.js";
+import { buildReport } from "./reporter.js";
 import { loadRuntimeEvidence } from "./telemetry.js";
 import { filterActionableRules } from "./analyzer.js";
 import { resolveHookCwd } from "./hook-io.js";
@@ -54,7 +54,6 @@ export function handleStopPayload(payload, { contextPath, reportPath, historyPat
   if (historyPath) appendJsonLine(historyPath, report);
 
   return {
-    continue: true,
-    systemMessage: formatReport(report)
+    continue: true
   };
 }