@gobing-ai/superskill 0.1.7 → 0.1.8

package/dist/index.js

@@ -9317,7 +9317,7 @@ function hashContent(filePath) {
 var init_hash = () => {};
 
 // ../../packages/core/src/content/identity.ts
-import { existsSync } from "fs";
+import { existsSync, statSync } from "fs";
 import { basename, dirname, extname, join } from "path";
 import { cwd } from "process";
 function resolveContentName(path) {
@@ -9333,10 +9333,21 @@ function resolveContentName(path) {
 }
 function resolveContentPath(type, name, opts) {
   if (name.includes("/") || name.includes("\\")) {
-    if (existsSync(name))
-      return name;
+    if (existsSync(name)) {
+      const st = statSync(name);
+      if (st.isDirectory()) {
+        const skillMd = join(name, "SKILL.md");
+        if (existsSync(skillMd))
+          return skillMd;
+      } else {
+        return name;
+      }
+    }
   }
   const base = opts?.baseDir ?? cwd();
+  const asIs = join(base, name);
+  if (existsSync(asIs) && statSync(asIs).isFile())
+    return asIs;
   const direct = join(base, `${name}.md`);
   if (existsSync(direct))
     return direct;
@@ -9710,7 +9721,7 @@ var init_adapt_subagent = __esm(() => {
 });
 
 // ../../packages/core/src/mapper.ts
-import { existsSync as existsSync3, mkdirSync, readdirSync, readFileSync as readFileSync2, statSync, writeFileSync } from "fs";
+import { existsSync as existsSync3, mkdirSync, readdirSync, readFileSync as readFileSync2, statSync as statSync2, writeFileSync } from "fs";
 import { join as join3 } from "path";
 function mapPluginToRulesync(pluginPath, pluginName, outputDir) {
   assertSafePathSegment(pluginName, "plugin name");
@@ -9833,7 +9844,7 @@ function copyAndRewriteDirectory(source, destination, pluginName) {
   for (const entry of readdirSync(source)) {
     const srcPath = join3(source, entry);
     const destPath = join3(destination, entry);
-    if (statSync(srcPath).isDirectory()) {
+    if (statSync2(srcPath).isDirectory()) {
       copyAndRewriteDirectory(srcPath, destPath, pluginName);
     } else {
       const content = readFileSync2(srcPath, "utf-8");
@@ -13814,7 +13825,7 @@ var init_zod = __esm(() => {
 });
 
 // ../../packages/core/src/marketplace.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
 import { join as join4, resolve } from "path";
 function resolvePlugin(marketplacePath, pluginName) {
   let manifestPath = null;
@@ -13861,8 +13872,19 @@ function resolvePlugin(marketplacePath, pluginName) {
   const marketplaceRoot = resolve(manifestPath, "..", "..");
   const pluginRootBase = manifest.metadata?.pluginRoot ?? "";
   const pluginRoot = resolve(marketplaceRoot, pluginRootBase, source);
-  if (!existsSync4(join4(pluginRoot, "plugin.json"))) {
-    throw new Error(`plugin.json not found in resolved plugin root: ${pluginRoot}`);
+  let dirents;
+  try {
+    dirents = readdirSync2(pluginRoot);
+  } catch {
+    throw new Error(`Plugin root not found: ${pluginRoot}`);
+  }
+  const hasSkills = dirents.includes("skills");
+  const hasCommands = dirents.includes("commands");
+  const hasAgents = dirents.includes("agents");
+  const hasHooksDir = dirents.includes("hooks");
+  const hasHooksFile = dirents.includes("hooks.json");
+  if (!(hasSkills || hasCommands || hasAgents || hasHooksDir || hasHooksFile)) {
+    throw new Error(`No recognizable plugin content (skills/, commands/, agents/, hooks/, hooks.json) in: ${pluginRoot}`);
   }
   return { pluginRoot, marketplaceRoot, source };
 }
@@ -14013,7 +14035,7 @@ var init_migrate = __esm(() => {
 });
 
 // ../../packages/core/src/operations/package.ts
-import { cpSync, existsSync as existsSync6, mkdirSync as mkdirSync3, statSync as statSync2 } from "fs";
+import { cpSync, existsSync as existsSync6, mkdirSync as mkdirSync3, statSync as statSync3 } from "fs";
 import { basename as basename2, dirname as dirname3, join as join5 } from "path";
 import { cwd as cwd3 } from "process";
 function resolveSkillDir(name) {
@@ -14021,7 +14043,7 @@ function resolveSkillDir(name) {
   if (!skillPath) {
     throw Object.assign(new Error(`Skill not found: ${name}`), { code: "ENOENT" });
   }
-  const dir = statSync2(skillPath).isDirectory() ? skillPath : dirname3(skillPath);
+  const dir = statSync3(skillPath).isDirectory() ? skillPath : dirname3(skillPath);
   return { dir, name: basename2(dir) };
 }
 function copyDirIfExists(src, dest) {
@@ -14122,10 +14144,10 @@ var init_types2 = __esm(() => {
   VAGUE_KEYWORDS = ["maybe", "perhaps", "might", "could be", "probably"];
   REQUIRED_FIELDS = {
     skill: ["name", "description"],
-    command: ["name", "description"],
+    command: ["description"],
     agent: ["name", "description", "model", "tools"],
-    hook: ["name", "description", "event"],
-    magent: ["name", "description"]
+    hook: [],
+    magent: []
   };
 });
 
@@ -14224,89 +14246,172 @@ var init_heuristics = __esm(() => {
 });
 
 // ../../packages/core/src/quality/hook.ts
-function scoreCorrectness(data) {
-  const raw = data.event;
-  let base;
-  let note;
-  if (typeof raw === "string" && raw.trim().length > 0) {
-    const event = raw.trim();
-    if (KNOWN_HOOK_EVENTS.includes(event)) {
-      base = 1;
-      note = `Valid event: ${event}`;
-    } else {
-      base = 0.5;
-      note = `Unknown event: ${event}`;
+function parseHookEntries(raw) {
+  if (typeof raw !== "object" || raw === null)
+    return null;
+  const data = raw;
+  const hooks = data.hooks;
+  if (typeof hooks !== "object" || hooks === null)
+    return null;
+  const entries = [];
+  for (const [event, matcherBlocks] of Object.entries(hooks)) {
+    if (!Array.isArray(matcherBlocks))
+      continue;
+    for (const block of matcherBlocks) {
+      if (typeof block !== "object" || block === null)
+        continue;
+      const subHooks = block.hooks;
+      if (!Array.isArray(subHooks))
+        continue;
+      for (const h of subHooks) {
+        if (typeof h !== "object" || h === null)
+          continue;
+        entries.push({
+          event,
+          matcher: typeof block.matcher === "string" ? block.matcher : "",
+          command: typeof h.command === "string" ? h.command : "",
+          type: typeof h.type === "string" ? h.type : "",
+          timeout: typeof h.timeout === "number" ? h.timeout : undefined
+        });
+      }
     }
-  } else {
-    base = 0;
-    note = "Missing event field";
-  }
-  if (data.enabled === true) {
-    base = clamp(base + 0.1);
   }
-  return { score: clamp(base), note };
-}
-function scoreEventCoverage(data, body) {
-  const eventName = typeof data.event === "string" ? data.event.trim() : "";
-  const mentionsEventName = eventName.length > 0 && body.toLowerCase().includes(eventName.toLowerCase()) ? 1 : 0;
-  const density = keywordDensity(body, ["event", "intercept", "trigger", "when", "condition", "match"]);
-  const score = 0.5 * mentionsEventName + 0.5 * density;
-  const note = score >= 0.5 ? "Event coverage described" : "Minimal event description";
-  return { score: clamp(score), note };
-}
-function scoreSafety(body) {
-  const density = keywordDensity(body, [
-    "safety",
-    "secure",
-    "gated",
-    "approval",
-    "explicit",
-    "dangerous",
-    "destructive",
-    "block"
-  ]);
-  const note = density >= 0.2 ? "Includes safety considerations" : "No safety gates described";
-  return { score: clamp(density), note };
+  return entries.length > 0 ? entries : null;
 }
-function scorePatternMatchQuality(body) {
-  const hasSpecificGlob = /\*\.[a-z]+\b/i.test(body);
-  const patternDensity = keywordDensity(body, ["match", "pattern", "regex", "glob"]);
-  let score;
-  let note;
-  if (hasSpecificGlob) {
-    score = 0.9;
-    note = "Specific match patterns";
-  } else if (patternDensity > 0) {
-    score = 0.3;
-    note = "Broad/unspecific patterns";
-  } else {
-    score = 0;
-    note = "No match patterns";
+function scoreCorrectness(entries) {
+  let valid = 0;
+  for (const e of entries) {
+    if (e.type === "command" && e.command.length > 0 && e.matcher.length > 0)
+      valid++;
   }
+  const score = entries.length > 0 ? clamp(valid / entries.length) : 0;
+  const note = `${valid}/${entries.length} entries valid`;
+  return { score, note };
+}
+function scoreEventCoverage(entries) {
+  const events = new Set(entries.map((e) => e.event));
+  const covered = KNOWN_HOOK_EVENTS.filter((e) => events.has(e)).length;
+  const score = clamp(Math.min(events.size / 3, 1));
+  const note = `${covered} of ${KNOWN_HOOK_EVENTS.length} known events covered (${events.size} total)`;
   return { score, note };
 }
+function scoreSafety(entries) {
+  const dangerousPatterns = [
+    { re: /rm\s+-rf/i, label: "rm -rf" },
+    { re: /\b(?:curl|wget|fetch)\b.*\|\s*(?:ba|z)?sh\b/i, label: "download pipe to shell" },
+    { re: /--no-verify/i, label: "--no-verify bypass" },
+    { re: /\beval\b/i, label: "eval" },
+    { re: /sudo\b/i, label: "sudo" },
+    { re: /chmod\s+777/i, label: "chmod 777" },
+    { re: /\$\([^)]*\)/, label: "unquoted command substitution" },
+    { re: /`[^`]+`/, label: "backtick execution" }
+  ];
+  const findings = [];
+  let dangerous = 0;
+  for (const e of entries) {
+    for (const { re, label } of dangerousPatterns) {
+      if (re.test(e.command)) {
+        dangerous++;
+        findings.push(`[${e.event}] ${label}: ${e.command.slice(0, 60)}`);
+      }
+    }
+  }
+  const base = entries.length > 0 ? 1 - dangerous / (entries.length * 2) : 0;
+  const score = clamp(Math.max(base, 0.1));
+  const note = dangerous === 0 ? "No dangerous command patterns found" : `${dangerous} dangerous pattern(s) found`;
+  const recs = dangerous > 0 ? ["Replace dangerous patterns with safe alternatives; add explicit approval gates"] : undefined;
+  return { score, note, findings: findings.length > 0 ? findings : undefined, recommendations: recs };
+}
+function scorePatternMatchQuality(entries) {
+  let specificMatchers = 0;
+  let hasTimeout = 0;
+  let portable = 0;
+  for (const e of entries) {
+    if (e.matcher !== "*" && e.matcher.length > 0)
+      specificMatchers++;
+    if (e.timeout !== undefined && e.timeout > 0)
+      hasTimeout++;
+    if (/\$\{CLAUDE_PLUGIN_ROOT\}/.test(e.command) || !/^\//.test(e.command.trim()))
+      portable++;
+  }
+  const n = entries.length || 1;
+  const matcherScore = specificMatchers / n;
+  const timeoutScore = hasTimeout / n;
+  const portableScore = portable / n;
+  const score = clamp(0.3 * matcherScore + 0.4 * timeoutScore + 0.3 * portableScore);
+  const noteParts = [];
+  if (specificMatchers < n)
+    noteParts.push(`${n - specificMatchers} broad matcher(s)`);
+  if (hasTimeout < n)
+    noteParts.push(`${n - hasTimeout} missing timeout`);
+  if (portable < n)
+    noteParts.push(`${n - portable} non-portable path(s)`);
+  const findings = noteParts.length > 0 ? noteParts.map((p) => p) : undefined;
+  const recs = noteParts.length > 0 ? [
+    "Use specific matchers instead of *; add timeout to every hook; use CLAUDE_PLUGIN_ROOT env var for paths"
+  ] : undefined;
+  return {
+    score,
+    note: noteParts.length > 0 ? noteParts.join("; ") : "All entries specific, timed, and portable",
+    findings,
+    recommendations: recs
+  };
+}
 function evaluateHook(content, target) {
-  const parsed = parseFrontmatterSafe(content);
-  const data = parsed ?? {};
-  const body = extractBody(content);
-  const isParseError = parsed === null;
-  const dimensions = (() => {
-    if (isParseError) {
-      const errNote = parseErrorNote(content, "Frontmatter parse error");
+  const isJson = target.endsWith(".json") || /^\s*\{/.test(content);
+  if (isJson) {
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
       return {
-        correctness: { score: 0.1, note: errNote },
-        "event-coverage": { score: 0, note: errNote },
-        safety: { score: 0, note: errNote },
-        "pattern-match-quality": { score: 0, note: errNote }
+        type: "hook",
+        target,
+        content: "",
+        aggregate: 0,
+        dimensions: {
+          correctness: { score: 0, note: "Invalid JSON: parse error" },
+          "event-coverage": { score: 0, note: "Invalid JSON: parse error" },
+          safety: { score: 0, note: "Invalid JSON: parse error" },
+          "pattern-match-quality": { score: 0, note: "Invalid JSON: parse error" }
+        }
       };
     }
+    const entries = parseHookEntries(parsed);
+    if (!entries || entries.length === 0) {
+      return {
+        type: "hook",
+        target,
+        content: "",
+        aggregate: 0,
+        dimensions: {
+          correctness: { score: 0, note: "No hook entries found in JSON" },
+          "event-coverage": { score: 0, note: "No hook entries found in JSON" },
+          safety: { score: 0, note: "No hook entries found in JSON" },
+          "pattern-match-quality": { score: 0, note: "No hook entries found in JSON" }
+        }
+      };
+    }
+    const dimensions2 = {
+      correctness: scoreCorrectness(entries),
+      "event-coverage": scoreEventCoverage(entries),
+      safety: scoreSafety(entries),
+      "pattern-match-quality": scorePatternMatchQuality(entries)
+    };
     return {
-      correctness: scoreCorrectness(data),
-      "event-coverage": scoreEventCoverage(data, body),
-      safety: scoreSafety(body),
-      "pattern-match-quality": scorePatternMatchQuality(body)
+      type: "hook",
+      target,
+      content: "",
+      aggregate: computeAggregate(dimensions2),
+      dimensions: dimensions2
     };
-  })();
+  }
+  const dimensions = {
+    correctness: { score: 0, note: "Markdown hook definitions not supported; use hooks.json" },
+    "event-coverage": { score: 0, note: "Markdown hook definitions not supported; use hooks.json" },
+    safety: { score: 0, note: "Markdown hook definitions not supported; use hooks.json" },
+    "pattern-match-quality": { score: 0, note: "Markdown hook definitions not supported; use hooks.json" }
+  };
   return {
     type: "hook",
     target,
@@ -14333,8 +14438,34 @@ var init_hook = __esm(() => {
 });
 
 // ../../packages/core/src/operations/validate.ts
-import { existsSync as existsSync8, statSync as statSync3 } from "fs";
-import { dirname as dirname4 } from "path";
+import { existsSync as existsSync8, statSync as statSync4 } from "fs";
+import { dirname as dirname4, join as join7 } from "path";
+function checkBodyLinks(body, baseDir) {
+  const findings = [];
+  const linkRe = /\[([^\]]*)\]\(([^)]+)\)/g;
+  for (const match of body.matchAll(linkRe)) {
+    const linkText = match[1];
+    const target = match[2];
+    if (!target)
+      continue;
+    if (/^#/.test(target))
+      continue;
+    if (/^[a-z][a-z0-9+.-]*:/i.test(target))
+      continue;
+    const filePart = target.split(/[#?]/)[0];
+    if (!filePart)
+      continue;
+    const resolved = join7(baseDir, filePart);
+    if (!existsSync8(resolved)) {
+      findings.push({
+        severity: "warning",
+        field: "_links",
+        message: `Broken body link: [${linkText}](${target}) \u2192 target not found: ${resolved}`
+      });
+    }
+  }
+  return findings;
+}
 async function validate(type, nameOrPath, opts) {
   const resolvedPath = resolveContentPath(type, nameOrPath);
   if (!resolvedPath) {
@@ -14345,7 +14476,7 @@ async function validate(type, nameOrPath, opts) {
   }
   let stat;
   try {
-    stat = statSync3(resolvedPath);
+    stat = statSync4(resolvedPath);
   } catch {
     return sentinelResult(`File not found: ${resolvedPath}`);
   }
@@ -14365,10 +14496,17 @@ async function validate(type, nameOrPath, opts) {
     return sentinelResult(`Cannot read file: ${resolvedPath}`);
   }
   const baseDir = dirname4(resolvedPath);
-  return _validateContent(type, content, {
+  const result = _validateContent(type, content, {
     ...opts,
     referenceChecker: (refType, refName) => resolveContentPath(refType, refName, { baseDir }) !== null
   });
+  const bodyStart = content.indexOf(`
+---
+`);
+  const body = bodyStart >= 0 ? content.slice(bodyStart + 5) : content;
+  const linkFindings = checkBodyLinks(body, baseDir);
+  result.findings.push(...linkFindings);
+  return result;
 }
 function _validateContent(type, content, opts) {
   const findings = [];
@@ -32208,7 +32346,7 @@ var init_config = __esm(() => {
 });
 
 // ../../node_modules/.bun/@gobing-ai+ts-runtime@0.3.21/node_modules/@gobing-ai/ts-runtime/dist/file-system-node.js
-import { appendFileSync, cpSync as cpSync2, createWriteStream, existsSync as existsSync9, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync6, renameSync, rmSync as rmSync2, statSync as statSync4, writeFileSync as writeFileSync4 } from "fs";
+import { appendFileSync, cpSync as cpSync2, createWriteStream, existsSync as existsSync9, mkdirSync as mkdirSync5, readdirSync as readdirSync3, readFileSync as readFileSync6, renameSync, rmSync as rmSync2, statSync as statSync5, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname5, resolve as resolvePath } from "path";
 function createNodeFileSystem(root) {
   const projectRoot = root ?? findProjectRoot(process.cwd());
@@ -32228,7 +32366,7 @@ function createNodeFileSystem(root) {
     ensureDir: (path) => {
       mkdirSync5(path, { recursive: true });
     },
-    readDir: (path) => readdirSync2(path),
+    readDir: (path) => readdirSync3(path),
     deleteFile: (path) => {
       rmSync2(path, { recursive: true, force: true });
     },
@@ -32244,7 +32382,7 @@ function createNodeFileSystem(root) {
     },
     stat: (path) => {
       try {
-        const s = statSync4(path);
+        const s = statSync5(path);
         return {
           isFile: () => s.isFile(),
           isDirectory: () => s.isDirectory(),
@@ -34872,7 +35010,7 @@ var init_encoding_option = __esm(() => {
 });
 
 // ../../node_modules/.bun/execa@9.6.1/node_modules/execa/lib/arguments/cwd.js
-import { statSync as statSync5 } from "fs";
+import { statSync as statSync6 } from "fs";
 import path4 from "path";
 import process6 from "process";
 var normalizeCwd = (cwd5 = getDefaultCwd()) => {
@@ -34892,7 +35030,7 @@ ${error51.message}`;
   }
   let cwdStat;
   try {
-    cwdStat = statSync5(cwd5);
+    cwdStat = statSync6(cwd5);
   } catch (error51) {
     return `The "cwd" option is invalid: ${cwd5}.
 ${error51.message}
@@ -40376,8 +40514,14 @@ function scoreCompleteness(data) {
   const required2 = REQUIRED_FIELDS.agent;
   const score = scorePresence(fieldsPresent, required2);
   const missing = required2.filter((f) => !fieldsPresent.includes(f));
-  const note = missing.length > 0 ? `Missing: ${missing.join(", ")}` : "All required fields present";
-  return { score: clamp(score), note };
+  const findings = missing.length > 0 ? [`Missing required fields: ${missing.join(", ")}`] : undefined;
+  const recs = missing.length > 0 ? ["Add the missing frontmatter fields"] : undefined;
+  return {
+    score: clamp(score),
+    note: missing.length > 0 ? `Missing: ${missing.join(", ")}` : "All required fields present",
+    findings,
+    recommendations: recs
+  };
 }
 function scoreRoleClarity(body) {
   const patterns = [/you are/i, /role/i, /specialist/i, /persona/i];
@@ -40404,7 +40548,9 @@ function scoreRoleClarity(body) {
   }
   const score = specificity ? clamp(base2 + 0.2) : base2;
   const note = matchCount >= 2 ? "Clear role defined" : matchCount === 1 ? "Role definition vague/generic" : "No role definition found";
-  return { score, note };
+  const findings = matchCount < 2 ? ["Role definition is vague, generic, or absent"] : undefined;
+  const recs = matchCount === 0 ? ['Add a role statement (e.g. "You are a ... specialist")'] : matchCount === 1 ? ["Add more role signals (specialist, persona, role scope)"] : undefined;
+  return { score, note, findings, recommendations: recs };
 }
 function scoreToolSelection(data) {
   const tools = data.tools;
@@ -40417,7 +40563,9 @@ function scoreToolSelection(data) {
   } else {
     score = 0.1;
   }
-  return { score, note: `${count2} tools selected` };
+  const findings = count2 < 3 ? [`Only ${count2} tool(s) selected \u2014 3+ recommended`] : undefined;
+  const recs = count2 === 0 ? ["Add at least 3 tools to the agent frontmatter"] : count2 < 3 ? ["Add more tools to cover the agent workflow"] : undefined;
+  return { score, note: `${count2} tools selected`, findings, recommendations: recs };
 }
 function scoreSkillLinkage(body) {
   const patterns = [/skill:/i, /skills:/i, /skill/i];
@@ -40437,7 +40585,13 @@ function scoreSkillLinkage(body) {
     score = 0;
     note = "No skill references";
   }
-  return { score, note };
+  let findings;
+  let recs;
+  if (score < 1) {
+    findings = ["Skill linkage is weak or missing"];
+    recs = score === 0.5 ? ["Use structured skill references (skill: or skills:) in the agent body"] : ["Add skill references to the agent body for delegated workflows"];
+  }
+  return { score, note, findings, recommendations: recs };
 }
 function scoreModelFit(data) {
   const model = data.model;
@@ -40460,7 +40614,16 @@ function scoreModelFit(data) {
     score = 0;
     note = "Model: missing";
   }
-  return { score, note };
+  let findings;
+  let recs;
+  if (score < 0.5) {
+    findings = ["Model field is missing or unrecognized"];
+    recs = ["Specify a valid model (e.g. inherit, claude-sonnet-4, claude-opus-4)"];
+  } else if (score === 0.5) {
+    findings = ["Model name appears ambiguous"];
+    recs = ["Use a recognized model alias (inherit, sonnet, opus, haiku) or well-formed name (claude-sonnet-4)"];
+  }
+  return { score, note, findings, recommendations: recs };
 }
 function evaluateAgent(content, target) {
   const data = parseFrontmatterSafe(content) ?? {};
@@ -40489,53 +40652,99 @@ var init_agent = __esm(() => {
 function scoreCompleteness2(data) {
   const fieldsPresent = Object.keys(data);
   const base2 = scorePresence(fieldsPresent, REQUIRED_FIELDS.command);
-  const argsFactor = Array.isArray(data.arguments) ? 1 : 0;
-  const score = clamp(base2 * (0.5 + 0.5 * argsFactor));
+  const hasArgHint = typeof data["argument-hint"] === "string" && data["argument-hint"].length > 0;
+  const hasAllowedTools = Array.isArray(data["allowed-tools"]) && data["allowed-tools"].length > 0;
+  const optBonus = (hasArgHint ? 0.1 : 0) + (hasAllowedTools ? 0.1 : 0);
+  const score = clamp(Math.min(base2 + optBonus, 1));
   const missing = [];
   for (const f of REQUIRED_FIELDS.command) {
     if (!(f in data))
       missing.push(f);
   }
   const note = missing.length > 0 ? `Missing fields: ${missing.join(", ")}` : "All required fields present";
-  return { score, note };
+  const findings = missing.length > 0 ? [`Missing required fields: ${missing.join(", ")}`] : undefined;
+  const recs = missing.includes("description") ? ["Add a description field to the command frontmatter"] : undefined;
+  return { score, note, findings, recommendations: recs };
 }
 function scoreClarity(body) {
   return scoreClarityFromDensities(body);
 }
 function scoreArgumentHints(data) {
-  const args = data.arguments;
-  if (!Array.isArray(args)) {
-    return { score: 0, note: "No arguments array found" };
+  const hasKey = "argument-hint" in data;
+  const argHint = data["argument-hint"];
+  if (!hasKey) {
+    return { score: 1, note: "No argument-hint (command takes no parameters)" };
   }
-  if (args.length === 0) {
-    return { score: 0, note: "0/0 arguments have hints" };
-  }
-  let withHints = 0;
-  for (const arg of args) {
-    if (typeof arg === "object" && arg !== null && "name" in arg && "description" in arg) {
-      withHints++;
-    }
+  if (typeof argHint !== "string" || argHint.trim().length === 0) {
+    return {
+      score: 0.4,
+      note: "Argument-hint declared but empty",
+      findings: ["Argument-hint is declared but empty"],
+      recommendations: [
+        "Add a descriptive argument-hint string with placeholder syntax, or remove the empty field"
+      ]
+    };
   }
-  const score = clamp(withHints / args.length);
-  return { score, note: `${withHints}/${args.length} arguments have hints` };
-}
-function scoreToolReferences(body) {
+  const hint = argHint.trim();
+  const hasPositional = /<[a-z][^>]*>/i.test(hint);
+  const hasFlags = /\[?--[a-z][^\s\]]*\]?/i.test(hint);
+  let score;
+  let note;
+  if (hasPositional && hasFlags) {
+    score = 1;
+    note = "Rich argument-hint with positional args and flags";
+  } else if (hasPositional || hasFlags) {
+    score = 0.75;
+    note = "Argument-hint present but could be more descriptive";
+  } else {
+    score = 0.4;
+    note = "Argument-hint is vague or placeholder-only";
+  }
+  let findings;
+  let recs;
+  if (score < 1 && score > 0.5) {
+    findings = ["Argument-hint could be more descriptive"];
+    recs = ["Add both positional args (<name>) and flags ([--flag <value>]) to the argument-hint"];
+  } else if (score <= 0.5) {
+    findings = ["Argument-hint is vague or missing for a parameterized command"];
+    recs = ["Add a descriptive argument-hint string with placeholder syntax"];
+  }
+  return { score, note, findings, recommendations: recs };
+}
+function scoreToolReferences(body, data) {
+  const allowedTools = data["allowed-tools"];
+  const toolCount = Array.isArray(allowedTools) ? allowedTools.length : 0;
   const structuredCount = (body.match(/\btools?:/gi) ?? []).length;
   const backtickCount = (body.match(/`[a-z][a-z0-9_-]*`/g) ?? []).length;
-  const weightedCount = structuredCount + Math.min(backtickCount, 1);
+  const bodyWeighted = structuredCount + Math.min(backtickCount, 1);
   let score;
   let note;
-  if (structuredCount >= 1 || weightedCount >= 2) {
+  if (toolCount >= 5) {
     score = 1;
-    note = "Uses tool references";
-  } else if (weightedCount === 1) {
-    score = 0.6;
+    note = `${toolCount} allowed-tools declared`;
+  } else if (toolCount >= 3) {
+    score = 0.9;
+    note = `${toolCount} allowed-tools declared`;
+  } else if (toolCount >= 1 || structuredCount >= 1 || bodyWeighted >= 2) {
+    score = 0.7;
+    note = toolCount > 0 ? `${toolCount} allowed-tools declared` : "Uses tool references";
+  } else if (bodyWeighted === 1) {
+    score = 0.4;
     note = "Limited tool references";
   } else {
     score = 0.1;
     note = "No tool references found";
   }
-  return { score, note };
+  let findings;
+  let recs;
+  if (score < 0.5) {
+    findings = ["No tool references found"];
+    recs = ["Add allowed-tools to frontmatter or reference tools in the command body"];
+  } else if (score < 0.8) {
+    findings = ["Limited tool references"];
+    recs = ["Declare all required tools in the allowed-tools frontmatter array"];
+  }
+  return { score, note, findings, recommendations: recs };
 }
 function scoreSlashSyntax(body, target) {
   const slashPattern = /\/[a-z][a-z-]*/g;
@@ -40562,7 +40771,7 @@ function evaluateCommand(content, target) {
     completeness: scoreCompleteness2(data),
     clarity: scoreClarity(body),
     "argument-hints": scoreArgumentHints(data),
-    "tool-references": scoreToolReferences(body),
+    "tool-references": scoreToolReferences(body, data),
     "slash-syntax": scoreSlashSyntax(body, target)
   };
   return {
@@ -40581,16 +40790,21 @@ var init_command3 = __esm(() => {
 // ../../packages/core/src/quality/magent.ts
 function scoreCompleteness3(body) {
   let found = 0;
-  for (const re of MAGENT_SECTIONS) {
+  for (const { re } of MAGENT_SECTIONS) {
     if (re.test(body))
       found++;
   }
+  const score = clamp(found / MAGENT_SECTIONS.length);
+  const findings = found < MAGENT_SECTIONS.length / 2 ? ["Config is missing key governance sections"] : undefined;
+  const recs = found < MAGENT_SECTIONS.length ? ["Add more governance sections (commands, verification, conventions, safety, docs)"] : undefined;
   return {
-    score: clamp(found / MAGENT_SECTIONS.length),
-    note: `${found}/${MAGENT_SECTIONS.length} sections present`
+    score,
+    note: `${found}/${MAGENT_SECTIONS.length} governance sections present`,
+    findings,
+    recommendations: recs
   };
 }
-function scorePlatformCoverage(data) {
+function scorePlatformCoverage(data, body) {
   const raw = data.platforms;
   let platforms = [];
   if (Array.isArray(raw)) {
@@ -40598,8 +40812,29 @@ function scorePlatformCoverage(data) {
   } else if (typeof raw === "string") {
     platforms = raw.split(",").map((s) => s.trim()).filter(Boolean);
   }
+  if (platforms.length === 0) {
+    const detected = [];
+    const platformPatterns = [
+      [/claude.?code/i, "claude-code"],
+      [/codex/i, "codex"],
+      [/gemini/i, "gemini"],
+      [/cursor/i, "cursor"],
+      [/windsurf/i, "windsurf"],
+      [/opencode/i, "opencode"],
+      [/openclaw/i, "openclaw"],
+      [/antigravity/i, "antigravity"],
+      [/pi\b/i, "pi"]
+    ];
+    for (const [re, name] of platformPatterns) {
+      if (re.test(body))
+        detected.push(name);
+    }
+    platforms = detected;
+  }
   const score = clamp(Math.min(platforms.length / 5, 1));
-  return { score, note: `${platforms.length} platforms covered` };
+  const findings = platforms.length === 0 ? ["No platforms declared or detected"] : platforms.length < 3 ? ["Limited platform coverage"] : undefined;
+  const recs = platforms.length < 3 ? ["Declare supported platforms in frontmatter (platforms:) or mention them in prose"] : undefined;
+  return { score, note: `${platforms.length} platforms covered`, findings, recommendations: recs };
 }
 function scoreConciseness(body) {
   return {
@@ -40627,16 +40862,19 @@ function scoreSafety2(body) {
     if (lower.includes(kw.toLowerCase()))
       count2++;
   }
-  return { score: density, note: `${count2} safety markers found` };
+  const findings = count2 < 3 ? ["Limited safety markers in config"] : undefined;
+  const recs = count2 < 3 ? ["Add [CRITICAL] markers, safety rules, NEVER directives, and security validation"] : undefined;
+  return { score: density, note: `${count2} safety markers found`, findings, recommendations: recs };
 }
 function evaluateMagent(content, target) {
-  const fmResult = parseFrontmatterSafe(content);
-  const data = fmResult ?? {};
-  const fmNote = fmResult === null ? parseErrorNote(content, "unknown parse error") : null;
   const body = extractBody(content);
+  const hasFrontmatter = /^---\s*$/m.test(content);
+  const fmResult = hasFrontmatter ? parseFrontmatterSafe(content) : undefined;
+  const data = fmResult ?? {};
+  const fmNote = hasFrontmatter && fmResult === null ? parseErrorNote(content, "Frontmatter parse error") : null;
   const dimensions = {
     completeness: scoreCompleteness3(body),
-    "platform-coverage": scorePlatformCoverage(data),
+    "platform-coverage": scorePlatformCoverage(data, body),
     conciseness: scoreConciseness(body),
     "tone-consistency": scoreToneConsistency(body),
     safety: scoreSafety2(body)
@@ -40659,7 +40897,14 @@ var MAGENT_SECTIONS;
 var init_magent = __esm(() => {
   init_heuristics();
   init_types2();
-  MAGENT_SECTIONS = [/^## IDENTITY/m, /^## SOUL/m, /^## AGENTS/m, /^## USER/m];
+  MAGENT_SECTIONS = [
+    { re: /^## .*[Pp]roject|^## .*[Ss]tack/m, label: "project" },
+    { re: /^## .*[Cc]ommand|^## .*[Tt]ool/m, label: "commands" },
+    { re: /^## .*[Vv]erif|^## .*[Tt]est|^## .*[Gg]ate/m, label: "verification" },
+    { re: /^## .*[Cc]onvention|^## .*[Ss]tyle|^## .*[Bb]oundar/m, label: "conventions" },
+    { re: /^## .*[Ss]afety|^## .*[Ss]ecurity|^## .*[Cc]ritical/m, label: "safety" },
+    { re: /^## .*[Dd]oc|^## .*[Rr]eference|^## .*[Rr]outing/m, label: "docs" }
+  ];
 });
 
 // ../../packages/core/src/quality/skill.ts
@@ -40694,7 +40939,17 @@ function scoreCompleteness4(content, data, body) {
   const keySet = new Set(presentKeys);
   const missing = required2.filter((f) => !keySet.has(f));
   const note = missing.length > 0 ? `Missing fields: ${missing.join(", ")}` : "All required fields present";
-  return { score, note };
+  const findings = [];
+  const recommendations = [];
+  if (missing.length > 0) {
+    findings.push(`Missing required frontmatter: ${missing.join(", ")}`);
+    recommendations.push(`Add \`${missing.join("`, `")}\` to YAML frontmatter`);
+  }
+  if (structure < 1) {
+    findings.push("Body lacks section headings (# / ## / ###). Structure aids navigation.");
+    recommendations.push("Organize content with markdown headings for progressive disclosure");
+  }
+  return { score, note, findings, recommendations };
 }
 function scoreClarity2(body) {
   return scoreClarityFromDensities(body);
@@ -40709,7 +40964,16 @@ function scoreTriggerAccuracy(body) {
   } else {
     score = clamp(1 - (count2 - 10) / 10);
   }
-  return { score, note: `${count2} trigger phrases found` };
+  const findings = [];
+  const recommendations = [];
+  if (count2 < 3) {
+    findings.push(`Only ${count2} trigger phrase(s) found; aim for 3\u201310 for reliable skill activation.`);
+    recommendations.push("Add 1\u20132 more When-to-Use scenarios or trigger phrase patterns to the description.");
+  } else if (count2 > 10) {
+    findings.push(`${count2} trigger phrases may cause overlap with adjacent skills.`);
+    recommendations.push("Consolidate overlapping triggers or narrow the activation scope.");
+  }
+  return { score, note: `${count2} trigger phrases found`, findings, recommendations };
 }
 function scoreAntiHallucination(body) {
   const density = keywordDensity(body, [
@@ -40723,10 +40987,16 @@ function scoreAntiHallucination(body) {
     "evidence"
   ]);
   const note = density > 0 ? "Includes verification language" : "Missing verification instructions";
-  return { score: density, note };
+  const findings = [];
+  const recommendations = [];
+  if (density < 0.3) {
+    findings.push("Verification/citation language sparse or absent. Skill may invite fabrication.");
+    recommendations.push('Add explicit "verify with source", "cross-check against docs", or "cite the reference" instructions.');
+  }
+  return { score: density, note, findings, recommendations };
 }
 function scoreConciseness2(body) {
-  const score = scoreLength(body, 500, 5000);
+  const score = scoreLength(body, 500, 15000);
   return { score, note: `Body length: ${body.length} chars` };
 }
 function countTriggerPhrases(body) {
@@ -40791,7 +41061,7 @@ var init_evaluate = __esm(() => {
 // ../../packages/core/src/quality/rubric.ts
 import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 function resolveRubricContent(type, opts) {
   if (opts?.path) {
     if (!existsSync10(opts.path)) {
@@ -40800,15 +41070,15 @@ function resolveRubricContent(type, opts) {
     return readFileSync9(opts.path, "utf-8");
   }
   const homeDir = process.env.HOME ?? homedir3();
-  const userPath = join7(homeDir, ".superskill", "rubrics", `${type}.yaml`);
+  const userPath = join8(homeDir, ".superskill", "rubrics", `${type}.yaml`);
   if (existsSync10(userPath)) {
     return readFileSync9(userPath, "utf-8");
   }
-  const devPath = join7(import.meta.dir, "..", "rubrics", `${type}.yaml`);
+  const devPath = join8(import.meta.dir, "..", "rubrics", `${type}.yaml`);
   if (existsSync10(devPath)) {
     return readFileSync9(devPath, "utf-8");
   }
-  const prodPath = join7(import.meta.dir, "..", "..", "rubrics", `${type}.yaml`);
+  const prodPath = join8(import.meta.dir, "..", "..", "rubrics", `${type}.yaml`);
   if (existsSync10(prodPath)) {
     return readFileSync9(prodPath, "utf-8");
   }
@@ -46639,11 +46909,11 @@ var require_out = __commonJS((exports) => {
     async.read(path7, getSettings(optionsOrSettingsOrCallback), callback);
   }
   exports.stat = stat;
-  function statSync6(path7, optionsOrSettings) {
+  function statSync7(path7, optionsOrSettings) {
     const settings = getSettings(optionsOrSettings);
     return sync.read(path7, settings);
   }
-  exports.statSync = statSync6;
+  exports.statSync = statSync7;
   function getSettings(settingsOrOptions = {}) {
     if (settingsOrOptions instanceof settings_1.default) {
       return settingsOrOptions;
@@ -57813,7 +58083,7 @@ import { join as join52 } from "path";
 import path10, { relative as relative2, resolve as resolve4 } from "path";
 import { basename as basename4, join as join9 } from "path";
 import { join as join72 } from "path";
-import { join as join8 } from "path";
+import { join as join82 } from "path";
 import { join as join10 } from "path";
 import { basename as basename22, join as join11 } from "path";
 import { join as join13 } from "path";
@@ -57886,7 +58156,7 @@ import { join as join79 } from "path";
 import { join as join81 } from "path";
 import { join as join80 } from "path";
 import { join as join84 } from "path";
-import { join as join82 } from "path";
+import { join as join822 } from "path";
 import { join as join83 } from "path";
 import { join as join85 } from "path";
 import { join as join86 } from "path";
@@ -63432,7 +63702,7 @@ var init_chunk_QKQNZ6C3 = __esm(() => {
     constructor({ frontmatter, body, ...rest2 }) {
       const parseResult = RulesyncCommandFrontmatterSchema.safeParse(frontmatter);
       if (!parseResult.success && rest2.validate) {
-        throw new Error(`Invalid frontmatter in ${join8(rest2.outputRoot ?? process.cwd(), rest2.relativeDirPath, rest2.relativeFilePath)}: ${formatError2(parseResult.error)}`);
+        throw new Error(`Invalid frontmatter in ${join82(rest2.outputRoot ?? process.cwd(), rest2.relativeDirPath, rest2.relativeFilePath)}: ${formatError2(parseResult.error)}`);
       }
       const parsedFrontmatter = parseResult.success ? { ...frontmatter, ...parseResult.data } : { ...frontmatter, targets: frontmatter.targets ?? ["*"] };
       super({
@@ -63473,7 +63743,7 @@ var init_chunk_QKQNZ6C3 = __esm(() => {
       } else {
         return {
           success: false,
-          error: new Error(`Invalid frontmatter in ${join8(this.relativeDirPath, this.relativeFilePath)}: ${formatError2(result.error)}`)
+          error: new Error(`Invalid frontmatter in ${join82(this.relativeDirPath, this.relativeFilePath)}: ${formatError2(result.error)}`)
         };
       }
     }
@@ -63481,7 +63751,7 @@ var init_chunk_QKQNZ6C3 = __esm(() => {
       outputRoot = process.cwd(),
       relativeFilePath
     }) {
-      const filePath = join8(outputRoot, _RulesyncCommand.getSettablePaths().relativeDirPath, relativeFilePath);
+      const filePath = join82(outputRoot, _RulesyncCommand.getSettablePaths().relativeDirPath, relativeFilePath);
       const fileContent = await readFileContent(filePath);
       const { frontmatter, body: content } = parseFrontmatter2(fileContent, filePath);
       const result = RulesyncCommandFrontmatterSchema.safeParse(frontmatter);
@@ -69803,9 +70073,9 @@ prompt = ""`;
       return ignoreProcessorToolTargets;
     }
   };
-  AMP_GLOBAL_DIR = join82(".config", "amp");
-  AMP_SKILLS_PROJECT_DIR = join82(AMP_AGENTS_DIR, "skills");
-  AMP_SKILLS_GLOBAL_DIR = join82(".config", "agents", "skills");
+  AMP_GLOBAL_DIR = join822(".config", "amp");
+  AMP_SKILLS_PROJECT_DIR = join822(AMP_AGENTS_DIR, "skills");
+  AMP_SKILLS_GLOBAL_DIR = join822(".config", "agents", "skills");
   EnvVarNameSchema = exports_external3.string().check(refine2((value) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(value), "envVars entries must be valid environment variable names"));
   McpServerSchema = exports_external3.looseObject({
     type: exports_external3.optional(exports_external3.enum(["local", "stdio", "sse", "http", "ws", "streamable-http"])),
@@ -94660,11 +94930,39 @@ function deserializeEvaluation(row) {
 }
 
 // src/operations/evaluate.ts
+async function showHistory(type, contentName, opts) {
+  const adapter = opts.adapter ?? await openStore();
+  const dao = new EvaluationDao(adapter);
+  const rows = await dao.getEvaluations(type, contentName);
+  if (rows.length === 0)
+    return;
+  const cols = { date: 19, agg: 9, verdict: 7 };
+  const lines = [];
+  lines.push(`Evaluation history for ${contentName} (${rows.length} entries):`);
+  lines.push("");
+  const header = `${"Date".padEnd(cols.date)}  ${"Aggregate".padEnd(cols.agg)}  ${"Verdict".padEnd(cols.verdict)}  Scorer`;
+  lines.push(header);
+  lines.push("-".repeat(header.length));
+  for (const row of rows) {
+    const date9 = new Date(row.created_at).toISOString().slice(0, 19).replace("T", " ");
+    const agg = row.aggregate.toFixed(2).padEnd(cols.agg);
+    const verdict = (row.aggregate >= 0.7 ? "PASS" : "FAIL").padEnd(cols.verdict);
+    const scorer = row.scorer ?? "heuristic";
+    const rv = row.rubric_version ? ` v${row.rubric_version}` : "";
+    lines.push(`${date9.padEnd(cols.date)}  ${agg}  ${verdict}  ${scorer}${rv}`);
+  }
+  echo(lines.join(`
+`));
+}
 async function evaluate3(type, nameOrPath, opts) {
   const resolvedPath = resolveContentPath(type, nameOrPath);
   if (!resolvedPath) {
     throw Object.assign(new Error(`File not found: ${nameOrPath}`), { code: 2 });
   }
+  if (opts?.history) {
+    await showHistory(type, resolveContentName(resolvedPath), opts);
+    return null;
+  }
   let content;
   try {
     content = await Bun.file(resolvedPath).text();
@@ -94680,6 +94978,7 @@ async function evaluate3(type, nameOrPath, opts) {
   }
   const report = evaluate(type, content, resolvedTarget);
   report.content = resolveContentName(resolvedPath);
+  applyRubricWeightingAndVerdict(type, report, opts);
   if (opts?.save) {
     await persistEvaluation(type, resolvedPath, resolvedTarget, report, opts);
   }
@@ -94695,11 +94994,30 @@ function computeWeightedAggregate(scores, rubric2) {
   }
   return sum2;
 }
+function applyRubricWeightingAndVerdict(type, report, opts) {
+  try {
+    const rubric2 = loadRubric(type, opts?.rubric ? { path: opts.rubric } : undefined);
+    report.aggregate = computeWeightedAggregate(report.dimensions, rubric2);
+  } catch {}
+  const agg = report.aggregate;
+  report.verdict = agg >= 0.7 ? "PASS" : "FAIL";
+  if (agg >= 0.9)
+    report.grade = "A";
+  else if (agg >= 0.75)
+    report.grade = "B";
+  else if (agg >= 0.6)
+    report.grade = "C";
+  else if (agg >= 0.45)
+    report.grade = "D";
+  else
+    report.grade = "F";
+}
 function emitEnvelope(type, resolvedPath, content, resolvedTarget, opts) {
   const rubric2 = loadRubric(type, { path: opts.rubric });
   const contentName = resolveContentName(resolvedPath);
   const baseline = evaluate(type, content, resolvedTarget);
   baseline.content = contentName;
+  applyRubricWeightingAndVerdict(type, baseline, opts);
   const envelope = {
     type,
     content_name: contentName,
@@ -94811,6 +95129,33 @@ function formatEvaluationReport(report, json3) {
   }
   lines.push(`  ${"\u2500".repeat(maxNameLen)}${"\u2500".repeat(30)}`);
   lines.push(`  ${"AGGREGATE".padEnd(maxNameLen)}  ${report.aggregate.toFixed(2)}`);
+  if (report.verdict || report.grade) {
+    lines.push("");
+    lines.push(`  Verdict: ${report.verdict ?? ""}  Grade: ${report.grade ?? ""}`);
+  }
+  const findings = [];
+  const recommendations = [];
+  for (const name of dimNames) {
+    const dim2 = report.dimensions[name];
+    if (!dim2)
+      continue;
+    if (dim2.findings)
+      findings.push(...dim2.findings.map((f) => `[${name}] ${f}`));
+    if (dim2.recommendations)
+      recommendations.push(...dim2.recommendations.map((r) => `[${name}] ${r}`));
+  }
+  if (findings.length > 0) {
+    lines.push("");
+    lines.push("Findings:");
+    for (const f of findings)
+      lines.push(`  \u2022 ${f}`);
+  }
+  if (recommendations.length > 0) {
+    lines.push("");
+    lines.push("Recommendations:");
+    for (const r of recommendations)
+      lines.push(`  \u2192 ${r}`);
+  }
   return lines.join(`
 `);
 }
@@ -96004,10 +96349,10 @@ import {
   copyFileSync as copyFileSync2,
   existsSync as existsSync14,
   mkdirSync as mkdirSync9,
-  readdirSync as readdirSync3,
+  readdirSync as readdirSync4,
   readFileSync as readFileSync13,
   rmSync as rmSync4,
-  statSync as statSync6,
+  statSync as statSync7,
   writeFileSync as writeFileSync8
 } from "fs";
 import { homedir as homedir5 } from "os";
@@ -96267,7 +96612,7 @@ async function executeInstall(plugin, targets2, options2, dependencies = {}) {
       if (existsSync14(agentsDir) && !options2.dryRun) {
         const piAgentsDir = join223(outputRoot, ".pi", "agent", "agents");
         mkdirSync9(piAgentsDir, { recursive: true });
-        for (const entry of readdirSync3(agentsDir)) {
+        for (const entry of readdirSync4(agentsDir)) {
           if (!entry.endsWith(".md"))
             continue;
           const agentName = entry.replace(/\.md$/, "");
@@ -96332,7 +96677,7 @@ function resolvePluginRoot(plugin, marketplacePath) {
     return { pluginRoot: resolved.pluginRoot, marketplaceRoot: manifestRoot, marketplaceName };
   }
   const fallback = join223("plugins", plugin);
-  if (existsSync14(join223(fallback, "plugin.json")))
+  if (existsSync14(fallback) && readdirSync4(fallback).some((d) => ["skills", "commands", "agents", "hooks", "hooks.json"].includes(d)))
     return { pluginRoot: fallback };
   const available = listResolvablePlugins(marketplacePath);
   const msg = available.length > 0 ? `Available: ${available.join(", ")}` : "No marketplace manifest found and no plugins/<name>/ directory.";
@@ -96369,9 +96714,9 @@ function transformRulesyncMarkdown(root, target, pluginName) {
 function transformMarkdownDirectory(dir, target, pluginName) {
   if (!existsSync14(dir))
     return;
-  for (const entry of readdirSync3(dir)) {
+  for (const entry of readdirSync4(dir)) {
     const path11 = join223(dir, entry);
-    const stats = statSync6(path11);
+    const stats = statSync7(path11);
     if (stats.isDirectory()) {
       transformMarkdownDirectory(path11, target, pluginName);
       continue;
@@ -96388,12 +96733,12 @@ function copyDirectory(source, destination, options2 = {}) {
   if (!existsSync14(source))
     return;
   mkdirSync9(destination, { recursive: true });
-  for (const entry of readdirSync3(source)) {
+  for (const entry of readdirSync4(source)) {
     if (options2.skipDirectoryNames?.has(entry))
       continue;
     const sourcePath = join223(source, entry);
     const destinationPath = join223(destination, entry);
-    if (statSync6(sourcePath).isDirectory()) {
+    if (statSync7(sourcePath).isDirectory()) {
       copyDirectory(sourcePath, destinationPath, options2);
     } else {
       copyFileSync2(sourcePath, destinationPath);
@@ -96695,10 +97040,11 @@ async function skillEvaluate(opts) {
   const report = await evaluate3("skill", opts.nameOrPath, {
     target,
     save: opts.save,
+    history: opts.history,
     ...opts.rubric ? { rubric: opts.rubric } : {},
     ...opts.ingest ? { ingest: opts.ingest } : {}
   });
-  if (report) {
+  if (report && !opts.history) {
     const output2 = formatEvaluationReport(report, opts.json);
     echo(`${output2}`);
   }
@@ -96770,7 +97116,7 @@ function registerSkill(program2) {
   const cmd = program2.command("skill").description("Manage skill definitions");
   addScaffoldOptions(cmd.command("scaffold <name>").description("Create a new skill from template")).action(handleSkillScaffold);
   addStrictOption(addTargetOption(addJsonOption(cmd.command("validate <nameOrPath>").description("Validate a skill file")))).action(handleSkillValidate);
-  addEvaluateOptions(addSaveOption(addTargetOption(addJsonOption(cmd.command("evaluate <nameOrPath>").description("Evaluate skill quality (use --rubric --json for envelope, --ingest --save to persist scores)"))))).action(handleSkillEvaluate);
+  addEvaluateOptions(addSaveOption(addTargetOption(addJsonOption(cmd.command("evaluate <nameOrPath>").description("Evaluate skill quality (use --rubric --json for envelope, --ingest --save to persist scores)").option("--history", "Show prior evaluation rows from the store"))))).action(handleSkillEvaluate);
   addSaveOption(addTargetOption(addAutoOption(cmd.command("refine <nameOrPath>").description("Evaluate and auto-fix a skill")))).action(handleSkillRefine);
   addEvolveOptions(cmd.command("evolve <name>").description("Longitudinal improvement from evaluation history")).action(handleSkillEvolve);
   cmd.command("package <name>").description("Package a skill for distribution").option("-o, --output <dir>", "Output directory (default: cwd)").option("--include-companions", "Include companion configs (metadata.openclaw, agents/)").action(handleSkillPackage);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/superskill",
-    "version": "0.1.7",
+    "version": "0.1.8",
     "description": "A manager for multi-agent skill, slash command, subagent, hook, MCP and etc.",
     "keywords": [
         "cli",

package/rubrics/command.yaml

@@ -4,13 +4,13 @@ dimensions:
   - name: completeness
     weight: 0.25
     criterion: >
-      Does the command cover its stated function end-to-end? Penalize missing
-      argument validation, undocumented flags, and incomplete output. A
-      complete command handles the happy path and the documented error paths.
+      Does the command frontmatter include the required description field
+      and optional-but-expected fields (argument-hint string, allowed-tools array)?
+      A complete command declares its purpose and signals what tools and arguments
+      it uses. Penalize missing description; reward argument-hint and allowed-tools.
     anchors:
-      excellent: "All arguments validated, all flags documented, output covers success and error paths."
-      poor: "Happy path only; argument validation and error paths undocumented."
-
+      excellent: "Description present; argument-hint and allowed-tools declared."
+      poor: "Missing description; no argument-hint or allowed-tools signals."
   - name: clarity
     weight: 0.25
     criterion: >
@@ -24,13 +24,13 @@ dimensions:
   - name: argument-hints
     weight: 0.20
     criterion: >
-      Are argument hints present and accurate? Each argument should have a
-      hint that helps the user supply the right value. Penalize missing hints,
-      hints that restate the argument name, and hints that mislead.
+      Is the argument-hint string clear, descriptive, and consistent with
+      Claude Code conventions? A rich hint names positional args (<agent-name>)
+      and flags ([--description <text>]). Penalize placeholder-only hints or
+      missing hints on commands that take parameters.
     anchors:
-      excellent: "Every argument has a hint that guides the user to the correct value."
-      poor: "Hints missing, or restate the argument name without guidance."
-
+      excellent: "Argument-hint string names positional args and flags with descriptions."
+      poor: "Argument-hint is empty, placeholder-only, or missing on a parameterized command."
   - name: tool-references
     weight: 0.15
     criterion: >

package/rubrics/hook.yaml

@@ -2,41 +2,45 @@ version: 1
 type: hook
 dimensions:
   - name: correctness
-    weight: 0.30
+    weight: 0.25
     criterion: >
-      Does the hook's logic produce the intended effect? Penalize hooks that
-      fire on the wrong event, mutate state the spec says they shouldn't, or
-      exit with the wrong code on a documented path.
+      Does each hook entry have a valid command, type="command", and a non-empty
+      matcher? Penalize entries with missing or empty commands, unrecognized types,
+      or blank matchers.
     anchors:
-      excellent: "Logic matches the spec on every documented path; correct event, mutation, and exit code."
-      poor: "Logic diverges from spec on at least one documented path."
+      excellent: "Every entry has type=command, a non-empty command, and a valid matcher."
+      poor: "Entries missing commands, have invalid types, or have blank matchers."
 
   - name: event-coverage
-    weight: 0.30
+    weight: 0.20
     criterion: >
-      Does the hook handle all events it claims to? Penalize hooks that
-      register for an event but silently no-op on it, or that miss an event
-      the spec requires. Coverage means the hook acts on every registered event.
+      How many lifecycle events are hooked? The canonical event set includes
+      PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd,
+      UserPromptSubmit, PreCompact, and Notification. Broader coverage of
+      appropriate events is better; penalize coverage that misses safety-critical
+      events (e.g. no PreToolUse gate).
     anchors:
-      excellent: "Every registered event has a real handler; no silent no-ops; no missing required events."
-      poor: "Registered events include silent no-ops, or required events are missing."
+      excellent: "Covers multiple lifecycle events including PreToolUse and Stop; breadth matches the hook's purpose."
+      poor: "Covers a single event or misses safety-critical lifecycle events."
 
   - name: safety
-    weight: 0.25
+    weight: 0.35
     criterion: >
-      Does the hook avoid destructive side effects? Penalize hooks that
-      force-push, delete without confirmation, bypass gates, or modify files
-      outside their stated scope. Safety is about blast radius, not just correctness.
+      Do the hook commands avoid dangerous patterns? Scan for rm -rf, curl pipe
+      to shell, --no-verify bypasses, eval, sudo, chmod 777, unquoted command
+      substitution, and backtick execution. Hooks run arbitrary shell — safety
+      is the highest-value dimension.
     anchors:
-      excellent: "No destructive side effect without an explicit guard; blast radius matches stated scope."
-      poor: "Destructive side effects (force-push, delete, bypass) without guards."
+      excellent: "No dangerous patterns; all commands use safe, portable constructs."
+      poor: "Commands contain dangerous patterns (rm -rf, curl|sh, --no-verify) with no guard."
 
   - name: pattern-match-quality
-    weight: 0.15
+    weight: 0.20
     criterion: >
-      Are the matchers precise? Penalize matchers that over-match (fire on
-      unrelated commands) or under-match (miss the intended case). A precise
-      matcher fires on exactly the intended inputs.
+      Are matchers specific (not just *), do entries have timeouts, and are
+      paths portable (using ${CLAUDE_PLUGIN_ROOT} rather than absolute paths)?
+      Penalize broad * matchers on destructive events, missing timeouts, and
+      hardcoded user-specific paths.
     anchors:
-      excellent: "Matchers fire on exactly the intended inputs; no over- or under-matching."
-      poor: "Matchers over-match (fire on unrelated commands) or under-match (miss intended case)."
+      excellent: "Specific matchers, timeouts on every entry, portable paths throughout."
+      poor: "Broad * matchers, missing timeouts, absolute paths tied to a specific user/machine."

package/rubrics/magent.yaml

@@ -4,13 +4,14 @@ dimensions:
   - name: completeness
     weight: 0.25
     criterion: >
-      Does the main-agent config cover its stated scope end-to-end? Penalize
-      missing routing rules, undocumented fallbacks, and gaps between the
-      stated trigger and the actual execution path.
+      Does the main-agent config cover key governance areas: project/stack,
+      commands/tools, verification/testing, conventions/style, safety/security,
+      and documentation/references? Configs may be frontmatter-optional
+      (AGENTS.md/CLAUDE.md are plain markdown by design). Penalize missing
+      governance sections regardless of frontmatter presence.
     anchors:
-      excellent: "Routing, fallbacks, and execution path are fully explicit; no implicit steps."
-      poor: "Scope claims coverage but routing or fallbacks are implicit."
-
+      excellent: "All governance areas covered; project, commands, verification, conventions, safety, docs."
+      poor: "Few governance sections; config is mostly unstructured or bare."
   - name: platform-coverage
     weight: 0.25
     criterion: >